动态规划_矩阵连乘问题

就会点儿C++，现在看见个问题就想封装封装，我是装运工么！

有关DP的一些列问题，这篇博客写的极好，戳http://www.cnblogs.com/chinazhangjie/archive/2010/11/16/1878400.html

动态规划要素：

1.最优子结构性质:最优解包含着其子问题的最优解.

2.子问题的重叠性质:递归算法求解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次.

3.备忘录方法：为每个解过的子问题建立了备忘录以备需要时查看，避免了相同子问题的重复求解。

矩阵连乘问题

（以上是我截图上面链接里的博客内容）

刚开始就这里的P*P*P没明白, 其实就是自己数学sucks!

计算两个矩阵相乘，比如A1*A2,则总共要计算的乘法次数就是30 * 35 *15。那么把A1到A6从k位置分隔开来后，实际还是两个矩阵相乘啦，因为矩阵*矩阵还是矩阵，而且矩阵乘法满足结合律。所以这个P*P*P就是(A1~A6)被分割后，最后还得加上(A1~Ak)和 (Ak+1 ~ A6)这两大矩阵相乘的次数。就好比A1*A2, (i-1)对应30, k对应35,  j对应15。

而且实际代码里的两个二维数组m_和 s_都是7*7的矩阵，为的就是不用考虑恼人的下标0的问题。

实际是这样的，外面都多了一圈0.

代码如下(备忘录方法)

#ifndef MATRIX_CHAIN_H_
#define MATRIX_CHAIN_H_ 
#include <iostream>
#include <vector>

class MatrixChain
{
    public:
        MatrixChain(int nMatrix, int value[])
            :nMatrix_(nMatrix), value_(value)
        {}
        void initBothMatrix();
        int lookupChain(int i, int j);
        void traceChain(int i, int j);
        void printBest();
        ~MatrixChain(){}

    private:
        int* value_; //to store each Matrix's column and the first Matrix'srow
        int nMatrix_; 
        std::vector<std::vector<int> > m_; //to store min result between 'Matrix_i' and 'Matrix_j'
        std::vector<std::vector<int> > s_; //to store the segment position, s[i][j]=k

};

#endif  /*MATRIX_CHAIN_H_*/

#include <iostream>
#include <vector>
#include "MatrixChain.h"
using namespace std;

/* 将两个矩阵m_和s_都初始化为(nMatrix + 1) *(nMatrix + 1)大小的矩阵
 * 这便于以后的运算，从而无需考虑下标0的问题
 */
void MatrixChain::initBothMatrix()
{
    m_.resize(nMatrix_ + 1);
    s_.resize(nMatrix_ + 1);
    for(int i = 0; i <= nMatrix_; ++i)
    {
        m_[i].resize(nMatrix_ + 1);
        s_[i].resize(nMatrix_ + 1);
    }

    for(int i = 0; i <= nMatrix_; ++i)
    {
        for(int j = 0; j <= nMatrix_; ++j)
        {
            m_[i][j] = 0;
            s_[i][j] = 0;
        }
    }
}



int MatrixChain::lookupChain(int i, int j)
{
    if(m_[i][j] > 0)
        return m_[i][j];
    if(i == j)
        return 0;
    int u = lookupChain(i, i) + lookupChain(i + 1, j) + *(value_+i-1) * *(value_+i) * *(value_+j);
    s_[i][j] = i;

    for(int k = i + 1; k < j; ++k)
    {
        int t = lookupChain(i, k) + lookupChain(k + 1, j) + *(value_+i-1) * *(value_+k) * *(value_+j);
        if(t < u)
        {
            u = t;
            s_[i][j] = k;
        }
    }
    m_[i][j] = u;
    return u;
}


void MatrixChain::traceChain(int i, int j)
{
    if(i == j){
        cout << "A"<< i;
    }else if(i+1 == j){
        cout <<"(A" << i << "A" << j << ")";
    }else{
        cout << "(";
        traceChain(i, s_[i][j]);
        traceChain(s_[i][j] + 1, j);
        cout << ")";
    }
}

//for test
void MatrixChain::printBest()
{
    /*  
    cout << "m_: " << endl;
    for(int i = 0; i < nMatrix_; ++i)
    {
        for(int j = 0; j<= nMatrix_; ++j)
            cout << m_[i][j] << " ";
        cout << endl;
    }
    cout << "s_: " << endl;
    for(int i = 0; i <= nMatrix_; ++i)
    {
        for(int j = 0; j<= nMatrix_; ++j)
            cout << s_[i][j] << " ";
        cout << endl;
    }

    */
    cout << "min multiply count: " << m_[1][nMatrix_] << endl;
}

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

const int L = 7;
//A1 30*35 A2 35*15 A3 15*5 A4 5*10 A5 10*20 A6 20*25
int main(int argc, const char *argv[])
{
    //p中记录的是所有矩阵的行与最后一个矩阵的列对应的value
    int p[L] = {30, 35, 15, 5, 10, 20, 25};
    MatrixChain matrix_chain(L-1, p);
    matrix_chain.initBothMatrix();
    matrix_chain.lookupChain(1, L-1);
    matrix_chain.printBest();
    matrix_chain.traceChain(1, L-1);

    return 0;
}

 Tips:

1.维数组用vector<vector<> >这种方法还真是省心又好用，就是初始化的时候别忘了用.resize()设置下行列的大小，不然会出现越界之类的错误。

2.C++对齐输出两个矩阵：

#include <iomanip>

cout << setw(7) << m_[i][j]; //以宽度7对齐输出