动态规划之沙子合并

设有N堆沙子排成一排，其编号为1，2，3，…，N（N< =300）。每堆沙子有一定的数量，可以用一个整数来描述，现在要将这N堆沙子合并成为一堆，每次只能合并相邻的两堆，合并的代价为这两堆沙子的数量之和，合并后与这两堆沙子相邻的沙子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同，如有4堆沙子分别为 1 3 5 2 我们可以先合并1、2堆，代价为4，得到4 5 2 又合并 1，2堆，代价为9，得到9 2 ，再合并得到11，总代价为4+9+11=24，如果第二步是先合并2，3堆，则代价为7，得到4 7，最后一次合并代价为11，总代价为4+7+11=22；

问题是：找出一种合理的方法，使总的代价最小。输出最小代价。

输入格式：

第一行一个数N表示沙子的堆数N。第二行N个数，表示每堆沙子的质量。 < =1000

输出格式：

合并的最小代价

样例输入

4
1 3 5 2
样例输出

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int [] p=new int [n+1];

        for (int i = 1; i <=n; i++) {
            p[i]=sc.nextInt();
        }
        int [][] m=new int [n+1][n+1];
        int [][]s=new int [n+1][n+1];
        MatrixChain(p, n, m, s);
        System.out.println(m[1][n]);


    }
    static void MatrixChain(int [] p,int n,int [][] m,int [][] s){
        for (int i = 1; i <=n; i++) {
            m[i][i]=0;
        }

        for (int r= 2; r<= n; r++) {
            for (int i= 1; i<=n-r+1; i++) {
                int j=i+r-1;
                m[i][j]=m[i+1][j]+sum(i,j,p);
                s[i][j]=i;
                for (int k = i+1; k < j; k++) {
                    int t=m[i][k]+m[k+1][j]+sum(i,j,p);
                    if(t<m[i][j]){
                        m[i][j]=t;
                        s[i][j]=k;
                    }
                }
            }
        }
    }
    private static int sum(int i, int j,int [] p) {
        int num=0;
        for (int k = i; k <=j; k++) {
            num+=p[k];
        }
        return num;
    }
}

动态规划之沙子合并

猜你喜欢