算法提高 矩阵乘法 Java——直线区间DP

和石子合并一样的直线区间DP，只不过初始化dp数组的时候要小心，因为矩阵相乘后值会非常大，蓝桥杯的最后一个测试案例的结果大概800多亿，而且dp方程中要把int转为long类型的值

AC代码

import java.util.Scanner;

public class Main {
    static int maxn = 1100;
    static long INF = Long.MAX_VALUE;//必须用long的最大值初始化dp数组，因为数据太大了
    static juzhen[] zhu;//在main中new对象数组
    static long[][] dp = new long[maxn][maxn];
    public static void main(String[] args){

        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();

        zhu = new juzhen[N+1];
        int[] nums = new int[N+2];
        for(int i = 1;i<=N;i++){//初始化dp
            for(int j = 1;j<=N;j++){
                dp[i][j] = INF;
            }
        }
        for(int i = 1;i <= N;i++){
            dp[i][i] = 0;
        }
        //存珠子
        for(int i = 1;i <= N+1;i++){
            nums[i] = sc.nextInt();
        }
        for(int i = 1;i <= N;i++){
            juzhen z = new juzhen(nums[i],nums[i+1]);
            zhu[i] = z;
        }

        for(int len = 1;len <= N;len++){
            for(int i = 1;i <= N - len + 1;i++){
                int jmax = i + len - 1;
                for(int k = i;k < jmax;k++){
                    dp[i][jmax] = Math.min(dp[i][jmax],dp[i][k]+dp[k+1][jmax]+(long) zhu[i].getHead()*(long) zhu[k+1].getHead()*(long) zhu[jmax].getTail());
                }
            }
        }
        System.out.println(dp[1][N]);
    }
}
//矩阵类
class juzhen{
    public int head;
    public int tail;

    public juzhen(int head, int tail) {
        this.head = head;
        this.tail = tail;
    }

    public void setHead(int head) {
        this.head = head;
    }

    public void setTail(int tail) {
        this.tail = tail;
    }

    public int getHead() {
        return head;
    }

    public int getTail() {
        return tail;
    }
}