蓝桥杯 算法提高 矩阵乘法 （区间DP: 最优矩阵连乘）

算法提高 矩阵乘法
时间限制：**3.0s 内存限制：**256.0MB
问题描述
　　有n个矩阵，大小分别为a0*a1, a1*a2, a2*a3, …, a[n-1]*a[n]，现要将它们依次相乘，只能使用结合率，求最少需要多少次运算。
　　两个大小分别为p*q和q*r的矩阵相乘时的运算次数计为p*q*r。
输入格式
　　输入的第一行包含一个整数n，表示矩阵的个数。
　　第二行包含n+1个数，表示给定的矩阵。
输出格式
　　输出一个整数，表示最少的运算次数。
样例输入
3
1 10 5 20
样例输出
150
数据规模和约定
　　1<=n<=1000, 1<=ai<=10000。

ps:最优矩阵连乘，总存在最后一次相乘的位置，既分为左边x个矩阵相乘，右边y个矩阵相乘，最后把这两边的矩阵相乘( 矩阵乘法符合结合律)。那么要使最后的相乘次数最少，左右两边的矩阵也需要满足相乘的次数最少（最优子结构），那么就将问题的规模缩小了，既可以转换为从两个矩阵相乘的次数最少(既每两个矩阵本身相乘的次数)，到每三个矩阵相乘的矩阵最少(利用了上面的两个矩阵相乘次数最少)……一直到每n个矩阵相乘的次数最少。
举个简单的例子：
有三个矩阵A(5行4列), B(4行6列), C(6行8列), 问怎样的计算才能使矩阵相乘的次数最少?
首先我们按照上面的思路：先计算每两个矩阵相乘的次数，
A*B的次数为(5 * 4 * 6 = 120 次), B * C的次数为(4 * 6 * 8 = 192次), 接着我们计算每三个矩阵相乘最少的次数，有两种情况(枚举分割点): (1) A(BC) = 192 + 5 * 4 * 8 = 352次。(分割点在第一个矩阵)
(2)(AB)C = 120 + 5 * 6 * 8 = 360 次(分割点在第二个矩阵)。
比较(1)(2)这样我们就把最少的次数求出来了为352次。

通过上面的例子，我们很快就可以写出动态转移方程

dp[i][j]={0min(dp[i][j],dp[i][k]+dp[k+1][j]+a[i−1]∗a[k]∗a[j],i = ji < j d p [ i ] [ j ] = { 0 i = j m i n ( d p [ i ] [ j ] , d p [ i ] [ k ] + d p [ k + 1 ] [ j ] + a [ i − 1 ] ∗ a [ k ] ∗ a [ j ] , i < j

其中dp[i][j] 表示第i个矩阵到第j个矩阵相乘的最少次数，k为分割点。
时间复杂度为: O(n^3)

#include
#include
using namespace std;
long long a[1004];
long long dp[1004][1004];
int main()
{
    ios::sync_with_stdio(false);
    int n;
    while(cin>>n)
    {
        int t = n + 1;
        for(int i = 0; i < t; i++)
            cin>>a[i];
        memset(dp, 0x3f, sizeof dp);
        //dp[i][i]只有一个矩阵相乘的次数为0
        for(int i = 1; i <= n; i++)dp[i][i] = 0;

        for(int l = 2; l <= n; l++)
        {//枚举矩阵连乘的长度
            for(int i = 1; i + l - 1 <= n; i++)
            {//枚举矩阵连乘起始的位置
                int j = i + l - 1;//j为长度为l的链的末尾
                for(int k = i; k <= j - 1; k++)
                {//枚举分割点
                    long long q = dp[i][k]+ dp[k+1][j] + a[i-1]*a[k]*a[j];
                    if(q < dp[i][j])
                    {
                        dp[i][j] = q;
                    }
                }
            }
        }
        cout<1][n]<return 0;
}

后来尝试用四边形不等式来优化，但是失败了

#include
#include
using namespace std;
long long a[1004];
long long dp[1004][1004];
int div[1004][1004];//记录最优分割点
int main()
{
    ios::sync_with_stdio(false);
    int n;
    while(cin>>n)
    {
        int t = n + 1;
        for(int i = 0; i < t; i++)
            cin>>a[i];
        memset(dp, 0x3f, sizeof dp);
        memset(div, 0, sizeof div);
        for(int i = 1; i <= n; i++)dp[i][i] = 0; //dp[i][i]只有一个矩阵相乘的次数为0
        for(int i = 1; i + 1 <= n; i++)
        {//计算长度为2时的分割点
            int j = i + 1;
            dp[i][j] = a[i-1] * a[i] * a[j];
            div[i][j] = i;
        }

        for(int l = 3; l <= n; l++)
        {//枚举矩阵连乘的长度
            for(int i = 1; i + l - 1 <= n; i++)
            {//枚举矩阵连乘起始的位置
                int j = i + l - 1;//j为长度为l的链的末尾
                for(int k = div[i][j-1]; k <= div[i+1][j]; k++)
                {//枚举分割点
                    long long q = dp[i][k]+ dp[k+1][j] + a[i-1]*a[k]*a[j];
                    if(q < dp[i][j])
                    {
                        dp[i][j] = q;
                        div[i][j] = k;//更新分割点
                    }
                }
            }
        }
        cout<1][n]<return 0;
}

后来，请教了别人，说是因为long long q = dp[i][k]+ dp[k+1][j] + a[i-1]*a[k]*a[j];也就是状态转移方程里面多了a[k]这一个变量(与分割点有关)，会干扰优化(不等式优化的是A+B,B如果不确定会干扰整个项)，但是我看到论文关于用用四边形不等式来优化矩阵链乘确是这个思路，但是找不到他们具体是如何实现的，如果有dalao知道如何实现，麻烦指教，谢谢。