动态规划 矩阵链乘法

矩阵链乘法

n个矩阵相乘，A1A2...An，试着找到一种相乘顺序，使得整个相乘的过程中所做的标量乘法次数最少，即相乘的代价最小。

问题分析：

　　记矩阵Ai的行列分别为Pi-1和Pi，那么A1*A2所做的乘法的次数为P0*P1*P2

A1A2...An的最小相乘代价为f(1,n)，Ai...Aj的最小相乘代价为f(i,j)

则 f(1,n) = min{f(1,k)+f(k+1,n)+P0*Pk*Pn} k=1...n-1

f(i,i)=0　　f(i,i+1)=Pi-1*Pi*Pi+1

So 可以由此产生递归式

Recursive_Matrix_Multiply(p, i, j)
{    
    if(i==j)
        return 0;
    f[i][j] = max_int;
    for(k=i;k<j;k++)
    {
        q=Recursive_Matrix_Multiply(p,i,k)+Recursive_Matrix_Multiply(p,k+1,j)+p[i-1]*p[k]*p[j];
        if(q<f[i][j])
        {
            f[i][j]=q;
            s[i][j]=k;
        }
    }
    return f[i][j];
}

其中s[i][j]记录的是Ai...Aj相乘的最小代价的分割点，即先计算Ai...Ak，再计算Ak+1...Aj，然后再将结果相乘，Ai...Aj的相乘代价最小

递归的解法看起来思路清晰，但时间复杂度太高

若记n个矩阵的时间复杂度为T(n)，则T(n)=∑_k=1..n-1{T(k) + T(n-k) + c}, 可以推断T(n)>=2ⁿ

分析递归的过程可以发现，有很多子问题被重复计算过了，比如计算A1...A3的过程中需要A2A3，在A1...Aj，j>3的过程中，也都需要A2A3，如果我们能够自底向上开始计算Ai..Aj，并把结果记录下来，后面用到的时候直接查询就可获得，就可以降低时间复杂度了

于是，有了以下自底向上的解法

Matrix_Chain_Order(p, 1, n)
{
    for(t=1;t<n+1;i++)
        f[t][t]=0;
    for(m=2;m<n;m++)
    {
        for(i=1;i<=n-m+1;i++)
        {
            j=i+m-1;
            f[i][j]=max_int;
            for(k=i;k<j;k++)
            {
                q = f[i][k]+f[k+1][j]+p[i-1]*p[k]*p[j];
                if(q<f[i][j])
                {
                    f[i][j]=q;
                    s[i][j]=k;
                }
            }
        }
    }
    return f and s;
}

三层循环，每一层中的循环变量值至多为n-1，故时间复杂度为O(n³)，时间复杂度有指数级 降低到了多项式时间，而付出的代价是增加了O(n²)的辅助空间

动态规划的思想就是以空间为代价，降低算法的时间复杂度