代码随想录day41

343.整数拆分

朴素dfs版本，超时

class Solution {
    int res ;
    public int integerBreak(int n) {
        res = 0;
        dfs(n,n,1,0);
        return res;
    }
    public void dfs(int n,int x,int sum,int k){
        if(x < 0)return;
        if(x==0 && k >=2){
            res = Math.max(res,sum);
            return;
        }
        for(int i = 1;i <= x; i++){
            // if(x == n) continue;
            sum *=i;
            k++;
            dfs(n,x - i ,sum,k);
            sum /=i;
            k--;
        }
    }
}

动态规划

遇到的几个问题
1.为什么要 dp[i] = Math.max(dp[i],Math.max(j*(i-j),j*dp[i-j])) ?
因为j是不断的变化,dp[i]需要不断的更新才能取得最大值
2.j存在多种情况?为什么没有考虑拆分j
因为j本来就是拆分过的 dp[i-j]中已经包含了之前拆分j的情况

class Solution {
    public int integerBreak(int n) {
        // 定义dp数组 dp[i] 表示数字i拆分之后得到的最大值
        // 递推公式 dp[i] = max(j * dp[i-j],j*(i-j))
        int[] dp = new int[n+1];
        dp[2] = 1;
        for(int i = 3;i <= n;i++){
            for(int j = 1;j < i;j++){
                dp[i] = Math.max(dp[i],Math.max(j*(i-j),j*dp[i-j]));
                // dp[i] = Math.max(j*(i-j),j*dp[i-j]);
            }
        }
        System.out.println(Arrays.toString(dp));
        return dp[n];
    }
}

96. 不同的二叉搜索树

class Solution {
    public int numTrees(int n) {
        // dp[i] ： 1到i为节点组成的二叉搜索树的个数为dp[i]。

        int[] dp = new int[n + 1];
        // Arrays.fill(dp,1);
        // if(n <= 2) return n;
        // dp[1] = 1;
        // dp[2] = 2;
        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];

    }
}