public static void main(String[] args) {
List<Integer>list=Arrays.asList(4,4,3,1);
// 循环的次数 C(N+2),3
System.out.println(count(list));
}
public static int count(List<Integer> list){
int n = list.size();
List<Integer>tmplist=new ArrayList<Integer>();
int sum=0;
for(int i=0;i<n;i++){
// 以0为分界线，分成不同的子集，再求这些子集合的和，再全部加起来
if(list.get(i)!=0)
tmplist.add(list.get(i));
else{
int []a=new int[tmplist.size()];
for(int j=0;j<tmplist.size();j++){
a[j]=tmplist.get(j);
}
sum+=maxCoins(a);
tmplist.clear();
}
// 求最后那个子集合的和
if(i==n-1){
int []a=new int[tmplist.size()];
for(int j=0;j<tmplist.size();j++){
a[j]=tmplist.get(j);
}
sum+=maxCoins(a);
tmplist.clear();
}
}
// System.out.println(sum);
return sum;
}
public static int maxCoins(int[] iNums) {
int[] nums = new int[iNums.length + 2];
int n = 1;
// 在集合的头尾加上两个编号为1的气球
for (int x : iNums) if (x > 0) nums[n++] = x;
nums[0] = nums[n++] = 1;
int[][] memo = new int[n][n];
return burst(memo, nums, 0, n - 1);
}
static int count = 0;
/**
* 以 4，4，3，1为例子
* 定义：burst(left,right)，是计算left~right之间最的大得分,计算的方法是循环 i=1~4 , 递归求right=burst(left,i)
* left=burst(i,right) 以及temp = nums[left]*nums[i]*nums[right] ，在与上次循环的结果ans比较，
* 取max(ans,left+temp+right) ， 注意这是开区间！ (3,5)的最大得分用闭区间表示就是[4]这一个气球的得分！
*
* @param memo ：二维数组，存储某范围内的最大得分 例如 (3,5)的值 表示 3~5最大的得分，在递归中都是(left,right)进行计算的
* @param nums
* @param left ：当前递归时候的最left值
* @param right：当前递归时候的最right值
* @return
*
*
* （1）在第一层递归第一次计算burstLeft的时候，由于 i=left+1,所以burstLeft根本就不存在，可见方法定义，比如3~4的(3,4)不存在任何气球
* 所以会进入burstRight的递归，接下来每层递归的第一层循环都是这样，即，i=left+1，burstLeft不存在，就会一直往深处递归到right-2
* 到此时，经过的流程为
* 1 left:0 i:1 right:5 TEMP:4
2 left:1 i:2 right:5 TEMP:16
3 left:2 i:3 right:5 TEMP:12
4 left:3 i:4 right:5 TEMP:3
* （2）此时，burstLeft=(left,i):(3,4) ; burstRight=(i,right):(4,5)都不存在
* ans=nums[3]*nums[4]*nums[5]。把值存入memo[3][5]（只有一个气球4，所以肯定是最大值），返回到left等于2的递归。
*
* （3）返回的地点是burstRight=(i,right),其中i=3,right=5; 运行到此刻表示的含义是，当left=2,i=3,right=5
* TEMP=nums[2]*nums[3]*nums[5] =12 burstLeft=(2,3)=0 burstRight=(3,5)=3 ，算到了一种burst(2,5)
* 的可能 nums[2]*nums[3]*nums[5]+burstLeft+burstRight=15。
*
* （4）然再 i+1 = 4 < right：5 继续循环，算出TEMP=nums[2]*nums[4]*nums[5] = 4 ，
* burstLeft=burst(2,4)=12 burstRight=(4,5)=0 所以算的burst(2,5)另外一种可能:
* nums[2]*nums[4]*nums[5]+burstLeft+burstRight=16。
*
* （5）然后根据max(ans,...)--->15<16, 拿算得burst(2,5)=16。
*
*
* 综上所述每次求temp=nums[left]*nums[i]*nums[right]的时候，其实相当于求burst(left,right)中最中最后一步的
* 计算。比如上例子求先算burst(2,5)中的 nums[2]*nums[4]*nums[5]，再算burst(2,4)和burst(4,5),但实际情况是
* 先完成burst(2,4)（此时的burst(4,5)不存在，没什么用）才可以进行 nums[2]*nums[4]*nums[5]的计算。
* 由此可以总结出。该算法的循环的i是确定最后射击的那个气球，然后再不断递归求得 (left,i) 和 (i,right)
*
*/
public static int burst(int[][] memo, int[] nums, int left, int right) {
if (left + 1 == right) return 0;
if (memo[left][right] > 0) {
// System.out.println("left: "+left+" right:"+right+" memo[left][right]:"+memo[left][right]);
return memo[left][right];
}
int ans = 0;
for (int i = left + 1; i < right; ++i){
int temp = nums[left] * nums[i] * nums[right] ;
System.out.println(++count+" left:"+left + " i:" + i + " right:"+right +" TEMP:"+temp);
int burstLeft = burst(memo, nums, left, i);
int burstRight = burst(memo, nums, i, right);
ans = Math.max(ans , burstLeft+temp+burstRight);
}
memo[left][right] = ans;
System.out.println("left: "+left+" right:"+right+" memo[left][right]:"+memo[left][right]);
return ans;
}
以4,4,3,1为例子
定义：burst(left,right)，是计算left~right之间最的大得分,计算的方法是循环 i=1~4 , 递归求right=burst(left,i)
* left=burst(i,right) 以及temp = nums[left]*nums[i]*nums[right] ，在与上次循环的结果ans比较，
* 取max(ans,left+temp+right) ， 注意这是开区间！ (3,5)的最大得分用闭区间表示就是[4]这一个气球的得分！
*
* @param memo ：二维数组，存储某范围内的最大得分 例如 (3,5)的值 表示 3~5最大的得分，在递归中都是(left,right)进行计算的
* @param nums
* @param left ：当前递归时候的最left值
* @param right：当前递归时候的最right值
* @return
* 以4,4,3,1为例子
*
* （1）在第一层递归第一次计算burstLeft的时候，由于 i=left+1,所以burstLeft根本就不存在，可见方法定义，比如3~4的(3,4)不存在任何气球
* 所以会进入burstRight的递归，接下来每层递归的第一层循环都是这样，即，i=left+1，burstLeft不存在，就会一直往深处递归到right-2
* 到此时，经过的流程为
* 1 left:0 i:1 right:5 TEMP:4
2 left:1 i:2 right:5 TEMP:16
3 left:2 i:3 right:5 TEMP:12
4 left:3 i:4 right:5 TEMP:3
* （2）此时，burstLeft=(left,i):(3,4) ; burstRight=(i,right):(4,5)都不存在，
* ans=nums[3]*nums[4]*nums[5]。把值存入memo[3][5]（只有一个气球4，所以肯定是最大值），返回到left等于2的递归。
*
* （3）返回的地点是burstRight=(i,right),其中i=3,right=5; 运行到此刻表示的含义是，当left=2,i=3,right=5
* TEMP=nums[2]*nums[3]*nums[5] =12 burstLeft=(2,3)=0 burstRight=(3,5)=3 ，算到了一种burst(2,5)
* 的可能 nums[2]*nums[3]*nums[5]+burstLeft+burstRight=15。
*
* （4）然再 i+1 = 4 < right：5 继续循环，算出TEMP=nums[2]*nums[4]*nums[5] = 4 ，
* burstLeft=burst(2,4)=12 burstRight=(4,5)=0 所以算的burst(2,5)另外一种可能:
* nums[2]*nums[4]*nums[5]+burstLeft+burstRight=16。
*
* （5）然后根据max(ans,...)--->15<16, 拿算得burst(2,5)=16。
*
*
* 综上所述每次求temp=nums[left]*nums[i]*nums[right]的时候，其实相当于先求burst(left,right)中最中最后一步的
* 计算。比如上例子求先算burst(2,5)中的 nums[2]*nums[4]*nums[5]，再算burst(2,4)和burst(4,5),但实际情况是
* 先完成burst(2,4)（此时的burst(4,5)不存在，没什么用）才可以进行 nums[2]*nums[4]*nums[5]的计算。
* 由此可以总结出。该算法的流程是，循环i确定最后射击的那个气球，然后再不断递归求得 (left,i) 和 (i,right)
本文详细解析了一个名为“爆破气球”的算法问题，通过递归的方式计算爆破一系列带有数值的气球可以获得的最大分数。文章以具体的代码示例说明了如何实现这一算法，并解释了其中的关键步骤。
扫一扫
85万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
