Leetcode 24——二叉搜索树的情况，二叉搜索树的验证，三角形的路径和

leetcode95:
给定一个整数 n，求以 1 … n 为节点组成的二叉搜索树有多少种？
示例:
输入: 3
输出: 5
解释:
给定 n = 3, 一共有 5 种不同结构的二叉搜索树:

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

**解析：其实类似于矩阵链，但是简单于矩阵链，也是动态规划的问题
dp[i]代表i个节点能够组成多少棵树，所以其实
dp[i]=dp[0]*d[i-1]+dp[1]*d[i-2]-------dp[i-1]*dp[0]就表示i个节点组成多少棵树
为什么是乘法？
因为若以节点j为根节点，则根左有dp[j-1]棵树，根右有dp[i-1]棵树，两面的树是排列组合的，所以乘法
最关键的是，因为dp[0]*d[i-1]+dp[1]d[i-2]-------dp[i-1]dp[0]中下标都是小于i的，所以直接一个for就好了，下标自动存储

class Solution {
public int numTrees(int n) {
int []dp=new int [n+1];
dp[0]=1;
dp[1]=1;
for(int i=2;i<=n;i++){
for(int j=1;j<=i;j++){
dp[i]+=dp[i-j]*dp[j-1];
}
}
return dp[n];
}
}

给定一个整数 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

解析：进阶版。有多少棵树。
思想仍然是上面的思想，只不过对于n个节点，中间每个节点都能作为根
所以for(i=1;i<=n;i++)表示每一个节点作为根的情况
其中对于节点J
而leftTrees代表1-(j-1)个节点分别作为根的时候的情况，leftTrees里一共有j-1个根
rightTreess代表(n-j)个节点作为根的时候的情况，rightTrees里一共有n-j个根
利用 for (TreeNode leftTree : leftTrees) {
for (TreeNode rightTree : rightTrees) 将其组合，得到结果

class Solution {
public List generateTrees(int n) {
List ans = new ArrayList();
if (n == 0) {
return ans;
}
return getAns(1, n);

}
private List getAns(int start, int end) {
List ans = new ArrayList();
//此时没有数字，将 null 加入结果中
if (start > end) {
ans.add(null);
return ans;
}
//只有一个数字，当前数字作为一棵树加入结果中
if (start == end) {
TreeNode tree = new TreeNode(start);
ans.add(tree);
return ans;
}
//尝试每个数字作为根节点
for (int i = start; i <= end; i++) {
//得到所有可能的左子树
List leftTrees = getAns(start, i - 1);
//得到所有可能的右子树
List rightTrees = getAns(i + 1, end);
//左子树右子树两两组合
for (TreeNode leftTree : leftTrees) {
for (TreeNode rightTree : rightTrees) {
TreeNode root = new TreeNode(i);
root.left = leftTree;
root.right = rightTree;
//加入到最终结果中
ans.add(root);
}
}
}
return ans;
}
}

leetcode98
给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:
输入:
2
/
1 3
输出: true
示例 2:

输入:
5
/
1 4
/
3 6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
根节点的值为 5 ，但是其右子节点值为 4 。

解析：关键在于传入子方法的时候传入上界限和下界限
但是有Integer.MAX_VALUE和Integer.MIN_VALUE的边界值问题，要单独讨论【当然也可以直接Long】所以设置了minflag和maxflag
为什么要单独讨论？
因为在return judgeTree(root,Integer.MAX_VALUE,Integer.MIN_VALUE,0,0);时候，你的上界和下界只能传入Integer.MAX_VALUE,Integer.MIN_VALUE，并且判断符合二叉搜索树的条件是 if(root.val<maxValue&&root.val>minValue){
而作为子节点值是允许等于Integer.MAX_VALUE,Integer.MIN_VALUE的，所以会存在错误。

class Solution {
public boolean isValidBST(TreeNode root) {
if(rootnull) return true;
return judgeTree(root,Integer.MAX_VALUE,Integer.MIN_VALUE,0,0);
}
public boolean judgeTree(TreeNode root,int maxValue,int minValue,int minflag,int maxflag){
if(rootnull)return true;
if(root.valInteger.MAX_VALUE){
if(root.val>maxValue||root.val<minValue)return false;
if(maxflag0)
return judgeTree(root.left,root.val,minValue,minflag,1)&&judgeTree(root.right,maxValue,root.val,minflag,1);
return false;
}
if(root.valInteger.MIN_VALUE){
if(root.val>maxValue||root.val<minValue)return false;
if(minflag0)
return judgeTree(root.left,root.val,minValue,1,maxflag)&&judgeTree(root.right,maxValue,root.val,1,maxflag);
return false;
}
if(root.val<maxValue&&root.val>minValue){
return judgeTree(root.left,root.val,minValue,minflag,maxflag)&&judgeTree(root.right,maxValue,root.val,minflag,maxflag);
}
return false;
}
}

leetcode120
给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。
例如，给定三角形：

[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

方法一：利用栈的思想
class Solution {
public int minimumTotal(List<List> triangle) {
Queue que=new LinkedList<>();
que.add(Integer.MAX_VALUE);que.add(triangle.get(0).get(0));que.add(Integer.MAX_VALUE);
for(int i=2;i<=triangle.size();i++){
for(int j=1;j<=i;j++){
int a=que.poll();
int b=que.peek();
if(aInteger.MAX_VALUE||bInteger.MAX_VALUE)que.add(a==Integer.MAX_VALUE?triangle.get(i-1).get(j-1)+b:triangle.get(i-1).get(j-1)+a);
else{que.add(a>b?triangle.get(i-1).get(j-1)+b:triangle.get(i-1).get(j-1)+a);}
}
if(i!=triangle.size())que.add(Integer.MAX_VALUE);
}
int minValue=Integer.MAX_VALUE;
que.poll();
while(!que.isEmpty()){
int value=que.poll();
minValue=Math.min(minValue,value);
}
return minValue;
}
}

方法二：由底向上【妙啊！】
public int minimumTotal(List<List> triangle) {
int row = triangle.size();
int[] minlen = new int[row+1];
for (int level = row-1;level>=0;level–){
for (int i = 0;i<=level;i++){ //第i行有i+1个数字
minlen[i] = Math.min(minlen[i], minlen[i+1]) + triangle.get(level).get(i);
}
}
return minlen[0];
}