分治法“戳气球”

最后的解法多半是贪心或者动态规划，大概率动态规划。
但依照流程来看，找不到最优子结构。每次戳气球都会影响之后戳的气球，状态太多了。
比如同样是戳数字5号，因为之前戳气球的情况不同，左右邻居不同，这意味着戳5号的情况不能复用。
就这样想着，完全找不到思路。（后来发现是被正向思维给限制了）
干想也没办法，直接用动态规划的范式硬做。
nums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []
想一下递归式，比如现在只剩1号，戳1号后，最后答案为 戳完前面的3号+戳完后面5，8号+戳1号，因为是最后戳1号，所以戳1号的值为 start1号end，戳前面和后面递归调用即可。一下就有思路了。原来得逆向戳气球，假设最后一次戳气球是x，这时因为只剩x没有邻居可以直接算出值为x，前面和后面的空缺再递归调用戳气球就可以了！

对于此题我们需要反过来思考，因为正向思考的话情况过于复杂，而且状态转换方程根本没法写，所以不妨试着逆向思考，也就是动态规划的“自底向上”的思考方式，我先思考最简单的情况，在来推出稍微复杂的情况。

其实反思过来动态规划本身就是逆向的思维，从最后一步往前推。先假设最后一个生育的气球是k，那么由此我们可以将问题分为dp(i,k)和dp(k,j)两部分从而达到分而治之的目的。其实在分支的过程中也用到了动态规划的思想，即用for循环来保证k是能取到数组里的每一位数，即每一个气球都是可能最后一个被戳到，然后再从这里面寻找最大值，不过要注意的是，由于边界不能被选中，我们需要向将原数组扩容，即nums[-1]=nums[end+1]=1;然后再传入函数，这是递归结束的条件时只剩下两边的“1”，

class Solution {
public:

    int maxCoins(vector<int>& nums) {
        if(nums.size()==0)return 0;
        nums.insert(nums.begin(),1);
        nums.push_back(1);
        vector<vector<int>>memo(nums.size(),vector<int>(nums.size(),0)); 
        return Dp(nums,0,nums.size()-1,memo);
    }
 int Dp(vector<int>&nums,int i,int j,vector<vector<int>>&memo){
        if(i==j-1)return 0;
        if(memo[i][j]>0)return memo[i][j];
        int Max=0;
        for(int k=i+1;k<j;k++){
            Max=max(Dp(nums,i,k,memo)+Dp(nums,k,j,memo)+nums[i]*nums[k]*nums[j],Max);
        }
        memo[i][j]=Max;
         return Max;
    }
};

1.3 迭代-动态规划（继续1.2，自底而上思考）
可将1.2中的缓存表作为DP表，填表即可。通过从最小子问题开始进行简单尝试，可以发现长度为2的子问题的解仅依赖于长度为1子问题的解；长度为3的子问题的解仅依赖于长度为2的子问题的解

注意此处我们的填表顺序是斜着来的，这是因为我们的i和j分别是一个区间的开始可结束标志，又由我们的分析可知，我们划分的标准是“区间长度”，即我们要先求出所有区间长度为i的dp，才能以此选出最大的值来继续求区间长度为“i+1”的dp值，所以是 fill(dp,nums,j,j+i);
dp[i][j]的含义是，区间i~j上能取得的最大收益，最终的最大收益当然是
dp[0][nums.length-1].

class Solution{ //动态规划 5ms 99.82 %
    public int maxCoins(int[] nums){
        int dp[][] = new int[nums.length][nums.length];
        if(nums.length == 0){  //沙雕测试用例[]
            return 0;
        }
        for(int i = 0; i<nums.length; i++){
            for(int j = 0;j<nums.length-i;j++){
                fill(dp,nums,j,j+i);
            }
        }
        return dp[0][nums.length-1];
    }
    void fill(int[][] dp,int nums[],int start,int end){
        int max = 0;
        for(int i=start; i<=end;i++){
            max = Math.max(max,(start-1<0 ? 1 : nums[start-1])*nums[i]*(end+1>nums.length-1 ? 1 : nums[end+1]) + (start>i-1 ? 0 : dp[start][i-1]) + (end < i+1 ? 0 : dp[i+1][end]));
        }
        dp[start][end] = max;
    }
}