算法_动态规划_石子合并问题

问题描述：
在一个圆形操场的四周摆放着n 堆石子。现要将石子有次序地合并成一堆。
规定每次只能选相邻的2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。
试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分

问题分析：
在此我们假设有n堆石子，一字排开，合并相邻两堆的石子，每合并两堆石子得到一个分数，最终合并后总分数最少的。
我们设m(i,j)定义为第i堆石子到第j堆石子合并后的最少总分数。a(i)为第i堆石子得石子数量。
当合并的石子堆为1堆时，很明显m(i,i)的分数为0;
当合并的石子堆为2堆时，m(i,i+1)的分数为a(i)+a(i+1);
当合并的石子堆为3堆时，m(i,i+2)的分数为
MIN((m(i,i)+m(i+1,i+2)+sum(i,i+2)) (m(i,i+1)+m(i+2,i+2)+sum(i,i+2));
当合并的石子堆为4堆时……

import java.util.Scanner;

public class Main {
    private static int n;
    private static int[] arr;
    private static int[] sum;
    private static int[][] dp;

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        arr=new int[2*n];
        sum=new int[2*n];
        for(int i=1;i<=n;i++){
            arr[i]=sc.nextInt();
            sum[i]=sum[i-1]+arr[i];
        }
        for(int i=n+1;i<=2*n-1;i++){
            arr[i]=arr[i-n];
            sum[i]=sum[i-1]+arr[i];
        }
        minFun();
        maxFun();
    }

    private static void minFun(){
        dp=new int[2*n][2*n];
        for(int r=1;r<=n-1;r++){
            for(int i=1;i<=2*n-1;i++){
                int j=i+r;
                if(j>=2*n){
                    continue;
                }
                dp[i][j]=dp[i][i]+dp[i+1][j]+sum[j]-sum[i-1];
                for(int k=i+1;k<j;k++){
                    dp[i][j]=Math.min(dp[i][j], dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]);
                }
            }
        }
        int result=dp[1][n];
        for(int i=2;i<=n;i++){
            result=Math.min(result,dp[i][n-1+i]);
        }
        System.out.println(result);
    }

    private static void maxFun(){
        dp=new int[2*n][2*n];
        for(int r=1;r<=n-1;r++){
            for(int i=1;i<=2*n-1;i++){
                int j=i+r;
                if(j>=2*n){
                    continue;
                }
                dp[i][j]=dp[i][i]+dp[i+1][j]+sum[j]-sum[i-1];
                for(int k=i+1;k<j;k++){
                    dp[i][j]=Math.max(dp[i][j], dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]);
                }
            }
        }
        int result=dp[1][n];
        for(int i=2;i<=n;i++){
            result=Math.max(result,dp[i][n-1+i]);
        }
        System.out.println(result);
    }


}