算法13---動態規划矩陣鏈乘法

矩陣鏈乘法是動態規划里面使用到的一個例子

 

1 兩個矩陣的計算

 

那么對於一個矩陣的乘法，首先如果是兩個矩陣的乘法，那么如何實現呢？

注意到我們使用二維數組表示矩陣，但是二維數組不能作為函數的返回值。具體實現如下

 

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define a_rows  3
#define a_columns 4
#define b_rows  4
#define b_columns 3

void matrix_multiply(int a[a_rows][a_columns],int b[b_rows][b_columns],int c[a_rows][b_columns])
{
    if (a_columns!=b_rows)
    {
        printf("error!can't figure the answer!\n");
    }
    for (int i = 0; i < a_rows; i++)
    {
        for (int j = 0; j < b_columns; j++)
        {
            c[i][j]=0;
            for (int k = 0; k< a_columns; k++)
            {
                c[i][j]=c[i][j]+a[i][k]*b[k][j];
            }
        }
    }
}

int main()
{

    printf("it is a easy matrix \n");

    int a[a_rows][a_columns]={{1,1,1,1},{2,2,2,2},{3,3,3,3}};
    int b[b_rows][b_columns]={{1,1,1},{2,2,2},{3,3,3},{4,4,4}};
    int c[a_rows][b_columns]={0};
    matrix_multiply(a,b,c);
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            printf("%d  \n",c[i][j]);
            if (j==2)
            {
                printf("\n");
            }
        }
    }
    return 0;
}

 

2 矩陣鏈問題

 

問題描述

     給定n個矩陣構成的一個鏈<A ₁,A ₂,A ₃,.......A _n>，其中i=1,2,...n，矩陣A的維數為p _i-1p _i，對乘積 A ₁A ₂...A _n 以一種最小化標量乘法次數的方式進行加全部括號。

　　換句話說，就是在矩陣鏈乘問題中，實際上並沒有把矩陣相乘，目的是確定一個具有最小代價的矩陣相乘順序。找出這樣一個結合順序使得相乘的代價最低。

 

一般的過程如下

（1）最優括號話方案的結構特征

  假設AiAi+1....Aj的一個最優加全括號把乘積在Ak和Ak+1之間分開，則Ai..k和Ak+1..j也都是最優加全括號的。

 

（2）一個遞歸求解方案

     設m[i,j]為計算機矩陣Ai...j所需的標量乘法運算次數的最小值，對此計算A1..n的最小代價就是m[1,n]。現在需要來遞歸定義m[i,j]，分兩種情況進行討論如下：

 

     當i==j時：m[i,j] = 0，（此時只包含一個矩陣）

     當i<j 時：從步驟1中需要尋找一個k（i≤k＜j）值，使得m[i,j] ＝min{m[i,k]+m[k+1,j]+pi-1pkpj} （i≤k＜j）。

 

（3）計算最優代價

我們不采用遞歸實現，而是自下向上的借助輔助空間保存中間量實現；

 

（4）構造一個最優解

 

 

具體的實現過程如下面所示

 

還沒有調好，主要是二維數組不能作為返回值

 

#include <stdio.h>
#include <stdlib.h>

#define N 6
#define MAXVALUE 999999

void recursive_matrix_chain(int *p,int i,int j,int m[N+1][N+1],int s[N+1][N+1]);
int memoized_matrix_chain(int *p,int m[N+1][N+1],int s[N+1][N+1]);
int lookup_chain(int *p,int i,int j,int m[N+1][N+1],int s[N+1][N+1]);

//我們首先采用遞歸來實現
void recursive_matrix_chain(int *p,int i,int j,int m[N+1][N+1],int s[N+1][N+1])
{
    if (i==j)
    {
        m[i][j]=0;
    }
    else
    {
        int k;
        m[i][j]=MAXVALUE;
        for (int k = i; k < j; k++)
        {
            int temp=recursive_matrix_chain(p,i,k,m,s)+recursive_matrix_chain(p,k+1,j,m,s)+p[i-1]*p[k]*p[j];
            if (temp<m[i][j])
            {
                m[i][j]=temp;
                s[i][j]=k;
            }
        }

    }
}

//因為遞歸的計算量太大，所以我們可以采用備忘錄的方法，自頂向下實現

