算法分析 | 动态规划算法设计之最长公共子序列 C语言版

声明：凡代码问题，欢迎在评论区沟通。承蒙指正，一起成长！

一、实验内容与要求

内容：最长公共子序列
·若给定序列X={x1,x2,…,xm},则另一序列Z={z1,z2,…,zk},是X的子序列是指存在一个严格递增下标序列{i1,i2,…,ik}使得对于所有j=1,2,…,k有：zj=xj。例如，序列Z={B,C,D,B}是序列X={A,B,C,B,D,A,B}的子序列，相应的递增下标序列为{2,3,5,7}。
·给定2个序列X和Y,当另一序列Z既是X的子序列又是Y的子序列时，称Z是序列X和Y的公共子序列。
·给定2个序列X={x1,x2,…,xm}和Y={y1.y2,…,yn}，找出X和Y的最长公共子序列。
要求：随机输入两个字符序列，求出其最长公共子序列的长度，并输出最长公共子序列字符串。

二、概要设计

1.定义字符数组x[Xm],y[Yn];，用于保存输入的两个序列；
2.主函数中输入Xm、Yn，分别为数组的长度约束；然后分别输入两个序列，若超出长度约束时提醒并退出；
3.根据数组规模动态申请两个整型二维数组b、c，用于保存最长公共子序列的长度和输出参数；
4.在Defind_Array(c,b,len1,len2)函数中，将数组将c[len1][len2]和b[len1][len2]初始化为0；
5.在 LCSLength(strlen(x),strlen(y),x, y, c, b)函数中，以x和y作为输入，输出两个数组b和c，其中b存储最长公共子序列的长度，c记录指示b的值是由那个子问题解答得到的，最后将最终的最长公共子序列的长度记录到b中。以LCSLength计算得到的数组c可用于快速构造序列最长公共子序列。当x[j]=y[j]时，找出这两个字符串j之前的最长公共子序列，然后在其尾部加上x[j]，即可得到最长公共子序列。当x[j] ≠ y[j]时，需要解决两个子问题：即找出x(j-1)和y的一个最长公共子序列及x和y(j-1)的一个最长公共子序列，这两个公共子序列中较长者即为x和y的一个最长公共子序列。首先从c的最后开始，对c进行配对。当遇到“1”时，表示最长公共子序列是由x(i-1)和y(j-1)的最长公共子序列在尾部加上x(i)得到的子序列；当遇到“2”时，表示最长公共子序列和x(i-1)与y(j)的最长公共子序列相同；当遇到“3”时，表示最长公共子序列和x(i)与y(j-1)的最长公共子序列相同。最后递归的最终位存储的数字就是LCS长度，打印sum值；
6.在printfLCS(len1,len2,x,b)函数中，根据数组b记录的数据依次选择性地输出X中的字符，即为最长公共子序列字符串；

三、直接上代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void Defind_Array(int **c,int **b,int len1,int len2);//声明：为数组变量初始化;
int LCSLength(int m,int n,char*x,char*y,int **c,int **b); //声明：将子序列长度记录在数组中;
void printfLCS( int i, int j,char *str, int **b);//声明：构造、输出子序列；
int main()
{
    int Xm,Yn;
    printf("请分别输入X、Y两个序列的长度m和n：");
    scanf("%d%d",&Xm,&Yn);
    char x[Xm],y[Yn];
    getchar();
    printf("输入:------------------------\n    序列X的值：");
    gets(x);
    printf("    序列Y的值：");
    gets(y);
    int len1 = strlen(x),len2 = strlen(y);
    if(Xm<len1 || Yn<len2)//超出长度约束时提醒并退出;
    {
        printf("你输入的字符长度超过了约束范围,程序退出！");
        return 0;
    }//申请二维数组
    int **c = (int **)malloc(sizeof(int*)*(len1 + 1));
    int **b = (int **)malloc(sizeof(int*)*(len1 + 1));
    Defind_Array(c,b,len1,len2);
    int sum = LCSLength(strlen(x),strlen(y),x, y, c, b);//计算LCS的长度
    printf("输出:------------------------");
    printf("\n    其子序列长度为: %d\n    最长公共子序列Z为:",sum);
    printfLCS(len1,len2,x,b);//利用数组b输出最长子序列;
    int i;//动态内存释放
    for ( i = 0; i <= len1; i++)
    {
        free(c[i]);
        free(b[i]);
    }
    free(c);
    free(b);
    return 0;
}
void Defind_Array(int **c,int **b,int len1,int len2)
{
    int i,j;
    for( i = 0; i<= len1; i++ )  //这个等号之前没加，导致内存泄漏
    {
        c[i] = (int *)malloc(sizeof(int)*(len2 + 1));
        b[i] = (int *)malloc(sizeof(int)*(len2 + 1));
    }
    for ( i = 0; i<= len1; i++)//将c[len1][len2]和b[len1][len2]初始化为0
    {
        for( j = 0; j <= len2; j++)
        {
            c[i][j] = 0;
            b[i][j] = 0;
        }
    }
}
int LCSLength(int m,int n,char *x,char *y,int **c,int **b)
{
    int i,j;
    for (i = 1; i <= m; i++) c[i][0] = 0;
    for (i = 1; i <= n; i++) c[0][i] = 0;
    for (i = 1; i <= m; i++)
        for (j = 1; j <= n; j++)
        {
            if (x[i-1]==y[j-1])
            {
                c[i][j]=c[i-1][j-1]+1;
                b[i][j]=1;
            }
            else if (c[i-1][j]>=c[i][j-1])
            {
                c[i][j]=c[i-1][j];
                b[i][j]=2;
            }
            else
            {
                c[i][j]=c[i][j-1];
                b[i][j]=3;
            }
        }
    return c[m][n];  //递归的最终位存储的数字就是LCS长度
}
void printfLCS( int i, int j,char *str, int **b)//构造最长公共子序列
{
    if( i == 0 || j == 0) return;    //递归至边界则扫描完毕
    if( b[i][j] == 1)
    {                     //对于相等的元素，其路径为左上方对角移动
        printfLCS( i - 1, j - 1,str, b);
        printf("%c ", str[i-1]);  //相等的话，原字符序列向前递归一位并打印出字符
    }
    else if ( b[i][j] == 2 )  //不相等时判断方向：向上则数组向上位移
        printfLCS(i - 1, j,str, b);
    else
        printfLCS(i , j - 1,str, b); //否则数组下标向左位移一位
}