动态规划之石子合并问题

问题

思路

假设有 1 2 3 三堆石头 总代价计算如下：

我们看到总代价 必然包括 三堆石头的总和 6，剩下代价看 1-2 和2-3 哪个代价最小,那么总代价为6加上最小代价。
所以有公式 mm[1][3] = MIN(mm[1][2],mm[2][3]) + sum(1,3)
推广到一般式 mm[1][n] = MIN(mm[1][n-1],mm[2][n]) + sum(i,n)
推广到一般式 mm[i][j] = MIN(mm[i][j-1],mm[i+1][j]) + sum(i,n)
自然联想到矩阵连乘 从左下到右上 填写斜线，最后输出右上 即为结果。（与矩阵连乘不同，没有用到第三层的for循环，for(int k = i+1;k<j;k++)）
——————————————————————
以上是我第一次所想到的，好像是正确。
——————————————————————
看 另一个 例子 1 2 3 1

按照上面的公式可以得到下面的表格：

我们发现最终的结果为16，但是有可以比16更小的代价

按上面的一般性的公式mm[1][4]
= MIN(mm[1][3],mm[2][4]) +sum(1,4) => MIN(9,10)+7=16
但是还有另一种可能如下：

也就是说

mm[1][4]=
mm[1][1] + mm[2][4] + sum(1,4) => 0 + 10 + 7 = 17
mm[1][2] + mm[]3[4] + sum(1,4) => 3 + 4 + 7 = 14
mm[1][3] + mm[]4[4] + sum(1,4) => 9 + 0 + 7= 16

可以看到，对于上面推导的公式 mm[i][j] = MIN(mm[i][j-1],mm[i+1][j]) + sum(i,n) ，我以偏概全，认为1-3（i->(j-1）），4-4 (j->j)或者1-1 (i->i)，2-4（(i+1）j）
是1-4（i->j）的最小代价，
还有一种情况1-2 (i->(j-2)) 3-4 （（i+2)->j） 的代价更小,没有考虑进去。
————————————————————
那么上面推导的公式就不正确了
再次推导：
mm[i][j]
= MIN(mm[i][k]+mm[k+1][j])+sun(i,j) 其中 i<=k<=j

至此我们发现 动态规划之石子合并问题与 动态规划之举证连乘就十分相似了，那就没多少说的了，直接码。

实现

import java.util.Scanner;

public class CollectStone {
	static int[] aa;
	static int[][] mm;
	public static void main(String[] args) {
		Scanner sc  = new Scanner(System.in);
		while(sc.hasNext()) {
			int n = sc.nextInt();
			aa = new int[n];
			
			for (int i = 0; i < n; i++) {
				aa[i] = sc.nextInt();
				
			}
			mm = new int[n+1][n+1];
			solve(n);
			System.out.println(mm[1][n]);
		}

	}
	private static void solve(int n) {
		for(int i=1;i<=n;i++) mm[i][i]=0;
		
		for (int r = 2; r <= n; r++) {
			for (int i = 1; i <= n-r+1; i++) {
				int j = i+r-1;
				mm[i][j] = mm[i][i]+mm[i+1][j]+sum(i,j);
				for (int k = i+1; k < j; k++) {
					int t = mm[i][k]+mm[k+1][j]+sum(i,j);
					if(t<mm[i][j]) {
						mm[i][j] = t;
					}
				}
				
			}
			
		}
	}
	private static int sum(int i, int j) {
		int sum=0;
		for (int z = i-1; z <= j-1; z++) {
			sum+=aa[z];
		}
		return sum;
	}

}