动态规划: 矩阵连乘问题, 最长公共子序列(LCS)，求解0/1揹包问题

通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。

特征：

最优子结构性质：

当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。

重叠子问题性质：

在用递归算法自顶向下解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只解一次，而后将其解保存在一个表格中，在以后尽可能多地利用这些子问题的解。

 

分治与动态规划

共同点：二者都要求原问题具有最优子结构性质,都是将原问题分而治之,分解成若干个规模较小(小到很容易解决的程序)的子问题.然后将子问题的解合并,形成原问题的解.

不同点：分治法将分解后的子问题看成相互独立的，通过用递归来做。

　　　　 动态规划将分解后的子问题理解为相互间有联系,有重叠部分，需要记忆，通常用迭代来做。

 

递推关系： 

 

 

 

矩阵连乘问题:

#include<iostream>
 using namespace std;
 const int MAX = 100;
//p用来记录矩阵的行列，main函数中有说明
//m[i][j]用来记录第i个矩阵至第j个矩阵的最优解
//s[][]用来记录从哪里断开的才可得到该最优解
int p[MAX+1],m[MAX][MAX],s[MAX][MAX];
int n;//矩阵个数

void matrixChain(){
    for(int i=1;i<=n;i++)m[i][i]=0;

    for(int r=2;r<=n;r++)//对角线循环
        for(int i=1;i<=n-r+1;i++){//行循环
            int j = r+i-1;//列的控制
            //找m[i][j]的最小值，先初始化一下，令k=i
            m[i][j]=m[i][i]+m[i+1][j]+p[i-1]*p[i]*p[j];
            s[i][j]=i;
            //k从i+1到j-1循环找m[i][j]的最小值
            for(int k = i+1;k<j;k++){
                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[i][j]=k;
                }
            }
        }
}

//根据s[][]记录的各个子段的最优解，将其输出
void traceback(int i,int j){
    if(i==j)return ;

    traceback(i,s[i][j]);
    traceback(s[i][j]+1,j);
    cout<<"Multiply A"<<i<<","<<s[i][j]<<"and A"<<s[i][j]+1<<","<<j<<endl;
}

int main(){
    cin>>n;
    for(int i=0;i<=n;i++)cin>>p[i];
    //测试数据可以设为六个矩阵分别为
    //A1[30*35],A2[35*15],A3[15*5],A4[5*10],A5[10*20],A6[20*25]
    //则p[0-6]={30,35,15,5,10,20,25}
    //输入：6 30 35 15 5 10 20 25
    matrixChain();

    traceback(1,n);
    //最终解值为m[1][n];
    cout<<m[1][n]<<endl;
    return 0;
}

 

 

动态规划C语言实现之最长公共子序列(LCS) ：

 

递归公式如下：

 

 

 

 

 

 

/***最长公共子序列***/
/*动态规划*/
 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
 
#ifndef size_c
#define size_c 200
#endif // 预定义字符串的长度
 
#define EQUAL   1   //EQUAL表示c[i][j]是由c[i-1][j-1]+1来的=此时两个序列有相同的字符
#define UP      2   //UP表示c[i][j]是由c[i-1][j]来的========此时两个序列没有相同的字符
#define LEFT    3   //LEFT表示c[i][j]是由[ci][j-1]来的======此时两个序列没有相同的字符
 
//int char1[size_c][size_c];  //定义两个二维数组存放字符串
//int char2[size_c][size_c];  //1存放位置，2存放路径
 
int max(int m, int n, int i, int j);
int print(int i, int j);
 
/***函数一、判断LCS长度***/
int Lcs_len(char *str1, char *str2, int **char1, int **char2)
{
    //int char1[size_c][size_c] = {0};
    //int char2[size_c][size_c] = {0};
 
    int m = strlen(str1);
    int n = strlen(str2);  //求出两个数组的边界长度
 
    int i, j;
    for (i = 0; i <=  m; i++)
    {
        char1[i][0] = 0;
    }
 
    for (j = 0; j <=  n; j++)  //初始化边界条件
    {
        char1[0][j] = 0;
    }
 
    for ( i = 1; i <= m; i++)
    {
        for ( j = 1; j <= n; j++)
        {
            if( str1[i-1] == str2[j-1] )
    // 这里使用i-1以及j-1是由于数组的下标从0开始
    //另一种实现方式是逆序实现，对于路径的确定更方便
            {
                char1[i][j] = char1[i-1][j-1] + 1;
                char2[i][j] = EQUAL;
            }
            else if (char1[i-1][j] >= char1[i][j-1])//在j循环时若字符串不等
                {                                // 则只用判断char中的元素
                char1[i][j] = char1[i-1][j];
                char2[i][j] = UP;
                }
            else
                {
                char1[i][j] = char1[i][j-1];
                char2[i][j] = LEFT;
                }
        }
 
 
    }
    return char1[m][n];  //递归的最终位存储的数字就是LCS长度
}
 
