动态规划二：整数划分求积

动态规划二：整数划分求积

题目:

给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。返回你可以获得的最大乘积。
示例 1:    输入: 2      输出: 1       解释: 2 = 1 + 1, 1 × 1 = 1。
示例 2:    输入: 10    输出: 36     解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。
说明: 假设 n 不小于 2 且不大于 58。

方法一：暴力递归

因为一个大于2的数，既可以拆分为2个数的和，也可以拆分为3个数的和，由于拆分个数的不确定，因此使用循环的方法无法解决；一个可行的思路就是递归，首先通过暴力递归穷举出一个数的所有划分方法，然后计算每种划分方法的积，然后返回积中最大的那个；

public static int product = 1; //定义为类变量
//递归穷举
public static void intBreak(int num,int index,int [] temp){
    //递归出口
    if( num <=0) {
        //输出划分方法
        // for(int i = 0; i< index;i++)
        //    System.out.printf("%-2d",temp[i]);
        // System.out.println();
        
        //要求至少划分为两个数，index =1 表示未划分，直接返回
        if(index ==1)   return ;
        
        //计算该种划分方法的积
        int produ = 1;
        for(int i = 0; i< index;i++)
             produ *= temp[i];
        //product为所有划分中积的最大值
        product = produ > product ? produ:product;
        return ;
    }
    //递归穷举，效率不够高，只是可解
    for(int i = num;i > 0 ;i--){
        //排除划分中出现的（1，n-1）和（n-1，1）重复的情况
        if( index > 0 && i > temp[index-1]) continue;
        temp[index] = i;
        //递归划分
        intBreak(num-i,index+1,temp);
    }
}

方法二：暴力递归2

//递归,对整数n进行分割（至少分割为两部分），可以获得的最大乘积
public static int intBreak2(int num){
        if(num ==1)
            return 1;
        int res = -1;
        for(int i = num; i > 0;i--){
            //最大乘积，由(res,i*(num-i),i*intBreak2(num-i)))三者中最大的产生;
            res = Math.max(res,Math.max(i*(num-i),i*intBreak2(num-i)));
        }
        return res;
}

针对该问题的递归过程进行分析：


对于整数n,可以划分为{1+分割（n-1）,2+分割（n-2）,…,(n-1)+分割（1）},对应分割方法的积为{1*分割（n-1）,2*分割（n-2）,…,(n-1)*分割（1）}；在这个过程中分割n的最大乘积，可以同通过其子问题分割（n-1），分割（n-2）,…分割（2），分割（1）的最大乘积解决，这便是最优子结构问题：

方法三：记忆化搜索

int [] memo = new int[num+1]; //定义在调用函数中
//记忆化搜索，自顶向下
public static int intBreak3(int num,int []memo){
        //memo[n] 表示整数 n 分解后，可以获得的最大乘积
        if(num == 1)
            return 1;
        //判断memo[num]是否存在，若存在，直接返回
        if(memo[num] != 0)
            return memo[num];
        int res = -1;
        //memo[num]不存在，则递归计算后，保存在memo[num]，然后返回
        for(int i = num; i > 0;i--){
            res = Math.max(res,Math.max(i*(num-i),i*intBreak3(num-i,memo)));
        }
        memo[num] = res;
        return memo[num];
}

方法四：动态规划

//动态规划，自底向上
public static int intBreak4(int num,int []memo){
        //memo[n] 表示整数 n 可以分解获得的最大乘积
        memo[0] = 1;
        for(int i = 1 ; i <= num;i++){
            //求解memo[i]
            for(int j = 1; j <i;j++)
                // i = j+(i-j)
                memo[i] = Math.max(memo[i],Math.max((i-j)*j,(i-j)*memo[j]));
        }
        return memo[num];
}