leetcode-1111.有效括号的嵌套深度(Python实现)

题目描述

有效括号字符串 仅由 “(” 和 “)” 构成，并符合下述几个条件之一：

• 空字符串

• 连接，可以记作 AB（A 与 B 连接），其中 A 和 B 都是有效括号字符串

• 嵌套，可以记作 (A)，其中 A 是有效括号字符串
  类似地，我们可以定义任意有效括号字符串 s 的 嵌套深度 depth(S)：

• s 为空时，depth("") = 0

• s 为 A 与 B 连接时，depth(A + B) = max(depth(A), depth(B))，其中 A 和 B 都是有效括号字符串

• s 为嵌套情况，depth("(" + A + “)”) = 1 + depth(A)，其中 A 是有效括号字符串
  例如：""，"()()"，和 “()(()())” 都是有效括号字符串，嵌套深度分别为 0，1，2，而 “)(” 和 “(()” 都不是有效括号字符串。

给你一个有效括号字符串 seq，将其分成两个不相交的子序列 A 和 B，且 A 和 B 满足有效括号字符串的定义（注意：A.length + B.length = seq.length）。

现在，你需要从中选出 任意 一组有效括号字符串 A 和 B，使 max(depth(A), depth(B)) 的可能取值最小。

返回长度为 seq.length 答案数组 answer ，选择 A 还是 B 的编码规则是：如果 seq[i] 是 A 的一部分，那么 answer[i] = 0。否则，answer[i] = 1。即便有多个满足要求的答案存在，你也只需返回 一个。

示例1

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

示例2

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

提示

1 <= text.size <= 10000

解题思路

Seq = ( ( ) ( ( ) ) ( ) )

嵌套深度 = [ 1, 2, 2, 2, 3, 3, 2, 2, 2, 1]

分组情况 = [ A, B, B, B, A, A, B, B, B, A]

输出 = [ 0, 1, 1, 1, 0, 0, 1, 1, 1, 0]

其中把A或B下标的括号单独抽出来，均为合法括号

当且仅当字符串同时包含"(“与”)"，且满足以下条件时，称为包含括号的有效字符串():

空字符串；
或者，为AB相联的形式，其中 A与B均为包含括号的有效字符串；// 因为A、B均为包含括号的有效字符串，A="()"，B="(())"。A或B还有可能是嵌套的
或者，为(A)，其中A为包含括号的有效字符串；// 因为A为包含括号的有效字符串，所以可以理解成：A="()"时，(A) = “(())”
包含括号的有效字符串嵌套按以下公式计算：

depth("") = 0； // 对应上面的1
depth(A + B) = max(depth(A), depth(B))；// 对应上面的2，其中的A和B均为包含括号的有效字符串
depth("(" + A + “)”) = 1 + depth(A); // 对应上面的3，1指的是depth()中的由引号包上的一对括号
比如：

“”：深度为0； // 没有括号，所以为0
“()()”：深度为1； // 有括号，但只有一层
“()(()())”：深度为2；// 括号包含了括号，所以为二层 “)(”, "(()"都不算包含括号的有效字符串。 // 不成对
给定一个包含括号的有效字符串，将其拆分为不相交的两个子串A与B(拆分后的A与B也必须是包含括号的有效字符串，且两个字符串长度相加等于原字符串长度, A.length + B.length = seq.length)。 // 这里应该可以拆成A为原字符串，B为空这种情况吧？

如何拆分才能使得A与B能得到最小的嵌套等级(max(depth(A), depth(B))。// 对于seq = “(()())“来说，可以拆成A=”(()())”，B=""。A=""，B="(()())"。A="(A)"，其中的A为"()()"(还能再拆成A + B的形式？)，B=""等，不知道理解的是不是对？？

返回包含与原串长度相等的答案，并放到一个数组中。这个数组只包含0或1，规则是：

0：表示嵌套深度来自A子串；

1：表示嵌套深度来自B子串；

代码实现

class Solution:
    def maxDepthAfterSplit(self, seq: str) -> List[int]:
        return [i & 1 ^ (c == '(') for i, c in enumerate(seq)]

class Solution:
    def maxDepthAfterSplit(self, seq: str) -> List[int]:
        flg = []
        s1 = []
        s2 = []
        ans = []
        for c in seq:
            if c == '(':
                if len(s1) <= len(s2):
                    s1.append(c)
                    ans.append(0)
                    flg.append(0)
                else:
                    s2.append(c)
                    ans.append(1)
                    flg.append(1)
            else:
                f = flg.pop()
                if f == 0:
                    ans.append(0)
                    s1.pop()
                else:
                    ans.append(1)
                    s2.pop()
        return ans