动态规划之最长公共子序列问题

最长公共子序列

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 3

描述

咱们就不拐弯抹角了，如题，需要你做的就是写一个程序，得出最长公共子序列。
tip：最长公共子序列也称作最长公共子串(不要求连续)，英文缩写为LCS（Longest Common Subsequence）。其定义是，一个序列 S ，如果分别是两个或多个已知序列的子序列，且是所有符合此条件序列中最长的，则 S 称为已知序列的最长公共子序列。

输入

第一行给出一个整数N(0<N<100)表示待测数据组数
接下来每组数据两行，分别为待测的两组字符串。每个字符串长度不大于1000.

输出

每组测试数据输出一个整数，表示最长公共子序列长度。每组结果占一行。

样例输入

2
asdf
adfsd
123abc
abc123abc

样例输出

3
6

 慢慢分析最长公共子序列的特点 -所谓的最优解得结构【菜鸟该干的活】

经过拓展的思想分析，得到如下

假设c[i-1,j-1]是s1[1,..i-1]与s2[i,..j-1]的最长公共子序列，要求c[i,j]呢？？？

有下面两种情况【分的更细可能是三种】

1.s1[i]=s2[j]  c[i,j]=c[i-1,j-1]+1;

2.s2[i]!=s2[j] c[i,j]=max(c[i-1,j],c[i,j-1])

这就是最优解得结构，根据这个结构我们可以比较容易的自底向上的构造了-

下面是本人实现的java代码

public static void search(char []c1,char []c2)
	{
		int length1=c1.length;
		int length2=c2.length;
		int t[][]=new int[length1][];
		for(int i=0;i
   
   
    
    t[i][j-1])
					{
						t[i][j]=t[i-1][j];
					}
					else
					{
						t[i][j]=t[i][j-1];
					}
				}
			}
		}
		System.out.println(t[length1-1][length2-1]);
	}

   
   

Java代码总是不如C的简洁，给出一个C代码

 
#include 
    
    
     
     
#include 
     
     
      
      

#define MAX 1010
int dp[MAX][MAX] = {0};

void lcs(const char *x, int m, const char *y, int n)
{
	int i,j;
	for (i=0; i<=m; i++)
	{
		dp[i][0] = 0;
	}
	for (j=0;j<=n; j++)
	{
		dp[0][j] = 0;
	}
	for (i=1; i<=m; i++)
	{
		for (j=1; j<=n; j++)
		{
			if (x[i-1] == y[j-1])
			{
				dp[i][j] = dp[i-1][j-1] + 1;
			}
			else
			{
				dp[i][j] = dp[i-1][j] > dp[i][j-1]?dp[i-1][j] : dp[i][j-1];
			}
		}
	}
}

int main()
{
	int m;
	char x[MAX],y[MAX];
	scanf("%d",&m);
	while (m--)
	{
		int xlen,ylen;
		scanf("%s%s",x,y);
		xlen = strlen(x);
		ylen = strlen(y);
		lcs(x,xlen,y,ylen);
		printf("%d\n",dp[xlen][ylen]);
	}
	return 0;
}        
 
#include 
      
      
       
       
#include 
       
       
        
        

#define MAX 1001
short dp[2][MAX];

int main()
{
	int m;
	char x[MAX],y[MAX];
	scanf("%d",&m);
	while (m--)
	{
		int xlen,ylen;
		int i,j,e = 0;
		scanf("%s%s",x,y);
		xlen = strlen(x);
		ylen = strlen(y);
		memset(dp,0,sizeof(dp));
		for (i=1; i<=xlen;i++)
		{
			e = 1-e;
			for (j=1; j<=ylen; j++)
			{
				if (x[i-1] == y[j-1])
				{
					dp[e][j] = dp[1-e][j-1] + 1;
				}
				else
				{
					dp[e][j] = dp[e][j-1] > dp[1-e][j]?dp[e][j-1] : dp[1-e][j];
				}
			}
		}
		printf("%d\n",dp[e][ylen]);
	}
	return 0;
}        
       
       
      
      
     
     
    
    

很多时候求出一个最长的子序列的长度还不够，需要打印出来。。这个时候最容易想到的就是利用字符串拼接的思想了

比较水的一段Java代码，不要喷我啊

public static void search(char []c1,char []c2)
	{
		int length1=c1.length;
		int length2=c2.length;
		int t[][]=new int[length1][];
		StringBuffer str[][]=new StringBuffer[length1][];
		for(int i=0;i
    
    
     
     t[i][j-1])
					{
						t[i][j]=t[i-1][j];
						str[i][j]=str[i][j].append(str[i-1][j].toString());					
					}
					else
					{
						t[i][j]=t[i][j-1];
						str[i][j]=str[i][j].append(str[i][j-1].toString());
					}
				}
			}
		}
		System.out.println(t[length1-1][length2-1]);
		System.out.println(str[length1-1][length2-1]);
	}

    
    

上述的代码仅仅就是实现了用户的基本需求，空间和时间都没有考虑啊。。

看到网上朋友分享的一段代码，得到一点启示

引进一个二维数组c[][]，用c[i][j]记录X[i]与Y[j] 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。
我们是自底向上进行递推计算，那么在计算c[i,j]之前，c[i-1][j-1]，c[i-1][j]与c[i][j-1]均已计算出来。此时我们根据X[i] = Y[j]还是X[i] != Y[j]，就可以计算出c[i][j]

下面给出实现代码

#include 
   
   
    
    

#include 
    
    
     
     

#define MAXLEN 100

void LCSLength(char *x, char *y, int m, int n, int c[][MAXLEN], int b[][MAXLEN])

{

    int i, j;

    

    for(i = 0; i <= m; i++)

        c[i][0] = 0;

    for(j = 1; j <= n; j++)

        c[0][j] = 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] = 0;

            }

            else if(c[i-1][j] >= c[i][j-1])

            {

                c[i][j] = c[i-1][j];

                b[i][j] = 1;

            }

            else

            {

                c[i][j] = c[i][j-1];

                b[i][j] = -1;

            }

        }

    }

}

 

void PrintLCS(int b[][MAXLEN], char *x, int i, int j)

{

    if(i == 0 || j == 0)

        return;

    if(b[i][j] == 0)

    {

        PrintLCS(b, x, i-1, j-1);

        printf("%c ", x[i-1]);

    }

    else if(b[i][j] == 1)

        PrintLCS(b, x, i-1, j);

    else

        PrintLCS(b, x, i, j-1);

}

 

int main(int argc, char **argv)

{

    char x[MAXLEN] = {"ABCBDAB"};

    char y[MAXLEN] = {"BDCABA"};

    int b[MAXLEN][MAXLEN];

    int c[MAXLEN][MAXLEN];

    int m, n;

    m = strlen(x);

    n = strlen(y);

    LCSLength(x, y, m, n, c, b);

    PrintLCS(b, x, m, n);

    

    return 0;

}