1111.Maximum Nesting Depth of Two Valid Parentheses Strings

Tags: Medium Greedy

Links: https://leetcode.com/problems/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

---

class Solution {
public:
    vector<int> maxDepthAfterSplit(string seq) {
        std::ios_base::sync_with_stdio(false);
        cin.tie(NULL);
        cout.tie(NULL);

        int n = seq.size();
        int maxDepth = 0;
        int tmp = 0;
        vector<int> d(n, 0);
        for (int i = 0; i < n; ++i) {
            if (seq[i] == '(') d[i] = ++tmp;
            else d[i] = tmp--;
            maxDepth = max(maxDepth, tmp);
        }

        maxDepth >>= 1;
        vector<int> res(n);
        for (int i = 0; i < n; ++i) {
            if (d[i] <= maxDepth) res[i] = 0;
            else res[i] = 1;
        }

        return res;
    }
};

我们可以通过一次遍历，求出每个位置的深度，求出最大的深度。具体过程为，我们维护一个当前左括号的数量 d，如果新遇到一个左括号，则 d++，更新当前位置的深度为 tmp；否则先更新当前位置的深度为 tmp，然后 tmp--。 采用贪心策略，显然将深度最大的部分尽量分为两部分。于是，我们在深度小于等于 tnp的地方划分给 A，其余的地方划分给 B，这样能保证最大的深度一定最小。