动态规划——矩阵连乘

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 650;

int T, n;
int m[N][2];
int dp[N][N];

// dp[i][j] 表示矩阵m[j] ~ m[j]的最小乘法次数

int main()
{
    cin >> T;
    while(T--)
    {
        cin >> n;
        // 解法是对的，是老师输入有问题
        for(int i = 1; i <= n; i++)
        {
            cin >> m[i][0] >> m[i][1];
        }

        // 因为是多测试用例，所以要赋值
        // 不需要对所有元素进行赋值，因为dp[i][j]所依赖的状态都会计算后才为使用
        for(int i = 0; i <= n; i++)
        {
            dp[i][i] = 0;
        }

        // 只需要对右上角的表格按对角线往上填即可
        for(int k = 2; k <= n; k++)
        {
            for(int i = 1, j = k; i <= n && j <= n; i++, j++)
            {
                // 循环顺序 i j
                // 1 2, 2 3, 3 4
                // 1 3, 2 4
                // 1 4

                // // 从i开始分割子问题，每次递增1，dp[i][i] 可以省略
                dp[i][j] = dp[i+1][j] + m[i][0] * m[i][1] * m[j][1];// 不想赋值无穷大，找个初值，可以赋值无穷大，省代码
                for(int t = i+1; t < j; t++)
                {
                    dp[i][j] = min(dp[i][j], dp[i][t] + dp[t+1][j] + m[i][0]*m[t][1]*m[j][1]);
                    // printf("dp[%d][%d] = %d\n", i, j, dp[i][j]);
                }

            }
        }

        cout << dp[1][n] << endl;
        
    }

    return 0;
}