Maximum repetition substring 【POJ - 3693】【后缀数组求重复次数最多的连续子串】

题目链接

---

  题目中给出一个串，问的是它的重复次数最多的连续子串，并且输出，如果有多个可能，输出字典序最小的。

  然后去大致的浏览了一下一些关于论文中重复次数最多的连续子串的介绍，发现可以枚举连续子串的单个子串的长度来解决这个问题，我们从1～N的枚举长度L，然后每次查询的是，所以这里的时间复杂度是的（调和级数），然后就是如何判断的问题了。

  我们枚举每一个长度，如果说有个序列包含在字符串中的位置以及，那么它至少也就是连续出现了两次，所以我们可以利用这层关系来解决这个问题。

  我们定义X是一个子串（位置在i），然后证明一下，如果有一个子串Y在位置（i+len(X)）上，则我们可以发现，如果他们相等，他们之后的元素会以X的长度周期变换，于是就可以解决连续重复次数最多的问题了：

  他们之间的关系可以这样的连续确定，并且有X到Y之间的长度是X串的长度，而当X==Y的时候，我们就可以证明后面出现的串是逐个且连续的。

  于是，我们就可以解决了重复次数最多的连续子串的次数的问题了，但是我们还未解决是哪个子串这样的问题。

  接下去，我们要知道的是字典序最小的满足条件的子串，于是我们可以利用sa[ ]来找，但是我们现在不能确定它的对应的长度，所以，我们在之前枚举L的时候，我们也可以在更新答案的同时，将次数相等的且是不同的L给记录下来。现在，我们可以通过我们记录下来的L来继续枚举哪个sa[ ]是正确的。

  这里需要特判一下，就是只有一个字符的时候，我这样的解法是没有答案的。所以是要特别输出的。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
