栈的括号问题

20. 有效的括号
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:
输入: "()"
输出: true

class Solution:
    def isValid(self, s: str) -> bool:
        dic = {')':'(',']':'[','}':'{'}
        stack = []
        for i in s:
            if stack and i in dic:
                if stack[-1] == dic[i]: stack.pop()
                else: return False
            else: stack.append(i)
            
        return not stack

1021. 删除最外层的括号
有效括号字符串为空 ("")、"(" + A + ")" 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。例如，""，"()"，"(())()" 和 "(()(()))" 都是有效的括号字符串。

如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。
给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + ... + P_k，其中 P_i 是有效括号字符串原语。
对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。

示例 1：
输入："(()())(())"
输出："()()()"
解释：
输入字符串为 "(()())(())"，原语化分解得到 "(()())" + "(())"，
删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。

class Solution:
    def removeOuterParentheses(self, S: str) -> str:
        mark = 0
        stack = []
        for s in S:
            if s == '(':
                if mark != 0:
                    stack.append(s)
                mark += 1
            if s == ')':
                mark -= 1
                if mark != 0:
                    stack.append(s)
        return ''.join(stack)


class Solution:
    def removeOuterParentheses(self, S: str) -> str:
        temp_str = []
        stack = []
        res = ""
        for i in S:
            temp_str.append(i)
            if i == "(":
                stack.append(i)
            if i == ")":
                stack.pop()

            if not stack:#若空栈，则证明为一段原语
                if len(temp_str)>2:
                    #只有取第二个到倒数第二个
                    res += ''.join(temp_str[1:-1])
                #解决()(),输出)(的非言语
                temp_str = []
        return res

 

606. 根据二叉树创建字符串
你需要采用前序遍历的方式，将一个二叉树转换成一个由括号和整数组成的字符串。

空节点则用一对空括号 "()" 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。

示例 1:

输入: 二叉树: [1,2,3,4]
       1
     /   \
    2     3
   /    
  4     

输出: "1(2(4))(3)"

解释: 原本将是“1(2(4)())(3())”，
在你省略所有不必要的空括号对之后，
它将是“1(2(4))(3)”。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def tree2str(self, t: TreeNode) -> str:
        def dfs(root):
            if not root:return ''
            if not root.left and not root.right:
                return str(root.val)
            if root.left:
                l = dfs(root.left)
                ls = '('+l+')'
            else:ls='()'
            if root.right:
                r = dfs(root.right)
                rs = '('+r+')'
            else:rs=''
            return str(root.val)+ls+rs
        res = dfs(t)
        return res