/***函数二、输出LCS***/
 
void Print_Lcs( char *str, int **b, int i, int j)
{
    if( i == 0 || j == 0)
        return;    //递归至边界则扫描完毕
    if( b[i][j] == EQUAL)
    {                     //对于相等的元素，其路径为左上方对角移动
        Print_Lcs(str, b, i - 1, j - 1);
        printf("%c ", str[i-1]);  //相等的话，原字符序列向前递归一位并打印出字符
    }
    else if ( b[i][j] == UP )  //不相等时判断方向：向上则数组向上位移
        Print_Lcs(str, b, i - 1, j);
    else
        Print_Lcs(str, b, i , j - 1); //否则数组下标向左位移一位
 
}
 
/***函数三、整合LCS函数***/
void Find_Lcs( char *str1, char *str2)
{
    int i,j,length;
    int len1 = strlen(str1),
        len2 = strlen(str2);
    //申请二维数组
    int **c = (int **)malloc(sizeof(int*) * (len1 + 1));
    int **b = (int **)malloc(sizeof(int*) * (len1 + 1));
    for( i = 0; i<= len1; i++ )  ////这个等号之前没加，导致内存泄漏
    {
        c[i] = (int *)malloc(sizeof(int) * (len2 + 1));
        b[i] = (int *)malloc(sizeof(int) * (len2 + 1));
    }
 
    //将c[len1][len2]和b[len1][len2]初始化为0
    for ( i = 0; i<= len1; i++)
        for( j = 0; j <= len2; j++)
        {
            c[i][j] = 0;
            b[i][j] = 0;
        }
 
    //计算LCS的长度
    length = Lcs_len(str1, str2, c, b);
    printf("The number of the Longest-Common-Subsequence is %d\n", length);
 
    //利用数组b输出最长子序列
    printf("The Longest-Common-Subsequence is: ");
    Print_Lcs(str1, b, len1, len2);
    printf("\n");
 
    //动态内存释放
    for ( i = 0; i <= len1; i++)
    {
        free(c[i]);
        free(b[i]);
    }
    free(c);
    free(b);
}
 
/***LCS测试输出***/
 
int main(int *argc, int *argv[])
{
 
    char X[size_c],Y[size_c];
    int len;
    printf("please enter your characters:");
    scanf("%s",X);
    while(strlen(X) > 200) //规定字符串序列的最大长度，此处为200
    {
        printf("what you input is too long, please try again");
        scanf("%s\n",X);//超出限制时提醒并重新输入
    }
    printf("please enter your characters:");
    scanf("%s",Y);
    while(strlen(Y) > 200)  //长度限制同上
    {
        printf("what you input is too long, please try again");
        scanf("%s",Y);
    }
 
    Find_Lcs(X,Y);  //使用LCS函数输出长度与子序列
    system("pause");
}

 

 

动态规划法：求解0/1揹包问题：

 

 

 

 

 

 

#include <iostream>
#include<cstdio>
#define N 100
#define MAX(a,b) a < b ? b : a
using namespace std;

struct goods{
int sign;//物品序号
int wight;//物品重量
int value;//物品价值
};

int n,bestValue,cv,cw,C;//物品数量，价值最大，当前价值，当前重量，揹包容量
int X[N],cx[N];//最终存储状态，当前存储状态
struct goods goods[N];

int KnapSack(int n,struct goods a[],int C,int x[]){
    int V[N][10*N];
    for(int i = 0; i <= n; i++)//初始化第0列
        V[i][0] = 0;
    for(int j = 0; j <= C; j++)//初始化第0行
        V[0][j] = 0;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= C; j++)
        if(j < a[i-1].wight)
            V[i][j] = V[i-1][j];
        else
            V[i][j] = MAX(V[i-1][j],V[i-1][j-a[i-1].wight] + a[i-1].value);

    for(int i = n,j = C; i > 0; i--){
        if(V[i][j] > V[i-1][j]){
            x[i-1] = 1;
            j = j - a[i-1].wight;
        }
        else
            x[i-1] = 0;
    }
    return V[n][C];
}
int main()
{
    printf("物品种类n：");
    scanf("%d",&n);
    printf("揹包容量C：");
    scanf("%d",&C);
    for(int i = 0; i < n; i++){
        printf("物品%d的重量w[%d]及其价值v[%d]：",i+1,i+1,i+1);
        scanf("%d%d",&goods[i].wight,&goods[i].value);
    }
    int sum2 = KnapSack(n,goods,C,X);
     printf("动态规划法求解0/1揹包问题:\nX=[");
     for(int i = 0; i < n; i++)
        cout<<X[i]<<" ";//输出所求X[n]矩阵
     printf("]   装入总价值%d\n", sum2);
     return 0;
}