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 withB
), whereA
andB
are VPS's, or - It can be written as
(A)
, whereA
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))
, whereA
andB
are VPS'sdepth("(" + A + ")") = 1 + depth(A)
, whereA
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;
}
};
法二:找规律
大致思路是,对于每层的(),一层分给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;
}
};