Burst Balloons（戳气球）（困难）（回溯）（动态规划）

题目：
有 n 个气球，编号为0 到 n-1，每个气球上都标有一个数字，这些数字存在数组 nums 中。

现在要求你戳破所有的气球。每当你戳破一个气球 i 时，你可以获得 nums[left] * nums[i] * nums[right] 个硬币。 这里的 left 和 right 代表和 i 相邻的两个气球的序号。注意当你戳破了气球 i 后，气球 left 和气球 right 就变成了相邻的气球。

求所能获得硬币的最大数量。

说明:

你可以假设 nums[-1] = nums[n] = 1，但注意它们不是真实存在的所以并不能被戳破。
0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100

来源：力扣（LeetCode）

法一：暴力遍历
加粗样式但我们会发现时间复杂度高达 n！，所以当我们碰到时间复杂度为 n！时，首先想到分治，为什么呢？
打个简单的比方：
8！与两个4！显然能节省不少的时间。
所以我们联想到

法二：分治
我们去戳从i到j的气球（不包含i与k），假设k是最后一个戳的气球，则我们将问题分成了两个子问题，即 戳i到k，戳k到j和戳k。
如此我们便得到了递归式：
dp[i][j] = dp[i][k]+dp[k][j]+nums[k]*nums[i]*nums[j]（k从i+1到j-1）。
显然问题到这里没有结束，我们还需要一个截至条件。
当只剩下i和j时，返回0。
代码如下：

public int[][] dp;
	public int maxCoins(int[] nums) {
		dp = new int[nums.length][nums.length];
		int[] tmp = new int[nums.length+2];
		int i = 1;
		for(int x:nums) 
			nums[i++] = x;
		tmp[0] = 1;
		tmp[tmp.length-1] = 1;
		return helper(0,tmp.length-1,tmp);
    }
	public int helper(int start,int end,int[] nums) {
		if(end-start == 1) {
			return 0;
		}
		if(dp[start][end]!=0) {
			return dp[start][end];
		}
		for(int i = start+1;i<end;i++) {
			int tmp =  helper(start,i,nums)+helper(i,end,nums)+nums[start]*nums[end]*nums[i];
			dp[start][end] = Math.max(dp[start][end], tmp);
		}
		return dp[start][end];
	}

法三：动态规划法
通常我们能不递归就递归。

递归调用的效率是很低的，因为牵扯到大量的函数调用，即栈帧的创建与释放。而且由于临时变量的存在以及需要保存之前栈帧的esp、程序计数器等寄存器值，在递归层数加深时会占用大量的栈空间，非常容易引起爆栈。
我们应该去思考递归调用的回归过程，通过模拟回归过程来用递推实现上述代码。
用递推模拟回归过程的方法，就是在上述实现的缓存 cache[i][j] 中逐渐推演，通过一步步的解决小问题来得到最终问题的解，这便是动态规划解法
如果一个问题的最优解包含其子问题的最优解，我们就称此问题具有最优子结构
引用于LeetCode作者：niu-you-rou。

进一步的思考后，我们发现，如果我们先求解三个一组的气球。
比如：
1,3,5,7,9,1（两侧加过一）
我们先求 1,3,5、3,5,7、5,7,9、7,9,1
再求 1,3,5,7、3,5,7,9、5,7,9,1
会发现当我们套用法二的公式时，我们已经求过了dp[i][k]与dp[k][j]。
这就是动态规划的的基本过程：
代码：

private int[][] dp;
	public int helper(int[] tmp,int start,int end) {
		if(end - start == 1) 
			return 0;
		if(dp[start][end]!=0) 
			return dp[start][end];
		int max = 0;
		for(int i = start+1;i<end;i++) {
			max = Math.max(max, dp[start][i]+dp[i][end]+tmp[i]*tmp[start]*tmp[end]);
		}
		return max;
	}
	public int maxCoins(int[] nums) {
		dp = new int[nums.length+2][nums.length+2];
		int[] tmp = new int[nums.length+2];
		System.arraycopy(nums, 0, tmp, 1, nums.length);
		tmp[0] = tmp[tmp.length-1] = 1;
		for(int i = 2;i<tmp.length;i++) {
			for(int j = 0;j<tmp.length-i;j++) {
				dp[j][i+j] = helper(tmp,j,j+i);
			}
		}
		return dp[0][tmp.length-1];
	}