代码随想录算法训练营第41天 | 动态规划 part03 ● 343. 整数拆分 ● 96.不同的二叉搜索树

day40休息日

#343 整数拆分  花了好久理解

int integerBreak(int n) {
        vector<int> dp(n+1,0);
        dp[1]=1;
        dp[2]=1;
        for(int i=3;i<=n;i++){
            cout<<"i:"<<i<<endl;
            for(int j=1;j<=i/2;j++){//int j=i/2;j>=1;j-- //int j=1;j<=i/2;j++
                printf("j: %d, dp[j]: %d,and we use j!\n",j,dp[j]);
                printf("i-j: %d, dp[i-j]: %d\n",i-j,dp[i-j]);

                dp[i]=max(j*max(i-j,dp[i-j]),dp[i]);
                //dp[i]=max(max(j,dp[j])*max(i-j,dp[i-j]),dp[i]);
                //上面这句是我自己写的版本，也对也能AC但是会慢很多
                cout<<"dp[i]: "<<dp[i]<<endl;
                cout<<"-----------------------"<<endl;
            }
        }
        return dp[n];
    }

自己AC花了30min，但后来理解随想录和我的不同的时候，想了一个多小时（也有放弃去做别的然后再返回来想，反正花了好久）

主要在推导公式上，dp在把n需要的乘积分成两个部分，第二个部分找dp[ ]

我写的：dp[i]=max(max(j,dp[j])*max(i-j,dp[i-j]),dp[i]);

随想录的：dp[i]=max(j*max(i-j,dp[i-j]),dp[i]);

我的能AC但是慢很多，做了一个额外的不需要的 在j和dp[j] 里面找最大值。

如何理解不需要拆分 j ，只需要拆分 i-j 

1.走到i的过程中，dp[j] dp[i-j] 都已经计算好了

2.我之前一直以为 j 必定比 dp [j] 大，所以不做比较直接用 j。其实不是的，只有 j<=4 时，j必定大于 dp [j]， 从5开始就是 j 小了

3. 我发现for loop那 //int j=i/2;j>=1;j-- //int j=1;j<=i/2;j++ 这两种写法都对，就是到 i 之后 从j 从前往后 从后往前都可以

4. 然后我把条件改成这样发现也对：for(int j=1;j<=min(4,i/2);j++) 就是在 j 够大的时候只走1-4

这一点加深了我的理解：这两部分乘积的max结果一定会在 j 1-4 这个范围里面出现，就是j 更大的时候也可能会组合成同样大的这个最大值，但是 j 1-4的时候一定会出现。 好像是因为 j 更大的那个组合 是可以 拆分成 j 更小的（1-4）的部分 加上一个 合适的 i-j的部分的 

gpt说的：“为什么最大乘积一定会在j在1-4这个范围内出现，这是因为对于j大于4的情况，我们总是可以将j分解为两个小于等于4的数，而得到的乘积比j本身大。因此，在计算最大乘积的时候，我们只需要考虑j在1-4这个范围内的情况就可以了”

再附上两张 testcase n =10 一个从前往后，一个从后往前 （j）的截图 

---

#96 不同的二叉搜索树  

自己没想出来，但是有一点思路。其实看到没给node结构就知道不会要遍历tree，而是通过前面的来找规律，看前面的用什么方法组合能合成第n个答案

我的想法是，比如 在 123的基础上加上4，分为4做为root，4 做为 leaf node，4做为中间的node。node和leaf好想，都是原来的个数一样的。但是作为中间node我推算不出多少个。

看了随想录很巧妙：

我们利用 n-1 那些情况做为subtree可能有的形状，来构成n

 

比如4的话，就是 1234 轮流作为root，此时剩下还有3个node 要放在左右子树，那可以是 左0右3，左1右2，左2右1，左3右0，也就是  for (int j = 0; j <= i-1; j++)  dp[i] += dp[j] * dp[i-1-j];

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