求最长公共子串

参考：http://www.cnblogs.com/zhangchaoyang/articles/2012070.html

http://www.cnblogs.com/dartagnan/archive/2011/10/06/2199764.html

http://www.cnblogs.com/zhangchaoyang/articles/2012070.html

最长公共子串（Longest Common Substirng）和最长公共子序列（Longest Common Subsequence，LCS）的区别为：子串是串的一个连续的部分，子序列则是从不改变序列的顺序，而从序列中去掉任意的元素而获得新的序列；也就是说，子串中字符的位置必须是连续的，子序列则可以不必连续。

方法·1：简单的动态规划

  关键代码：if（s1[i+len] == s2[j])

//求解最长连续子串
//求两字符串的最长公共子串
//暴力搜索
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char * maxsamesubstring(char *s1,char *s2)
{
    int i,j,len,maxlen,index,maxindex;
    
    maxlen=0;     //初始化最长公共子串的长度
    maxindex=0;   //初始化最长公共子串的位置

    len=0;        //当前公共子串的长度
    

    for(i=0;s1[i]!='\0';i++)
        for(j=0;s2[j]!='\0';j++)
		{
            if(s1[i+len]==s2[j])//这里是关键代码s1[i+len]==s2[j]，以s[i]开始的子串最长能到多少
            {
                if(!len)//len=0 的时候执行（第一次执行）
                {
                    index=j;   //index记下公共子串的起始位置
                }
                len++;//只要满足if(s1[i+len]==s2[j])则不断增加对长度的计数
            }
            else if(len)
            {
                if(maxlen<len)    //经过一次扫描找到了最长公共子串，跟新maxlen
                {
                    maxlen=len;
                    maxindex=index;//记录下最长公共子串的起始位置
                }
                len=0;           //进行下一次的扫描，注意index记录的是公共子串的起始位置
				j=index;//必须有这一个，否则会跳过了之前已经进行过的匹配字符，就有可能漏掉，不是最大匹配
				        //加上j=index就会从上一次匹配子串起始位置的下一个字符开始重新进行匹配
				//下一次for(j=0;s2[j]!='\0';j++)先index+1然后开始下面计算
            }
		}

    char *p=new char[maxlen+1];
    strncpy(p,s2+maxindex,maxlen);  //把最长公共字符串复制到p所指的空间
    p[maxlen]='\0';               //置串结束标志

    return p;

}

int main()
{
    char *s1="12",*s2="112",*sub;  

    sub=maxsamesubstring(s1,s2);

    printf("%s\n",sub);

    return 0;

}

方法2 动态规划法

1.公共子串的元素必须相邻:

    LCS问题就是求两个字符串最长公共子串的问题。解法就是用一个矩阵来记录两个字符串中所有位置的两个字符之间的匹配情况，若是匹配则为1，否则为0。然后求出对角线最长的1序列，其对应的位置就是最长匹配子串的位置.

下面是字符串21232523311324和字符串312123223445的匹配矩阵，前者为X方向的，后者为Y方向的。不难找到，红色部分是最长的匹配子串。通过查找位置我们得到最长的匹配子串为：21232

   0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
   0 1 0 0 0 0 0 0 0 1 1 0 0 0 0
   1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
   0 1 0 0 0 0 0 0 0 1 1 0 0 0 0
   1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
   0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
   1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
   1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
   0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
   0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

但是在0和1的矩阵中找最长的1对角线序列又要花去一定的时间。通过改进矩阵的生成方式和设置标记变量，可以省去这部分时间。下面是新的矩阵生成方式：

   0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
   0 1 0 0 0 0 0 0 0 2 1 0 0 0 0
   1 0 2 0 1 0 1 0 0 0 0 0 1 0 0
   0 2 0 0 0 0 0 0 0 1 1 0 0 0 0
   1 0 3 0 1 0 1 0 0 0 0 0 1 0 0
   0 0 0 4 0 0 0 2 1 0 0 1 0 0 0
   1 0 1 0 5 0 1 0 0 0 0 0 2 0 0
   1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
   0 0 0 2 0 0 0 2 1 0 0 1 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
   0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   

          当字符匹配的时候，我们并不是简单的给相应元素赋上1，而是赋上其左上角元素的值加一。我们用两个标记变量来标记矩阵中值最大的元素的位置，在矩阵生成的过程中来判断当前生成的元素的值是不是最大的，据此来改变标记变量的值，那么到矩阵完成的时候，最长匹配子串的位置和长度就已经出来了。

