【啊哈，算法】之十、后缀数组，求最长重复子串

转自：http://blog.csdn.net/hackbuteer1/article/details/7968623

直观的解法是，首先检测长度为 n - 1 的字符串情况，如果不存在重复则检测 n - 2, 一直递减下去，直到 1 。

这种方法的时间复杂度是 O(N * N * N)，其中包括三部分，长度纬度、根据长度检测的字符串数目、字符串检测。

利用后缀数组
后缀数组是一种数据结构，对一个字符串生成相应的后缀数组后，然后再排序，排完序依次检测相邻的两个字符串的开头公共部分。
这样的时间复杂度为：生成后缀数组 O(N)，排序 O(NlogN*N) 最后面的 N 是因为字符串比较也是 O(N)
依次检测相邻的两个字符串 O(N * N)，总的时间复杂度是 O(N^2*logN)，优于第一种方法的 O(N^3)

demo如下：

其中：当作为comlen函数参数的两个字符串长度相等时，该函数便返回这个长度值，从第一个字符开始

int comlen( char *p, char *q )  
{  
    int i = 0;  
    while( *p && (*p++ == *q++) )  
        ++i;  
    return i;  
}  

int main(void)  
{  
    int i , j , thislen , maxlen = -1;  
    ......  
    ......  
    ......  
    for(i = 0 ; i < n ; ++i )  
    {  
        for(j = i+1 ; j < n ; ++j )  
        {  
            if((thislen = comlen(&c[i] , &c[j])) > maxlen)  
            {  
                maxlen = thislen;  
                maxi = i;  
                maxj = j;  
            }  
        }  
    }  
    ......  
    ......  
    ......  
    return 0;  
}  

完整代码如下：

#include <iostream>  
using namespace std;  
  
#define MAXCHAR 5000 //最长处理5000个字符  
  
char c[MAXCHAR], *a[MAXCHAR];  
  
int comlen( char *p, char *q )  
{  
    int i = 0;  
    while( *p && (*p++ == *q++) )  
        ++i;  
    return i;  
}  
  
int pstrcmp( const void *p1, const void *p2 )  
{  
    return strcmp( *(char* const *)p1, *(char* const*)p2 );  
}  
  
  
int main(void)  
{  
    char ch;  
    int  n=0;  
    int  i, temp;  
    int  maxlen=0, maxi=0;  
    printf("Please input your string:\n");  
  
    n = 0;  
    while( (ch=getchar())!='\n' )  
    {  
        a[n] = &c[n];  
        c[n++] = ch;  
    }  
    c[n]='\0';     // 将数组c中的最后一个元素设为空字符，以终止所有字符串  
  
    qsort( a, n, sizeof(char*), pstrcmp );  
    for(i = 0 ; i < n-1 ; ++i )  
    {  
        temp=comlen( a[i], a[i+1] );  
        if( temp>maxlen )  
        {  
            maxlen=temp;  
            maxi=i;  
        }  
    }  
    printf("%.*s\n",maxlen, a[maxi]);  
      
    return 0;  
}  

元素a[0]指向整个字符串，下一个元素指向以第二个字符开始的数组的后缀，等等。如若输入字符串为"banana",该数组将表示这些后缀：
a[0]:banana
a[1]:anana
a[2]:nana
a[3]:ana
a[4]:na
a[5]:a
由于数组a中的指针分别指向字符串中的每个后缀，所以将数组a命名为"后缀数组"

对后缀数组进行快速排序，以将后缀相近的（变位词）子串集中在一起
qsort(a, n, sizeof(char*), pstrcmp)后
a[0]:a
a[1]:ana
a[2]:anana
a[3]:banana
a[4]:na
a[5]:nana

用comlen函数对数组进行扫描比较邻接元素，以找出最长重复的字符串。

第二种方法是通过kmp算法，next数组的方式：

#include<iostream>  
using namespace std;  
  
const int MAX = 100000;  
int next[MAX];  
char str[MAX];  
  
void GetNext(char *t)  
{  
    int len = strlen(t);  
    next[0] = -1;  
    int i = 0 , j = -1;  
    while(i < len)  
    {  
        if(j == -1 || t[i] == t[j])  
        {  
            i++;  
            j++;  
            if(t[i] != t[j])  
                next[i] = j;  
            else  
                next[i] = next[j];  
        }  
        else  
            j = next[j];  
    }  
}  
int main(void)  
{  
    int i , j , index , len;  
    cout<<"Please input your string:"<<endl;  
  
    cin>>str;  
    char *s = str;  
    len = 0;  
    for(i = 0 ; *s != '\0' ; s++ , ++i)  
    {  
        GetNext(s);  
        for(j = 1 ; j <= strlen(s) ; ++j)  
        {  
            if(next[j] > len)  
            {  
                len = next[j];  
                index = i + j;    //index是第一个最长重复串在str中的位置   
            }  
        }  
    }  
    if(len > 0)  
    {  
        for(i = index - len ; i < index ; ++i)  
            cout<<str[i];  
        cout<<endl;  
    }  
    else  
        cout<<"none"<<endl;  
  
    return 0;  
}  

题目描述：求最长不重复子串，如abcdefgegcsgcasse，最长不重复子串为abcdefg，长度为7

#include <iostream>
#include <list>
using namespace std;

//思路：用一个数组保存字符出现的次数。用i和j进行遍历整个字符串。
//当某个字符没有出现过，次数+1；出现字符已经出现过，次数+1，找到这个字符前面出现的位置的下一个位置，设为i
//并将之前的那些字符次数都-1。继续遍历，直到'\0'
int find(char str[],char *output)
{
	int i = 0 , j = 0;
	int cnt[26] = {0};
	int res = 0 , temp = 0;
	char *out = output;
	int final;
	while(str[j] != '\0')
	{
		if(cnt[str[j]-'a'] == 0)
		{
			cnt[str[j]-'a']++;

		}
		else
		{
			cnt[str[j]-'a']++;
			while(str[i] != str[j])
			{	
				cnt[str[i]-'a']--;
				i++;
			}
			cnt[str[i]-'a']--;
			i++;
		}	

		j++;
		temp = j-i;
		if(temp > res)
		{
			res = temp;
			final = i;
		}
	}
	//结果保存在output里面
	for(i = 0 ; i < res ; ++i)
		*out++ = str[final++];
	*out = '\0';
	return res;
}
int main(void)
{
	char a[] = "abcdefg";
	char b[100];
	int max = find(a,b);
	cout<<b<<endl;
	cout<<max<<endl;
	return 0;
}