leetcode第343题整数拆分

leetcode第343题整数拆分

自底向上 + 双层for循环：

分析：（以5为例子）

可以分为：

1 + 1 + 1 + 1 + 1 结果为1

1 + 2 + 1 + 1 结果为2

1 + 3 + 1 结果为3

1 + 4 结果为 4

2 + 3 结果为6

**dp数组的定义：**拆分以i结尾的数字，得到最大的乘积为dp【i】

状态转移方程： dp【i】其实是上一层j循环得到的结果，里面的数加起来和也是i i - j × j 就是对当前i 和 j 的情况作出的处理 dp【i - j】 × j也是一种处理情况，这类型的dp，组合想的时候，真的很不容易。

确定内层循环的起始值和终点值 j肯定是1开始，j从0开始，任何数 × 0 = 0.没有计算的必要，i - 1截至，

dp【3】 = max（0，2 × 1，dp【2】 × 1）

dp【4】 = max（0,3 * 1,dp【3】 × 1）

dp【4】 = max（3，2 × 2，dp【2】 × 2）；

dp【5】max（0，4 × 1，dp【4】 × 1）

dp【5】= max（4，3 × 2；dp【3】 × 2）；

我感觉还可以优化。

class Solution {
    public int integerBreak(int n) {
        if(n == 0 || n == 1){
            return n;
        }
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[0] = 0;
        dp[2] = 1;
        for(int i = 3;i < dp.length;i++){
            for(int j = 1;j < i - 1;j++){
                dp[i] = Math.max(dp[i],Math.max((i - j) * j,dp[i - j] * j));
            }
        }

        return dp[n];

    }
    //感觉这个应该是自顶向下的
    //dp数组的定义:下标为n的数字所代表的成绩最大化
}

自顶向下 + 记忆法递归的解法:

状态转移方程还是一样的。

class Solution {
    int[] memo;

    // imooc 9-3 也可用回溯
    public int integerBreak(int n) {
        memo = new int[n + 1];
        return breakInteger(n);
    }

    public int breakInteger(int n) {
        if (n == 1) {
            return 1;
        }

        int res = -1;

        if (memo[n] != 0) {
            return memo[n];
        }

        // res用来保存每次for循环过程中的最大值
        // 即res 取的是 i = 1 到 n-1 之间，尝试分割的方案的最大值
        // i表示先取前i作为第一段
        for (int i = 1; i <= n - 1; i ++) {
            res = Math.max(Math.max(res, i * (n - i)), i * breakInteger(n - i));
        }

        memo[n] = res;

        return res;
    }

}