算法的基本思想：

当字符匹配的时候，不是简单的给相应元素赋上1，而是赋上其左上角元素的值加一。

我们用两个标记变量来标记矩阵中值最大的元素的位置，在矩阵生成的过程中来判断

当前生成的元素的值是不是最大的，据此来改变标记变量的值，那么到矩阵完成的时

候，最长匹配子串的位置和长度就已经出来了。

#include<iostream>
using namespace std;
int lcsstr(string x,string y)
{
	int xlen=x.length();
	int ylen=y.length();
	if(xlen==0||ylen==0)//输入检测
		return -1;
	int **c=new int*[xlen+1];//创建动态的二维数组
	for(int i=0;i<xlen+1;i++)//创建动态的二维数组
		c[i]=new int[ylen+1];
	for(int j=0;j<xlen+1;j++)
		for(int k=0;k<ylen+1;k++)
			c[j][k]=0;
	int index=0;
	int maxlen=0;
	for(int i=1;i<=xlen;i++)
		for(int j=1;j<=ylen;j++)
		{
			if(x[i-1]==y[j-1])
				c[i][j]=c[i-1][j-1]+1;
			else
				c[i][j]=0;
			if(c[i][j]>maxlen)
			{
				maxlen=c[i][j];
				index=i;//记录下达到最大长度时的行数
			}
		}                            
		for(int i=0;i<maxlen;i++)//注意上面为了避免讨论边界情况，在外面扩充一行0和一列0，之后才是x，y的值
		{                        //所以这里在定位位置的时候，对于index要先减去1才是开始的位置
			cout<<x[index-1-maxlen+1+i];
		}
		cout<<endl;
		return maxlen;
}
int main()
{
	string x="21232523311324";
	string y="312123223445";
	int count=lcsstr(x,y);
	cout<<count<<endl;
	return 0;
}

改进的一种方法，其实可以只用一个一维数组就可以标识，但是在用一维数组进行标识的时候一定要注意：

串2从后向前比较。

//最长公共子串
//之前构造一个二维矩阵来标记相同的字符，由于得出矩阵的某一行后其上一行就没用了，所以实际上可以用一维数组来代替这个矩阵。
//如果是用一维矩阵则串2从后向前比较,为什么要从后向前呢?是把一维数组c[ ]当二维数组来用,
//如果要从前向后,可以将c申明为一个二维数组c[M][M].
#include<iostream>
using namespace std;
int lcsstr(string x,string y)
{
	int xlen=x.length();
	int ylen=y.length();
	if(xlen==0||ylen==0)//输入检测
		return -1;
	int *c=new int[ylen];
	for(int k=0;k<ylen;k++)
		c[k]=0;
	int index=0;
	int maxlen=0;
	for(int i=0;i<xlen;i++)
		for(int j=ylen-1;j>=0;j--)
		{
			if(x[i]==y[j])
			{
				if(i==0||j==0)
					c[j]=1;
				else
					c[j]=c[j-1]+1;
			}
			else
				c[j]=0;
			if(c[j]>maxlen)
			{
				maxlen=c[j];
				index=j;//记录下达到最大长度时的列数
			}
		}                            
		for(int k=0;k<maxlen;k++)//注意上面为了避免讨论边界情况，在外面扩充一行0和一列0，之后才是x，y的值
		{                        //所以这里在定位位置的时候，对于index要先减去1才是开始的位置
			cout<<y[index-maxlen+1+k];
		}
		cout<<endl;
		return maxlen;
}
int main()
{
	string x="21232523311324";
	string y="312123223445";
	int count=lcsstr(x,y);
	cout<<count<<endl;
	return 0;
}