【leetcode】【medium】【每日一題】1111. Maximum Nesting Depth of Two Valid Parentheses Strings

1111. Maximum Nesting Depth of Two Valid Parentheses Strings

A string is a valid parentheses string (denoted VPS) if and only if it consists of "(" and ")" characters only, and:

• It is the empty string, or
• It can be written as AB (A concatenated with B), where A and B are VPS's, or
• It can be written as (A), where A is a VPS.

We can similarly define the nesting depth depth(S) of any VPS S as follows:

• depth("") = 0
• depth(A + B) = max(depth(A), depth(B)), where A and B are VPS's
• depth("(" + A + ")") = 1 + depth(A), where A is a VPS.

For example,  "", "()()", and "()(()())" are VPS's (with nesting depths 0, 1, and 2), and ")(" and "(()" are not VPS's.

Given a VPS seq, split it into two disjoint subsequences A and B, such that A and B are VPS's (and A.length + B.length = seq.length).

Now choose any such A and B such that max(depth(A), depth(B)) is the minimum possible value.

Return an answer array (of length seq.length) that encodes such a choice of A and B:  answer[i] = 0 if seq[i] is part of A, else answer[i] = 1.  Note that even though multiple answers may exist, you may return any of them.

Example 1:

Input: seq = "(()())"
Output: [0,1,1,1,1,0]

Example 2:

Input: seq = "()(())()"
Output: [0,0,0,1,1,0,1,1]

Constraints:

• 1 <= seq.size <= 10000

題目鏈接：https://leetcode-cn.com/problems/maximum-nesting-depth-of-two-valid-parentheses-strings/

 

思路

法一：模擬法

模擬人的解題思路：先找到字符串深度是多少，把深度劈成2半，小於等於一半深度的爲A，大於爲B。

class Solution {
public:
    vector<int> maxDepthAfterSplit(string seq) {
        vector<int> ans;
        if(seq.size()<=1) return ans;
        int len = 0, maxlen = 0;
        for(int i=0; i<seq.size(); ++i){
            if(seq[i]=='('){
                ++len;
                maxlen = max(maxlen, len);
            }else{
                --len;
            }
        }
        len = 0;
        for(int i=0; i<seq.size(); ++i){
            if(seq[i]=='('){
                ++len;
            }
            if(len<=maxlen/2){
                ans.push_back(0);
            }else{
                ans.push_back(1);
            }
            if(seq[i]==')'){
                --len;
            }
        }
        return ans;
    }
};

 

法二：找規律

這個方法由他人分享獲得的：https://leetcode-cn.com/problems/maximum-nesting-depth-of-two-valid-parentheses-strings/solution/you-xiao-gua-hao-de-qian-tao-shen-du-by-leetcode-s/

大致思路是，對於每層的()，一層分給A，一層分給B，這樣交替就能平均分，而交替規律可由其在字符串中位置的下標得到。

seq： ( ( ) ( ( ) ) ( ) )
下標： 0 1 2 3 4 5 6 7 8 9
層數： 1 2 2 2 3 3 2 2 2 1

規律：

1）字符爲'('時，偶數下標 = 奇數層數，奇數下標 = 偶數層數；

2）字符爲')'時，偶數下標 = 偶數層數，奇數下標 = 奇數層數。

只要把偶數層數分給A，奇數層數分給B即可。

class Solution {
public:
    vector<int> maxDepthAfterSplit(string seq) {
        vector<int> ans;
        if(seq.size()<=1) return ans;
        for(int i=0; i<seq.size(); ++i){
            if(seq[i]=='('){
                if(i%2==0){
                    ans.push_back(0);
                }else{
                    ans.push_back(1);
                }
            }else{
                if(i%2==0){
                    ans.push_back(1);
                }else{
                    ans.push_back(0);
                }
            }
        }
        return ans;
    }
};