动态规划相关问题源码(包括矩阵链乘、LCS、和max sum)

functions.h

#include <iostream>
using namespace std;
#define SIZE 100     //数组大小
//****重载的计算数组长度函数****
int length(int a[]);
int length(char a[]);
//-----------------------------------
//****初始化数组函数******
void InitArray(int a[SIZE][SIZE]);
void InitArray(double a[SIZE][SIZE]);
//-----------------------------------
//****输入数组中数据*****
void Input(char p[]);
void Input(int p[]);
//-----------------------------------
//****打印数组中数据*****
void PrintArray(int a[SIZE][SIZE],int lr,int lc);
//-----------------------------------
//*****矩阵链乘*****
void Matrix_chain_order(double m[20][20],double s[20][20],int p[20]);
void Print_optimal_parens(double s[20][20],int i,int j);
//-----------------------------------
//********LCS********
void LCS_Length(char x[],char y[],int b[SIZE][SIZE],int c[SIZE][SIZE]);
void Print_LCS(int b[SIZE][SIZE],char x[],int i,int j);
//-----------------------------------
//*******Max_Sum******
int BetterMaxSum(int n, int a[], int &besti, int &bestj);
//-----------------------------------

functions.cpp

#include "Functions.h"
//**************************************************************
//----------计算数组a中元素个数,返回元素个数值------------------
int length(int a[])
{
int count=0;
while(a[count]!=0)
   count++;
return count;
}
int length(char a[])
{
int count=0;
while(a[count]!='/0')
   count++;
return count-1;
}
//--------------------------------------------------------------
//**************************************************************
//--------初始化二维数组a，将其中所有元素值均赋为0--------------
void InitArray(int a[SIZE][SIZE])
{
for(int i=0;i<SIZE;i++)
{
for(int j=0;j<SIZE;j++)
{
   a[i][j]=0;
}
}
}
void InitArray(double a[SIZE][SIZE])
{
for(int i=0;i<SIZE;i++)
{
for(int j=0;j<SIZE;j++)
{
   a[i][j]=0;
}
}
}
//--------------------------------------------------------------
//**************************************************************
//------------------输入数组p中元素-----------------------------
void Input(char p[])
{
cout<<"输入序列：";
gets(p);
//_____________________________
// 将字符数组中所有元素后移一位
//-----------------------------
int pos=0;
while(p[pos]!='/0')
    pos++;
p[pos+2]='/0';
while(pos>=0)
{
   p[pos+1]=p[pos];
   pos--;
}
//------------------------------
}
void Input(int p[])
{
int len;
cout<<"输入序列长度:";
cin>>len;
for(int i=0;i<len;i++)
{
   cout<<"输入数据p"<<i<<":";
   cin>>p[i];
}
p[len]=0;
}
//--------------------------------------------------------------
//**************************************************************
//--------------------输出数组中元素----------------------------
void PrintArray(int a[SIZE][SIZE],int lr,int lc)
{
for(int i=0;i<lr;i++)
{
   for(int j=0;j<lc;j++)
    cout<<a[i][j]<<"   ";
   cout<<endl;
}
cout<<endl;
}
//--------------------------------------------------------------
//**************************************************************
//-----------------矩阵链乘相关函数实现-------------------------
void Matrix_chain_order(double m[20][20],double s[20][20],int p[20])
{
int n=length(p)-1;
for(int i=1;i<=n;i++)
   m[i][i]=0;
for(int l=2;l<=n;l++)
{
   for(int i=1;i<=(n-l+1);i++)
   {
    int j=i+l-1;
    m[i][j]=10000000;
    for(int k=i;k<=(j-1);k++)
    {
     int q=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
       if(q<m[i][j])
     {
      m[i][j]=q;
      s[i][j]=k;
     }
    }
   }
}
}
void Print_optimal_parens(double s[20][20],int i,int j)
{
if(i==j)
   cout<<"A"<<i;
else
{
   cout<<"(";
   Print_optimal_parens(s,i,s[i][j]);
   Print_optimal_parens(s,s[i][j]+1,j);
   cout<<")";
}
}
//--------------------------------------------------------------
//**************************************************************
//-------------------LCS相关函数实现----------------------------
void LCS_Length(char x[],char y[],int b[SIZE][SIZE],int c[SIZE][SIZE])
{
int m=length(x);
int n=length(y);
for(int i=1;i<=m;i++)
   c[i][0]=0;
for(int j=0;j<=n;j++)
   c[0][j]=0;
for(int i=1;i<=m;i++)
{
   for(int j=1;j<=n;j++)
   {
    if(x[i]==y[j])
    {   
     c[i][j]=c[i-1][j-1]+1;
     b[i][j]=2;  
    }
    else
     {
      if(c[i-1][j]>=c[i][j-1])
         {
          c[i][j]=c[i-1][j];
          b[i][j]=3;
          }
        else
        {
        c[i][j]=c[i][j-1];
        b[i][j]=4;
   
         }
       }
   }
}
}
void Print_LCS(int b[SIZE][SIZE],char x[],int i,int j)
{
if(i==0||j==0)
   return;
if(b[i][j]==2)
{
   Print_LCS(b,x,i-1,j-1);
   cout<<x[i];
}
else
   {
    if(b[i][j]==3)
      Print_LCS(b,x,i-1,j);
         else
         Print_LCS(b,x,i,j-1);
     }
}
//--------------------------------------------------------------
//**************************************************************
//---------------Max-Sum相关函数实现----------------------------
int BetterMaxSum(int n, int a[], int &besti, int &bestj)
{
int sum = 0;
for(int i=1; i <= n; ++i)
{
   int thissum = 0;
   for(int j=i; j <= n; ++j)
   {
    thissum += a[j];
    if(thissum > sum)
    {
     sum = thissum;
     besti = i, bestj = j;
    }
   }
}
return sum;
}
//--------------------------------------------------------------

main.cpp

#include "Functions.h"
int main()
{
//######################################
//===========矩阵链乘测试代码=========
/*int p[20];
Input(p);
double m[20][20],s[20][20];
for(int i=0;i<20;i++)
{
for(int j=0;j<20;j++)
{
   m[i][j]=0;
   s[i][j]=0;
}
}
Matrix_chain_order(m,s,p);
Print_optimal_parens(s,1,length(p)-1);
*/
//########################################

//#######################################
//=========== LCS测试代码 ============
/*char x[SIZE],y[SIZE];
cout<<"请输入序列1："<<endl;
Input(x);
cout<<"请输入序列2："<<endl;
Input(y);
int b[SIZE][SIZE],c[SIZE][SIZE];
InitArray(b);
InitArray(c);
LCS_Length(x,y,b,c);
PrintArray(c,length(x)+1,length(y)+1);
PrintArray(b,length(x)+1,length(y)+1);
Print_LCS(b,x,length(x),length(y));*/
//#######################################

//#######################################
//==========Max-Sum测试代码==========
int a[20];
Input(a);
int besti,bestj;
int sum=BetterMaxSum(length(a),a,besti,bestj);
cout<<"Ans: i="<<besti<<"   j="<<bestj;
cout<<", Max Sum is "<<sum<<endl;
//#######################################
system("PAUSE");
return 0;
}