Leetcode题解 0026期

电脑电池炸了……非常丢人了，今天跑了一趟维修点……甚至不想买电池，今天三道题

0095题 不同的二叉搜索树 II【Unique Binary Search Trees II】

题目：
给定一个整数 n，生成所有由 1 … n 为节点所组成的二叉搜索树。
示例：

输入: 3
输出:
[
  [1,null,3,2],
  [3,2,null,1],
  [3,1,null,null,2],
  [2,1,3],
  [1,null,2,null,3]
]
解释:
以上的输出对应以下 5 种不同结构的二叉搜索树：

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

题目不严谨之处：
1. 应该表明n是正整数

除Robust以外无需注意太多

解题思路：
这题数量级肯定是爆炸的，因为这个应该和卡特兰数有bijection，可以证。
但是这样只能输出最后有多少种情况，这道题还让输出每种情况是什么，所以采用递归加DFS
其实这种题最难做的原因是因为一旦出错，代码贼难在本地调试，只能在playground里面各种操作。

class Solution:
    def dfs(self, left, right, res):
        if left > right: res.append(None); return
        left_res = list()
        right_res = list()
        for i in range(left, right+1):
            self.dfs(left, i-1, left_res)
            self.dfs(i+1, right, right_res)
            l = len(left_res)
            r = len(right_res)
            for j in range(l):
                for k in range(r):
                    root = TreeNode(i)
                    root.left = left_res[j]
                    root.right = right_res[k]
                    res.append(root)
            left_res = list()
            right_res = list()

    def generateTrees(self, n):
        res = []
        if n <= 0: return res
        self.dfs(1,n,res)
        return res

果不其然，测试数据只有9组，而且我怀疑有一组还是robust性的……

---

0096题 不同的二叉搜索树【Unique Binary Search Trees】

题目：
给定一个整数 n，求以 1 … n 为节点组成的二叉搜索树有多少种？
示例：

输入: 3
输出: 5
解释:
给定 n = 3, 一共有 5 种不同结构的二叉搜索树:

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

题目不严谨之处和上题一样

除Robust外无需注意太多

解题思路：
上一道题也提到了，这就是卡特兰数。其实原因很简单，因为卡特兰数最著名的例子就是那个括号的种类或者山丘种类，想一想二叉树和那种例题的相似之处，就豁然开朗了，离散数学了解一下……emm，直接代码公式一行带走

import math
class Solution:
    def numTrees(self, n):
        return int(math.factorial(2*n)//(math.factorial(n)**2))//(n+1)

---

0097题 交错字符串【Interleaving String】

题目：
给定三个字符串 s1, s2, s3, 验证 s3 是否是由 s1 和 s2 交错组成的。
示例：

输入: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
输出: true

输入: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
输出: false

题目相对严谨

除Robust外无需注意太多

解题思路：
其实这种字符串匹配的，尤其是两个字符串匹配的题目所使用的动态规划，可以归类为路线类动态规划？反正就是某位配某位看看行不行得通，就类似这样的问题，所以这道题也是同样打表来算。

class Solution:
    def isInterleave(self, s1, s2, s3):
        n1 = len(s1)
        n2 = len(s2)
        if n1 + n2 != len(s3): return False
        if sorted(list(s1)+list(s2)) != sorted(list(s3)): return False
        res = [[False for col in range(n2+1)] for row in range(n1+1)]
        # res[0][0] = True
        for i in range(n1+1):
            for j in range(n2+1):
                if i == 0 and j == 0:
                    res[i][j] = True
                elif i == 0:
                    res[i][j] = res[i][j-1] and (s2[j-1]==s3[j-1])
                elif j == 0:
                    res[i][j] = res[i-1][j] and (s1[i-1]==s3[i-1])
                else:
                    res[i][j] = (res[i][j-1] and (s2[j-1]==s3[i+j-1])) or (res[i-1][j] and (s1[i-1]==s3[i+j-1]))

        return res[n1][n2]