后缀数组，字符串中连续出现最多的字串

来源：互联网发布：网络调教女m的任务详细编辑：程序博客网时间：2024/05/16 01:53
【啊哈，算法】之九、后缀数组，字符串中连续出现最多的字串

分类： Algorithm2013-09-21 17:08 110人阅读评论(0) 收藏举报
转载自：http://blog.csdn.net/ysu108/article/details/7795479
字符串“abababc”,最多连续出现的为ab，连续出现三次。要和求一个字符串中的最长重复子串区分开来，还是上面的字符串，那么最长的重复子串为abab。两个题目的解法有些类似，都用到了后缀数组这个数据结构。求一个字符串中连续出现的次数最多的子串，首先生成后缀数组例如上面的字符串为:
abababc
bababc
ababc
babc
abc
bc
c
可以看出第一个后缀数组和第三个后缀数组的起始都为ab，第5个后缀数组也为ab。可以看出规律来，一个字符串s，如果第一次出现在后缀数组i的前面，那么如果它重复出现，下一次出现应该在第i+len(s)个后缀数组的前面。这个规律也不难看出。那么从头到尾按照这个规律搜索下不难得出结果。下面是代码：
[cpp] view plaincopy
#include <iostream>    
using namespace std;    
    
int con_sub(char *str, char **ret);    
    
int main()    
{    
        char str[] = "abcabcabcabcabcabbbb";    
        char *ret = NULL;    
        int time = con_sub(str, &ret);    
        printf("%s occuers %d times\n", ret, time);    
        return 0;    
}    
    
int con_sub(char *str, char **ret)    
{    
        int max_time = 0;//连续出现的最多次数    
        int ret_len = 0;//连续出现的字符串的长度    
        char *addr = NULL;//连续出现字符串的起始地址    
    
        int len = strlen(str);    
        char **a = (char **)malloc(sizeof(char *)*len);    
        //生成后缀数组    
        for(int i=0; i<len; i++)    
                a[i] = &str[i];    
    
        //重复字符串的长度范围为1到(len+1)/2    
        for(int i=1; i<=(len+1)/2; i++)    
        {    
                //当重复的字符串长度为i的时候，如果是连续出现的，那么第j和第j+i个后缀数组前面为重复的字符串    
                for(int j=0; j+i<=len-1; j+=i)    
                {    
                        int k = j;    
                        int temp_time = 1;    
                        while(k+i <= len-1 && strncmp(a[k], a[k+i], i) == 0)    
                        {    
                                temp_time++;    
                                k += i;    
                        }    
                        if(temp_time > max_time)    
                        {    
                                max_time = temp_time;    
                                ret_len = i;    
                                addr = a[k];    
                        }    
                }    
        }    
        *ret = new char[len+1];    
        strncpy(*ret, addr, ret_len);    
        return max_time;    
}    
 【啊哈，算法】之十、后缀数组，求最长重复子串
分类： Algorithm2013-09-21 18:14 105人阅读 评论(0) 收藏 举报
转自：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函数参数的两个字符串长度相等时，该函数便返回这个长度值，从第一个字符开始
[cpp] view plaincopy
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;    
}    

完整代码如下：
[cpp] view plaincopy
#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数组的方式：
[cpp] view plaincopy
#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
[cpp] view plaincopy
#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;  
}  