算法导论之动态规划：矩阵链相乘

#include <iostream>
#include <errno.h>
#include <sys/time.h>
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 recursive_matrix_chain(int *p, int i, int j, int m[N+1][N+1], int s[N+1][N+1]);
void 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<<"The result is:"<<end;
  print_optimal_parents(s, 1, N);
  cout<<endl<<"recursive with memorizing..."<<endl;
  
  for(i = 0; i < N+1; i++)
    for(j = 0; j < N+1; j++)
      {
        m[N+1][N+1] = 0;
        s[N+1][N+1] = 0;
      }
  cout<<"minimum computing : "<<lookup_chain(p, 1, N, m, s);
  for(i = 1; i <= N; i++)
    {
      for(j = 1; j <= N; j++)
        cout<<m[i][j]<<" ";
      cout<<endl;
    }
  cout<<"The result is:"<<end;
  print_optimal_parents(s, 1, N);
  cout<<endl<<"recursive with memorizing..."<<endl;
  
  return 0;
}
/* m[i,j] = m[i][k] * m[k+1]m[j] + p(i-1)*p(k)*p(j) */
void matrix_chain_order(int *p, int len, int m[N+1][N+1], int s[N+1][N+1])
{
  int n = len -1;
  int temp_chain_len , temp_result;
  for(temp_chain_len = 2; temp_chain_len <= n; temp_chain_len++)
    {
      for(int i = 1; i <= n - temp_chain_len + 1; i ++)
        {
          int j = i + temp_chain_len - 1;
          temp_result = 0;
          for(int k = i; k < j; k++)
            {
              temp_result = m[i][k] * m[k+1]m[j] + p[i-1]*p[k]*p[j];
              if(m[i][j] > temp_result)
                {
                  m[i][j] = temp_result;
                  s[i][j] = k;
                }
            }
          
        }
    }
}


void print_optimal_parents(int s[N+1][N+1], int i, int j)
{
  if(i == j)
    cout<<"A";
  else
    {
      cout<<"(";
      print_optimal_parents(s, i, s[i,j]);
      print_optimal_parents(s, s[i,j] + 1, j);
      cout<<")";
    }
  cout<<endl;
}


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] > 0)
    return m[i][j];
  if(j == i)
    m[i][j] = 0;
  else
    {
      int k;
      for(k = i; k < 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];
          it(temp < m[i][j])
            {
              m[i][j] = temp;
              s[i][j] = k;
            }
        }
    }
  return m[i][j];
}