矩阵连乘 DP

矩阵相乘问题：
假设存在一个矩阵A维数是3*2，一个矩阵B维数是2*2，首先我们先看一下A*B的情况，这两个矩阵相乘的计算量：

代码如下：

//矩阵a和b相乘，p、q分别为a的行和列，q、r分别为b的行和列
void MatrixMultiply(int a[][MAXN], int b[][MAXN], int p, int q, int r)
{
    int sum[MAXN][MAXN];
    memset(sum, 0, sizeof(sum));

    int i, j, k;
    //遍历矩阵a的行
    for (k = 0; k < p; k++)
    {
        //遍历矩阵b的列
        for (j = 0; j < r; j++)
        {
            //对应位置相乘
            for (i = 0; i < q; i++)
            {
                sum[k][j] += a[k][i] * b[i][j];
            }
        }
    }
}

A*B矩阵一共进行了p*q*r乘法计算p*q*r/2次加法运算。大家都知道乘法的计算是十分耗费时间的，所以我们的目的是要减少乘法的计算次数。
下面我来看矩阵A*B*C*D连乘

1、（A（BCD））——>（A（B（CD））），（A（（BC）D））;
2、（（AB）（CD））——>NULL；
3、（（ABC）D）——>（（A（BC）D）），（（（AB）C）D）;
对于上面四个矩阵来说，枚举方法是：
1、括号加在A和B之间，矩阵链被分为（A）和（BCD）；
2、括号加在B和C之间，矩阵链被分为（AB）和（CD）；
3、括号加在C和D之间，矩阵链被分为（ABC）和（D）；
在第一步中分出的（A）已经不能在加括号了，所以结束；
而（BCD）继续按照上面的步奏把括号依次加在B和C、C和D之间，其他情况相同。
加括号的过程是递归的。

//m数组内存放矩阵链的行列信息
//m[i-1]和m[i]分别为第i个矩阵的行和列（i = 1、2、3...）
int Best_Enum(int m[], int left, int right)
{
    //只有一个矩阵时，返回计算次数0
    if (left == right)
    {
        return 0;
    }

    int min = INF; //无穷大
    int i;
    //括号依次加在第1、2、3...n-1个矩阵后面
    for (i = left; i < right; i++)
    {
        //计算出这种完全加括号方式的计算次数
        int count = Best_Enum(m, left, i) + Best_Enum(m, i+1, right);
        count += m[left-1] * m[i] * m[right];
        //选出最小的
        if (count < min)
        {
            min = count;
        }
    }
    return min;
}

备忘录法优化

上图为递归枚举过程，小方块内的1:4代表第1个矩阵至第4个矩阵的完全加括号方式

我们可以看到黄色方块中有很多重复计算，所以利用备忘录来保存计算结果，在每次进行计算前，
先查表，看是否计算过，避免重复计算。

#include<iostream>
#include<string.h>
using namespace std;


#define SIZE 100
#define INF 0x7fffffff 

int memo[SIZE][SIZE];

//m数组内存放矩阵的行列信息
//m[i-1]和m[i]分别为第i个矩阵的行和列（i = 1、2、3...）
int Best_Memo(int m[], int left, int right)
{
    //只有一个矩阵时，返回计算次数0
    if (left == right)
    {
        return 0;
    }

    int min = INF;
    int i;
    //括号依次加在第1、2、3...n-1个矩阵后面
    for (i = left; i < right; i++)
    {
        //计算出这种完全加括号方式的计算次数
        int count;
        if (memo[left][i] == 0)
        {
            memo[left][i] = Best_Memo(m, left, i);
        }
        count = memo[left][i];
        if (memo[i+1][right] == 0)
        {
            memo[i+1][right] = Best_Memo(m, i+1, right);
        }
        count += memo[i+1][right];
        count += m[left-1] * m[i] * m[right];
        //选出最小的
        if (count < min)
        {
            min = count;
        }
    }
    return min;
}

int main()
{
    int m[SIZE];
    int n;
    while (cin>>n)
    {
        int i;
        for (i = 0; i < n; i++)
        {
            cin>>m[i];
        }
        memset(memo, 0, sizeof(memo));
        cout<<Best_Memo(m, 1, n-1);
    }
    return 0;
} 

以矩阵链ABCD为例
按照矩阵链长度递增计算最优值
矩阵链长度为1时，分别计算出矩阵链A、B、C、D的最优值
矩阵链长度为2时，分别计算出矩阵链AB、BC、CD的最优值
矩阵链长度为3时，分别计算出矩阵链ABC、BCD的最优值
矩阵链长度为4时，计算出矩阵链ABCD的最优值

k为矩阵链断开的位置
d数组存放矩阵计算的最优值，d[i][j]是以第i个矩阵为首，第j个矩阵为尾的矩阵链的最优值，i > 0
m数组内存放矩阵链的行列信息，m[i-1]和m[i]分别为第i个矩阵的行和列（i = 1、2、3…）

#include<iostream>
#include<string.h>
using namespace std;

#define SIZE 100
#define INF 0x7fffffff

int m[SIZE];        //存放矩阵链的行列信息，m[i-1]和m[i]分别为第i个矩阵的行和列（i = 1、2、3...）
int d[SIZE][SIZE];  //存放矩阵链计算的最优值，d[i][j]为第i个矩阵到第j个矩阵的矩阵链的最优值，i > 0

int Best_DP(int n)
{
    //把d[i][i]置为0，1 <= i < n
    memset(d, 0, sizeof(d));

    int len;
    //递归计算矩阵链的连乘最优值
    //len = 1，代表矩阵链由两个矩阵构成
    for (len = 1; len < n; len++)
    {
        int i, j, k;
        for (i = 1, j = i+len; j < n; i++, j++)
        {
            int min = INF; //无穷大
            for (k = i; k < j; k++)
            {
                int count = d[i][k] + d[k+1][j] + m[i-1] * m[k] * m[j];
                if (count < min)
                {
                    min = count;
                }
            }
            d[i][j] = min;
        }
    }
    return d[1][n-1];
}

int main()
{
    int n;
    while (cin>>n)
    {
        int i;
        for (i = 0; i < n; i++)
        {
            cin>>m[i];
        }

        cout<<Bset_DP(n);
    }
    return 0;
}