动态规划2-Leetcode343-integerBreak

1. 题目

将一个整数划分成若干个整数的和，使得这若干个整数乘积最大。

2. 思路

这个题可以用递归去解，因为各种划分可以表示成一棵递归树。

自顶向下的递归：

先来看一个简单的例子，当n等于4时：

可以使用动态规划解决的问题，一般都具有重叠子问题，我们只需要求出这些重叠子问题的最优解就可以了。

什么是子问题？

要求出n的integerBreak，那么只需要求出i和n-i的integerBreak，我们可以从递归树中观察到，每个节点就可以代表一个子问题，或者一个状态。

什么是重叠子问题？

我们可以从上面的递归树中看到，2被重复计算了多次，这就是重复的子问题，如果把这棵递归树画全，那么会出现更多的重叠子问题，因为有了重叠子问题，那么这些重叠的子问题我们就只需要计算一遍，一般可以通过HashMap把计算过的节点存储起来，如果检测到当前节点未被计算过在计算，否则就不计算直接返回HashMap中key对应的结果，这就叫做记忆化搜索。

子问题的最优解？

在这个题目中，最优解，就是当前划分中，乘积最大的那个。

自底向上的循环：

3. 代码

递归（穷举、暴力搜索，也就是把所有的可能的划分都遍历一遍，然后返回乘积最大的那个）：

	public int integerBreak(int n) {
		int res = -1;
		
		if(n == 1)
			return 1;
		
		for(int i = 1; i < n; i++){
			
			// 子问题 及 子问题的最优解
			res = max3(res,i*(n-i),i*integerBreak(n-i));			
		}
			
			
		return res;
	}

记忆化搜索：

	HashMap<Integer,Integer> hm = new HashMap();

	public int integerBreak(int n) {
		int res = -1;
		
		//终止条件这里可以是2
		if(n == 2)
			return 1;
		
		
		if(!hm.containsKey(n)){
			for(int i = 1; i < n; i++){
				res = max3(res,i*(n-i),i*integerBreak(n-i));
				hm.put(n, res);
			}
		}else{
			return res = hm.get(n);
		}

			
			
		return res;
	}

	private int max3(int a, int b, int c) {
		return Math.max(a, Math.max(b, c));
	}

循环：

	public int integerBreak(int n){
		
		int[] memo = new int[n+1];
		
		memo[1] = 1;
		
		for(int i = 2; i <= n ; i++){
			for(int j = 1; j<= i-1; j++){
				memo[i] = max3(memo[i],j * (i - j),j * memo[i-j]);
			}
		}
		
		return memo[n];
	}

	private int max3(int a, int b, int c) {
		return Math.max(a, Math.max(b, c));
	}

数学推论：

    public int integerBreak(int n) {
        if(n <= 3)
            return n - 1;
        
        int product = 1;
        while(n > 4){
            product *= 3;
            n -= 3;
        }
        product *= n;
        return product;
        
    }