int memoized_matrix_chain(int *p,int m[N+1][N+1],int s[N+1][N+1])
{

    for (int i = 1; i <=N; ++i)
    {
        for (int j = 0; j <=N; ++j)
        {
            m[i][j]=MAXVALUE;
        }
    }
    return lookup_chain(p,1,N,m,s);
}

int lookup_chain(int *p,int i,int j,int m[N+1][N+1],int s[N+1][N+1])
{
    if (m[i][j]<MAXVALUE)
    {
        return m[i][j];
    }
    if (i==j)
    {
        m[i][j]=0;
    }
    else
    {
        for (int k = i; i < j; ++k)
        {
            int temp=lookup_chain(p,i,k,m,s)+lookup_chain(p,k+1,j,m,s)+p[i-1]*p[k]*p[j];
            if (temp<m[i][j])
            {
                s[i][j]=k;
            }
        }
    }
    return m[i][j];
}


void print_optimal_parens(int s[N+1][N+1],int i,int j)
{
    if (i==j)
    {
        printf("A%d\n",i);
    }
    else
    {
        printf("(");
        print_optimal_parens(s,i,s[i][j]);
        print_optimal_parens(s,s[i][j]+1,j);
        printf(")");
    }
}

int main()
{
    int p[N+1] = {30,35,15,5,10,20,25};
    int m[N+1][N+1]={0};
    int s[N+1][N+1]={0};
    int i,j;
    memoized_matrix_chain(p,N+1,m,s);
    printf("m value is: " );

    for(i=1;i<=N;++i)
    {
        for(j=1;j<=N;++j)
            printf("%d ",m[i][j]);
        printf("\n");
    printf("s value is: \n");

    for(i=1;i<=N;++i)
    {
        for(j=1;j<=N;++j)
            printf("%d ",s[i][j]);
        printf("\n");
    }
    printf("the result is:\n");
    print_optimal_parents(s,1,N);
    return 0;
}

 

 

現在再給出一個c++的版本，一個實現，我是看的別人的，自己可以修改

 

#include <iostream>
using namespace std;

#define N 6
#define MAXVALUE 1000000

void matrix_chain_order(int *p,int len,int m[N+1][N+1],int s[N+1][N+1]);
void print_optimal_parents(int s[N+1][N+1],int i,int j);

int main()
{
    int p[N+1] = {30,35,15,5,10,20,25};
    int m[N+1][N+1]={0};
    int s[N+1][N+1]={0};
    int i,j;
    matrix_chain_order(p,N+1,m,s);
    cout<<"m value is: "<<endl;
    for(i=1;i<=N;++i)
    {
        for(j=1;j<=N;++j)
            cout<<m[i][j]<<" ";
        cout<<endl;
    }
    cout<<"s value is: "<<endl;
    for(i=1;i<=N;++i)
    {
        for(j=1;j<=N;++j)
            cout<<s[i][j]<<" ";
        cout<<endl;
    }
    cout<<"The result is:"<<endl;
    print_optimal_parents(s,1,N);
    return 0;
}

void matrix_chain_order(int *p,int len,int m[N+1][N+1],int s[N+1][N+1])
{
    int i,j,k,t;
    for(i=0;i<=N;++i)
        m[i][i] = 0;
    for(t=2;t<=N;t++)  //當前鏈乘矩陣的長度
    {
        for(i=1;i<=N-t+1;i++)  //從第一矩陣開始算起，計算長度為t的最少代價
        {
            j=i+t-1;//長度為t時候的最后一個元素
            m[i][j] = MAXVALUE;  //初始化為最大代價
            for(k=i;k<=j-1;k++)   //尋找最優的k值，使得分成兩部分k在i與j-1之間
            {
                int temp = m[i][k]+m[k+1][j] + p[i-1]*p[k]*p[j];
                if(temp < m[i][j])
                {
                    m[i][j] = temp;   //記錄下當前的最小代價
                    s[i][j] = k;      //記錄當前的括號位置，即矩陣的編號
                }
            }
        }
    }
}

//s中存放着括號當前的位置
void print_optimal_parents(int s[N+1][N+1],int i,int j)
{
    if( i == j)
        cout<<"A"<<i;
    else
    {
        cout<<"(";
        print_optimal_parents(s,i,s[i][j]);
        print_optimal_parents(s,s[i][j]+1,j);
        cout<<")";
    }

}