动态规划总结

5. 最长回文子串(中等)

题目

给你一个字符串 s，找到 s 中最长的回文子串。

思路

for 依次遍历字符串：
	向左扩展直到字符不同，l-1>=0
	向右扩展直到字符不同，r+1<=len(s)-1
	(保证中间的字符一样)
	l-1>=0 and  r+1<=len(s)-1  and  s[l-1]==s[r+1] 
	(保证左右字符相同)
	如果 回文长度>max:
		记录 l  max
		return  s[l:l+max]

代码

###Python
class Solution:
    def longestPalindrome(self, s: str) -> str:
            max=0
            l_end=0
            for i in range(0,len(s)):
                l=i
                r=i
                length=1
                while(r+1<=len(s)-1):
                    #print(1)
                    if s[r]==s[r+1]:
                        r+=1
                        length+=1
                    else:
                        break
                while(l-1>=0):
                    #print(2)
                    if s[l]==s[l-1]:
                        l-=1
                        length+=1
                    else:
                        break
                while(r+1<=len(s)-1 and l-1>=0):
                   # print(3)
                    if s[l-1]==s[r+1]:
                        l-=1
                        r+=1
                        length+=2
                    else:
                        break
                if length > max:
                    max=length
                    l_end=l
            return s[l_end:l_end+max]

95. 不同的二叉搜索树 II（中等）

题目

给你一个整数 n ，请你生成并返回所有由 n 个节点组成
且节点值从 1 到 n 互不相同的不同 二叉搜索树 。可以按 任意顺序 返回答案。

思路+代码

搜索二叉树:结点>左子树的数，结点<右子树的数

递归
for i  in  range(1,n+1):
	依次求左，右子树的搜索二叉树
	需要递归，不断的求搜索二叉树，直到为None

#Python
class Solution:
    def generateTrees(self, n: int) -> List[TreeNode]:
        def smallTrees(head, end):
            if head > end:
                return [None,]
            Trees = []
            for i in range(head, end + 1): 
                leftTrees = smallTrees(head, i - 1)
                rightTrees = smallTrees(i + 1, end)
                for l in leftTrees:
                    for r in rightTrees:
                        newTree = TreeNode(i)
                        newTree.left = l
                        newTree.right = r
                        Trees.append(newTree)
            return Trees
        return smallTrees(1, n) if n else []

96. 不同的二叉搜索树(中等)

题目

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 
有多少种？返回满足题意的二叉搜索树的种数。
输入：n = 3
输出：5

输入：n = 1
输出：1

思路+代码

需要依次将每个数字当一次根节点，求其子树总和。
其种类数为 = 左子树个数 * 右子树个数
因为子树种类的数量有节点数决定，所以可以直接计算。不需要构建搜索二叉树。

可以利用动态规划，利用 A[ i ] 求 A[ i+1 ] 。

#python
class Solution:
    def numTrees(self, n: int) -> int:
        A=[0]*(n+1)
        A[0]=1
        A[1]=1
        for i in range(2,n+1):
            for j in range(1,i+1):
                A[i]+=A[j-1]*A[i-j]
        return A[n]
#c++
class Solution {
public:
    int numTrees(int n) {
        vector<int> A(n+1,0);
        A[0]=1;
        A[1]=1;
        for (int i=2;i<=n;i++){
            for(int j=1;j<=i;j++){
                A[i]+=A[j-1]*A[i-j];
            }
        }
        return A[n];
    }
};
#java	
class Solution {
    public int numTrees(int n) {
        int[] A = new int[n+1];
        A[0]=1;
        A[1]=1;
        for (int i=2;i<=n;i++){
            for(int j=1;j<=i;j++){
                A[i]+=A[j-1]*A[i-j];
            }
        }
        return A[n];

    }
}