Leetcode--有效括號的嵌套深度

有效括號字符串 定義：對於每個左括號，都能找到與之對應的右括號，反之亦然。詳情參見題末「有效括號字符串」部分。

嵌套深度 depth 定義：即有效括號字符串嵌套的層數，depth(A) 表示有效括號字符串 A 的嵌套深度。詳情參見題末「嵌套深度」部分。

 

給你一個「有效括號字符串」 seq，請你將其分成兩個不相交的有效括號字符串，A 和 B，並使這兩個字符串的深度最小。

不相交：每個 seq[i] 只能分給 A 和 B 二者中的一個，不能既屬於 A 也屬於 B 。
A 或 B 中的元素在原字符串中可以不連續。
A.length + B.length = seq.length
max(depth(A), depth(B)) 的可能取值最小。
劃分方案用一個長度爲 seq.length 的答案數組 answer 表示，編碼規則如下：

answer[i] = 0，seq[i] 分給 A 。
answer[i] = 1，seq[i] 分給 B 。
如果存在多個滿足要求的答案，只需返回其中任意 一個 即可。

 

示例 1：

輸入：seq = "(()())"
輸出：[0,1,1,1,1,0]
示例 2：

輸入：seq = "()(())()"
輸出：[0,0,0,1,1,0,1,1]
 

提示：

1 <= text.size <= 10000
 

有效括號字符串：

僅由 "(" 和 ")" 構成的字符串，對於每個左括號，都能找到與之對應的右括號，反之亦然。
下述幾種情況同樣屬於有效括號字符串：

  1. 空字符串
  2. 連接，可以記作 AB（A 與 B 連接），其中 A 和 B 都是有效括號字符串
  3. 嵌套，可以記作 (A)，其中 A 是有效括號字符串
嵌套深度：

類似地，我們可以定義任意有效括號字符串 s 的 嵌套深度 depth(S)：

  1. s 爲空時，depth("") = 0
  2. s 爲 A 與 B 連接時，depth(A + B) = max(depth(A), depth(B))，其中 A 和 B 都是有效括號字符串
  3. s 爲嵌套情況，depth("(" + A + ")") = 1 + depth(A)，其中 A 是有效括號字符串

例如：""，"()()"，和 "()(()())" 都是有效括號字符串，嵌套深度分別爲 0，1，2，而 ")(" 和 "(()" 都不是有效括號字符串。

思路

如果要A和B的嵌套深度的最大值儘量小，則對之前的最大嵌套深度進行對半分，大於一半的分給B，小於一半的分給A；

原始嵌套深度可以使用括號匹配的方法來計算，

 當遍歷到字符 ')' 時，此時棧的大小便是當前括號的嵌套深度

class Solution {
public:
    vector<int> maxDepthAfterSplit(string seq) {
        // int型的最小值
        int maxDepth= 0x80000000;
        stack<int> st;
        int len= seq.length();
        // 記錄每個'('的下標
        vector<int> depthArray(len, 0);
        for(int i= 0; i< len; i++){
            if(seq[i]== '('){
                st.push(i);
            }
            else{
                // 括號的嵌套深度等於當前棧的大小，並更新最大的嵌套深度
                depthArray[st.top()]= depthArray[i]= st.size();
                maxDepth= maxDepth> (int)st.size()? maxDepth: (int)st.size();
                st.pop();
            }
        }
        maxDepth/= 2;

        // 嵌套深度大於最大嵌套深度的一半的括號分給B，反之分給A
        for(int i= 0; i< len; i++)
            depthArray[i]= int(depthArray[i]> maxDepth);
        return depthArray;
    }
};