DFS+回溯专题12 - leetcode95. Unique Binary Search Trees II/394. Decode String - Mark

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/a786150017/article/details/84973168

95. Unique Binary Search Trees II

题目描述

给定整数n，产生存储1…n的结构上唯一的二叉搜索树。

例子

Input: 3
Output:
[
[1,null,3,2],
[3,2,null,1],
[3,1,null,null,2],
[2,1,3],
[1,null,2,null,3]
]

思想
注意输出的是合法根节点的列表。
DFS输入是所存储数的范围，遍历该范围选定root，然后递归求得left和right。

(改进) 字典存储曾经处理过的范围

解法

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

class Solution(object):
    def generateTrees(self, n):
        """
        :type n: int
        :rtype: List[TreeNode]
        """
        if n <= 0:
            return []
        return self.dfs(1, n)
    
    def dfs(self, start, end):
        if start > end:
            return [None]
        res = []
        for root in range(start, end+1):
            for left in self.dfs(start, root-1):
                for right in self.dfs(root+1, end):
                    node = TreeNode(root)
                    node.left = left
                    node.right = right
                    res.append(node)
        return res

改进：字典

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

class Solution(object):
    def generateTrees(self, n):
        """
        :type n: int
        :rtype: List[TreeNode]
        """
        if n <= 0:
            return []
        self.cache = {}
        return self.dfs(1, n)
    
    def dfs(self, start, end):
        if start > end:
            return [None]
        if (start, end) not in self.cache:
            res = []
            for root in range(start, end+1):
                for left in self.dfs(start, root-1):
                    for right in self.dfs(root+1, end):
                        node = TreeNode(root)
                        node.left = left
                        node.right = right
                        res.append(node)
            self.cache[(start, end)] = res
        return self.cache[(start, end)]

394. Decode String

题目描述

给定一个已经编码的字符串，返回解码后的字符串。
编码规则：k[encoded_string]表示字符串encoded_string重复k次。

保证k是正整数；假设输入合法；没有额外的空格、方括号格式正确。假设原始数据不包含数字，只有重复次数是数字。

例子

s = “3[a]2[bc]”, return “aaabcbc”.
s = “3[a2[c]]”, return “accaccacc”.
s = “2[abc]3[cd]ef”, return “abcabccdcdcdef”.

思想
一个比较棘手的例子是3[a2[c]]。可以看出只有遇到字符 ‘]’ 时，才考虑解码操作。
(法1 - DFS)
DFS主体：遍历字符串，截取出数字部分，和数字后面的方括号部分（该部分DFS - decodeString）.
截止条件：方括号部分只包含字符时，直接返回该字符；否则接着按递归遍历。

(法2 - 栈)
需存储数字和字符串。遇到 ']‘时才进行弹出和计算处理；处理后记着继续压栈，例如该情况’3[a2[c]]’。

解法1
DFS

class Solution(object):
    def decodeString(self, s):
        """
        :type s: str
        :rtype: str
        """
        res = ''
        i = 0
        while i < len(s):
            if not s[i].isdigit() and s[i] != '[' and s[i] != ']':
                res += s[i]
                i += 1
            else:
                # Get repeat-times
                j = i
                while '0' <= s[j] <= '9':
                    j += 1
                repeat = int(s[i:j])
                # Get the strings between square brackets
                cnt = 0
                i = j + 1
                while i < len(s) and cnt >= 0:
                    if s[i] == '[':
                        cnt += 1
                    elif s[i] == ']':
                        cnt -= 1
                    i += 1
                res += repeat * self.decodeString(s[j+1:i-1])
        return res

解法2
栈

class Solution(object):
    def decodeString(self, s):
        """
        :type s: str
        :rtype: str
        """
        num = 0
        stack = [['', '']]
        for c in s:
            if '0' <= c <= '9':
                num = num * 10 + ord(c) - 48
            elif c == '[':
                stack.append([num, ''])
                num = 0
            elif c == ']':
                k, ss = stack.pop()
                stack[-1][1] += k * ss
            else:
                stack[-1][1] += c
        return stack[0][1]