Leetcode241.96.95回溯和动态规划和递归分治-非人题

95.必须重做

• 左边有多种情况，是一种vector的情况，右边呢，也是vector，
• 现场取i作为根节点。
• 什么时候退出呢？？选择参数也只有start和end
• 竟然是vector<>直接输出？，这样左边可获得这么一个阵列。

class Solution {
public:
vector<TreeNode*> ans;
    vector<TreeNode*> generateTrees(int n) {
        if(n == 0) return {};
        return backtracking(1, n);
    }

    vector<TreeNode*> backtracking(int start, int end){
        vector<TreeNode*> ret;
        
        if(start>end){
            ret.push_back(nullptr);
            return ret;
        } 
        
        for(int i=start; i<=end; i++){
            vector<TreeNode*> left = backtracking(start, i-1);
            vector<TreeNode*> right = backtracking(i+1, end);
            for(auto l:left){
                for(auto r: right){
                    TreeNode* root = new TreeNode(i);
                    root->left = l;
                    root->right = r;
                    ret.push_back(root);
                }
            }
        }
        return ret;
    }
};

96.

• 初始化中dp[1]应当是=1才对吧
• dp = dp[   j  这里为什么是-1？？？？]左边是0个，右边是n-1个呗，还得加它自己做根节点本身。
• 我怎么知道？？？它这样一定是搜索树，符合规范的？？
• G(n) = G(0)*G(n-1)+G(1)*(n-2)+...+G(n-1)*G(0)，

  假设n个节点存在二叉排序树的个数是G(n)，令f(i)为以i为根的二叉搜索树的个数

  即有:G(n) = f(1) + f(2) + f(3) + f(4) + ... + f(n)

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

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

• 这孙子，又是左边好多中情况，vector存一下，右边好多种，vector存一下，答案也是好多中，vector返回了，还是vector
• 出来的条件是，卧槽，没有符号了？？？表达式整出来就是（即输入）个整数，res里一个都没装，既没有加减乘的，合并来的数，这些数在最末端。expression就单独是一个数！！！于是okay！
• 当你在第一个-的左边一括号全括起来，右边也是。左边的处理办法和你括之前的一样的办法呀，只是小了点，于是递归。
• 递归了之后之后给他们加了括号，还得分三种情况才有结果。
• 出来的条件，这次在后面？？？

class Solution {
public:
    vector<int> diffWaysToCompute(string expression) {
        vector<int> res;
        for(int i=0; i<expression.size(); i++){
            char c = expression[i];
            if(c=='+' || c=='-' || c=='*'){
                auto res1 = diffWaysToCompute(expression.substr(0, i));//已经到了i-1
                auto res2 = diffWaysToCompute(expression.substr(i+1));
                for(auto r1: res1){
                    for(auto r2: res2){
                        if(c=='+'){
                            res.push_back(r1+r2);
                        }else if(c=='-'){
                            res.push_back(r1 - r2);
                        }else if(c =='*'){
                            res.push_back(r1 * r2);
                        }
                    }
                }
            }
        }
        if(res.empty()){
            res.push_back(stoi(expression));
        }
        return res;
    }
};

224.