动态规划 java 石子问题（直线）

一.石子问题与动态规划的矩阵相乘问题类似，刚开始我在数组边界上出现了小问题，让我知道了，数组的边界一定到精确，<还是<=，n还是n+1，都要精益求精；
二 .还有就是在i到j石子之和处出现问题，1.sum[j]-sum[i-1]
2.sum[j]-sum[i-2] 3.sum[j]-sum[i-1]+a[i-1]第一种会遗失a[i-1]的值，第二种会出现数组越界异常，所以第三种才是正确的，
3.关于第二个问题，我看到了某神是这样写的
public static int getSum(int[] a2, int a, int b) {
int sum = 0;
for(int i = a;i <= b;i++)
sum += a2[i];
return sum;
}那么中文中27行的sum[j - 1]- sum[i - 1] + a[i - 1];就可以改为getSum(a, i - 1, j - 1)；无疑是方便很多，

package my;

import java.util.Scanner;
/*在一条直线上有n堆石子，每堆有一定的数量，每次可以将两堆相邻的石子合并，
 * 合并后放在两堆的中间位置，合并的费用为两堆石子的总数。
 * 求把所有石子合并成一堆的最小花费。*/

public class shiziwenti {
    public static void main(String[] args) {
        int n = new Scanner(System.in).nextInt();
        int[] a = new int[n];
        int[] sum = new int[n];
        int[][] dp = new int[n + 1][n + 1];
        getsum(a, sum, n);
        printresult(dp, sum, a, n);
        System.out.print("\t" + dp[1][n]);
    }
    //计算最短花费
    private static void printresult(int[][] dp, int[] sum, int[] a, int n) {

        for (int len = 2; len <= n; len++) {
            for (int i = 1; i <= n - len + 1; i++) {
                int j = i + len - 1;
                dp[i][j] = Integer.MAX_VALUE;
                for (int k = i; k < j; k++) {
                    int temp = dp[i][k] + dp[k + 1][j] + sum[j - 1]
                            - sum[i - 1] + a[i - 1];
                    if (temp < dp[i][j])
                        dp[i][j] = temp;
                }
            }
        }

    }
    //计算石子的和
    private static void getsum(int[] a, int[] sum, int n) {
        for (int i = 0; i < n; i++)
            a[i] = new Scanner(System.in).nextInt();
        if (n == 1)
            System.out.print(a[0]);
        else {
            sum[0] = a[0];
            for (int i = 1; i < n; i++)
                sum[i] = sum[i - 1] + a[i];
            for (int i = 0; i < n; i++)
                System.out.print(sum[i]);
        }
    }
}