//#include <unordered_map>
//#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 7;
struct SA
{
    int n, m;
    int s[maxN];
    int y[maxN], x[maxN], c[maxN], sa[maxN], rk[maxN], height[maxN];
    inline void get_SA()
    {
        for(int i=1; i<=m; i++) c[i] = 0;   //桶的初始化
        for(int i=1; i<=n; i++) ++c[x[i] = s[i]];
        for(int i=2; i<=m; i++) c[i] += c[i - 1];   //利用差分前缀和的思想知道每个关键字最多是在第几名
        for(int i=n; i>=1; i--) sa[c[x[i]]--] = i;
        for(int k=1; k<=n; k<<=1)
        {
            int num = 0;
            for(int i=n - k + 1; i<=n; i++) y[++num] = i;
            for(int i=1; i<=n; i++) if(sa[i] > k) y[++num] = sa[i] - k; //是否可以作为第二关键字
            for(int i=1; i<=m; i++) c[i] = 0;
            for(int i=1; i<=n; i++) c[x[i]]++;  //因为上一次循环已经求出这次的第一关键字了
            for(int i=2; i<=m; i++) c[i] += c[i - 1];
            for(int i=n; i>=1; i--) //在同一第一关键字下，按第二关键字来排
            {
                sa[c[x[y[i]]]--] = y[i];
                y[i] = 0;
            }
            swap(x, y);
            x[sa[1]] = 1; num = 1;
            for(int i=2; i<=n; i++)
            {
                x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k]) ? num : ++num;
            }
            if(num == n) break;
            m = num;
        }
    }
    inline void get_height()
    {
        int k = 0;
        for(int i=1; i<=n; i++) rk[sa[i]] = i;
        for(int i=1; i<=n; i++)
        {
            if(rk[i] == 1) continue;    //第一名的height为0
            if(k) k--;  //height[i] >= height[i - 1] - 1
            int j = sa[rk[i] - 1];
            while(j + k <= n && i + k <= n && s[i + k] == s[j + k]) k++;
            height[rk[i]] = k;
        }
    }
    inline void clear()
    {
        n = 0; m = 200;
    }
} sa;
struct BIT_Tree
{
    int tree[maxN << 2];
    inline void buildTree(int rt, int l, int r)
    {
        if(l == r) { tree[rt] = sa.height[l]; return; }
        int mid = HalF;
        buildTree(Lson); buildTree(Rson);
        tree[rt] = min(tree[lsn], tree[rsn]);
    }
    inline int query(int rt, int l, int r, int ql, int qr)
    {
        if(ql <= l && qr >= r) return tree[rt];
        int mid = HalF;
        if(qr <= mid) return query(QL);
        else if(ql > mid) return query(QR);
        else return min(query(QL), query(QR));
    }
} bt;
int N, que[maxN], top;
char s[maxN];
inline int sure_tims()
{
    int ans_tim = 0;
    for(int i=1, l, r, k_len, tmp_len; i<=N; i++)
    {
        for(int j=0; i * (j + 1) + 1 <= N; j++)
        {
            l = sa.rk[i * j + 1]; r = sa.rk[i * (j + 1) + 1];
            if(l > r) swap(l, r);
            k_len = bt.query(1, 1, N, l + 1, r);
            if(k_len % i == 0)
            {
                if(ans_tim < k_len / i + 1)
                {
                    ans_tim = k_len / i + 1;
                    top = 0; que[++top] = i;
                }
                else if(ans_tim == k_len / i + 1)
                {
                    if(que[top] ^ i) que[++top] = i;
                }
            }
            else    //可能还有更多的匹配
            {
                if(ans_tim < k_len / i + 1) //首先是直接匹配，再看看能不能再加点
                {
                    ans_tim = k_len / i + 1;
                    top = 0; que[++top] = i;
                }
                else if(ans_tim == k_len / i + 1)
                {
                    if(que[top] ^ i) que[++top] = i;
                }
                tmp_len = k_len % i;
                tmp_len = i - tmp_len;
                if(i * j + 1 - tmp_len < 1) continue;
                l = sa.rk[i * j + 1 - tmp_len]; r = sa.rk[i * (j + 1) + 1 - tmp_len];
                if(l > r) swap(l, r);
                k_len = bt.query(1, 1, N, l + 1, r);
                if(k_len >= i)
                {
                    if(ans_tim < k_len / i + 1)
                    {
                        ans_tim = k_len / i + 1;
                        top = 0; que[++top] = i;
                    }
                    else if(ans_tim == k_len / i + 1)
                    {
                        if(que[top] ^ i) que[++top] = i;
                    }
                }
            }
        }
    }
    return ans_tim;
}
int main()
{
    int Cas = 0;
    while(scanf("%s", s + 1) && (s[1] ^ '#'))
    {
        sa.clear(); top = 0;
        N = (int)strlen(s + 1);
        for(int i=1; i<=N; i++)
        {
            sa.s[++sa.n] = s[i];
        }
        sa.s[++sa.n] = 'a' + 26;
        sa.get_SA();
        sa.get_height();
        bt.buildTree(1, 1, N);
        int ans_len = 0, ans_beg = 1;
        int ans_tim = sure_tims();  //确定连续重复次数最多的次数
        if(!ans_tim)
        {
            int id = sa.sa[1];
            printf("Case %d: %c\n", ++Cas, sa.s[id]);
            continue;
        }
        for(int i=1, flag = 1, id, l, r, tmp_len; i<=N && flag; i++)
        {
            for(int j=1; j<=top; j++)
            {
                id = sa.sa[i];
                l = i;
                if(id + que[j] > N) continue;
                r = sa.rk[id + que[j]];
                if(l > r) swap(l, r);
                tmp_len = bt.query(1, 1, N, l + 1, r);
                if(tmp_len >= (ans_tim - 1) * que[j])
                {
                    ans_beg = sa.sa[i]; ans_len = que[j] * ans_tim;
                    flag = 0;
                    break;
                }
            }
        }
        printf("Case %d: ", ++Cas);
        for(int i=ans_beg; i < ans_beg + ans_len; i++) printf("%c", s[i]); puts("");
    }
    return 0;
}
/*dababab*/
/*
dabab
dababab
dabababab
dababab
*/
/*baccdbaccdbacbdbacb*/