最优矩阵链乘

问题描述：

　　一个n×m矩阵由n行m列共n×m个数排列而成。两个矩阵A和B可 以相乘当且仅当A的列数等于B的行数。一个n×m的矩阵乘以一个m×p的矩阵等于 一个n×p的矩阵，运算量为m×n×p。矩阵乘法不满足分配律，但满足结合律，因此A×B×C可以按顺序(A×B)×C进行也可以按A×(B×C)来进行。假设A、B、C分别 是2×3，3×4，4×5的，则(A×B)×C的运算量为2×3×4+2×4×5=64，A×(B×C)的运算 量为3×4×5+2×3×5=90。显然第一种顺序节省运算量。给出n个矩阵组成的序列，设计一种方法把它们乘起来，使得总的运算量尽量小。假设第i个矩阵Ai是p[i−1] ×p[i]的。 

分析：

　　可以把这n个矩阵分成两部分，P = A₁ x A₂ x A₃...A_k和Q = A_k+1 x A_k+2...A_n，1<= k < n，显然结果就是k循环一遍，取其中PxQ结果最小的。

　　dp[i][j]表示从第i个矩阵乘到第j个矩阵所需要的最小代价。

　　状态转移方程：dp[i][j] = min(dp[i][k] + dp[k + 1][j] + p[i - 1] * p[k] * p[j]), i <= k < j

代码实现：

　　写法一：记忆化搜索

int solve(int i, int j)
{
    if(dp[i][j] < minn)
        return dp[i][j];
    if(i == j)
        dp[i][j] = 0;
    else
    {
        for(int k = i; k < j; k++)
        {
            int ans = solve(i, k) + solve(k + 1, j) + p[i - 1] * p[k] * p[j];
            if(ans < dp[i][j])
                dp[i][j] = ans;
        }
    }
    return dp[i][j];
}

　　写法二：递推

for(int i = 0; i < n; i++)
{
    //长度为1时
    dp[i][i] = 0;
}
for(int len = 2; len <= n; len++)
{
    //从小到大依次求出相应长度时的情况
    for(int i = 1; i < n - len + 1; i++)
    {
        j = i + len - 1;
        for(k = i; k < j; k++)
        {
            int ans = dp[i][k] + dp[k + 1][j] + p[i - 1] * p[k] * p[j];
            if(ans < dp[i][j])
                dp[i][j] = ans;
        }
    }
}

---

看一道例题

题目链接：

　　http://poj.org/problem?id=1651

题意：

　　给你n张牌，每次抽一张，每次抽取的价值等于这张牌的值乘以这张牌左右两张的值，其中，第一张和最后一张不能抽，问你怎样的抽取方案能够取到最小价值

分析：

　　典型的最优矩阵链乘，直接看代码理解吧

代码：

#include<iostream>
using namespace std;
int dp[110][110];    //dp[i][j]表示从i到j中（不包括i和j）抽数能得到的最小值
int num[110];
int main()
{
    int n;
    cin >> n;
    for(int i = 0; i < n; i++)
        cin >> num[i];

    for(int i = 0; i < n - 2; i++)
        dp[i][i + 2] = num[i] * num[i + 1] * num[i + 2];

    for(int len = 3; len < n; len++)
    {
        for(int i = 0; i + len < n; i++)
        {
            int j = i + len;
            for(int k = i + 1; k < j; k++)
            {
                if(dp[i][j] == 0)
                    dp[i][j] = dp[i][k] + dp[k][j] + num[i] * num[k] * num[j];
                else
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + num[i] * num[k] * num[j]);
            }
        }
    }
    cout << dp[0][n - 1] << endl;
    return 0;
}