栈的括号问题（2）

856. 括号的分数
给定一个平衡括号字符串 S，按下述规则计算该字符串的分数：

() 得 1 分。
AB 得 A + B 分，其中 A 和 B 是平衡括号字符串。
(A) 得 2 * A 分，其中 A 是平衡括号字符串。

class Solution:
    def scoreOfParentheses(self, S: str) -> int:
        stack = []
        res = 0
        for i in S:
            if i=="(":
                stack.append(res)
                res = 0
            elif i==")":
                p = stack.pop()
                res = p + 1 if res == 0 else p + 2 * res
            else:
                res += int(i)
        return res

1111. 有效括号的嵌套深度
有效括号字符串 定义：对于每个左括号，都能找到与之对应的右括号，反之亦然。详情参见题末「有效括号字符串」部分。
class Solution:
    def maxDepthAfterSplit(self, seq: str) -> List[int]:
        cnt = 0
        res = []
        for c in seq:
            if c == '(':
                cnt += 1
                res.append(cnt&1)
            else:
                res.append(cnt&1)
                cnt -= 1
        return res

921. 使括号有效的最少添加
给定一个由 '(' 和 ')' 括号组成的字符串 S，我们需要添加最少的括号（ '(' 或是 ')'，可以在任何位置），以使得到的括号字符串有效。
从形式上讲，只有满足下面几点之一，括号字符串才是有效的：
它是一个空字符串，或者
它可以被写成 AB （A 与 B 连接）, 其中 A 和 B 都是有效字符串，或者
它可以被写作 (A)，其中 A 是有效字符串。
给定一个括号字符串，返回为使结果字符串有效而必须添加的最少括号数。

示例 1：

输入："())"
输出：1
示例 2：
输入："((("
输出：3

class Solution:
    def minAddToMakeValid(self, S: str) -> int:
        ans = 0 
        count = 0
        for i in S:
            if i == '(':
                ans += 1
            else:
                ans -= 1
                #处理右边》左边的实例。将右边多出的记录先来。
            if ans < 0:
                count += 1
                ans += 1
        count += ans
        return count

class Solution:
    def minAddToMakeValid(self, S: str) -> int:
        i = 0
        while True:
            S = S.replace("()",'')
            S_len = len(S)
            if i != S_len:
                i = S_len
            else:
                break
        return i

class Solution(object):
    def minAddToMakeValid(self, S):
        """
        :type S: str
        :rtype: int
        """
        myStack = []
        res = 0
        for item in S:
            if item == ')':
                if myStack and myStack[-1] == '(':
                    myStack.pop()
                else:
                    res += 1
            else:
                myStack.append(item)
        res += len(myStack)
        return res

1249. 移除无效的括号
给你一个由 '('、')' 和小写字母组成的字符串 s。
你需要从字符串中删除最少数目的 '(' 或者 ')' （可以删除任意位置的括号)，使得剩下的「括号字符串」有效。
请返回任意一个合法字符串。
有效「括号字符串」应当符合以下 任意一条 要求：
空字符串或只包含小写字母的字符串
可以被写作 AB（A 连接 B）的字符串，其中 A 和 B 都是有效「括号字符串」
可以被写作 (A) 的字符串，其中 A 是一个有效的「括号字符串」
示例 1：
输入：s = "lee(t(c)o)de)"
输出："lee(t(c)o)de"
解释："lee(t(co)de)" , "lee(t(c)ode)" 也是一个可行答案

class Solution:
    def minRemoveToMakeValid(self, s: str) -> str:
        #使用栈的方式记录‘（’或者‘）’的位置。最后使用新的栈剥离不合适的数据（索引处理）
        stack_left ,stack_right = [] , []
        for i in range(len(s)):
            if s[i] == "(":
                stack_left.append(i)
            elif s[i] == ")":
                if not stack_left:
                    stack_right.append(i)
                else:
                    stack_left.pop()

        tmp = []
        for i in range(len(s)):
            if i not in stack_left and i not in stack_right:
                tmp.append(s[i])
        return "".join(tmp)