[LOJ 6288]貓咪[CF 700E]Cool Slogans

[LOJ 6288]貓咪[CF 700E]Cool Slogans

題意

給定一個字符串 \(T\), 求一個最大的 \(K\) 使得存在 \(S_1,S_2,\dots,S_k\) 知足 \(S_1\) 是 \(T\) 的子串且 \(\forall 1\le i< k\) 有 \(S_{i+1}\) 是 \(S\) 的雙子串.

其中雙子串的定義是: 若 \(a\) 在 \(b\) 的至少兩個不一樣位置做爲子串出現則 \(a\) 爲 \(b\) 的雙子串. 出現位置能夠重疊.

\(|T|\le 2\times 10^5\).

題解

考試的時候被沙雕題目描述搞得迷迷糊糊的結果沒發現是原題←菜的真實

顯然對於每一個子串咱們能夠這個子串裏挑一個答案最大且的雙子串做爲這個子串的答案.

咱們發現當咱們挑出一個子串 \(S_1\) 後, 能夠經過對左右端點進行適當縮減來恰好卡到"每個雙子串都是上一個串的一個border"的程度. 由於若是出現了不是border的狀況, 能夠把前面全部的 \(S_i\) 全都縮短, 不難發現這樣並不會致使答案變劣.

那麼實際上要計算的就是每一個子串最多迭代幾個border. 考慮在SAM上DP. SAM的結點上只能控制右端點, 左端點是一個區間, 不難發現只要搞右端點相同就能夠了. 線段樹合併搞出每一個點的 right 集合, 判斷一下答案最大的祖先是否能對當前點作出貢獻就能夠了. 能作出貢獻就 \(+1\), 不然就不加.

至於判斷, 由於當前 right 集合對應的長度最大爲 len 的子串都是徹底同樣的, 因此隨便取一個位置判斷就能夠了.

參考代碼

#include <bits/stdc++.h>

const int MAXN=4e5+10;

struct Node{
    int l;
    int r;
    int cnt;
    Node* lch;
    Node* rch;
    Node(int,int);
    void Insert(int);
    int Query(int,int);
};
Node* N[MAXN];

int n;
int cnt=1;
int root=1;
int last=1;
int s[MAXN];
int prt[MAXN];
int len[MAXN];
int val[MAXN];
int pos[MAXN];
int tprt[MAXN];
char str[MAXN];
std::map<char,int> chd[MAXN];

int Extend(char);
Node* Merge(Node*,Node*);

int main(){
    scanf("%s",str+1);
    n=strlen(str+1);
    for(int i=1;i<=n;i++){
        int x=Extend(str[i]);
        N[x]->Insert(pos[x]=i);
    }
    for(int i=1;i<=cnt;i++)
        s[i]=i;
    std::stable_sort(s+1,s+cnt+1,[](int a,int b){return len[a]>len[b];});
    for(int i=1;i<cnt;i++){
        N[prt[s[i]]]=Merge(N[prt[s[i]]],N[s[i]]);
        pos[prt[s[i]]]=pos[s[i]];
    }
    int ans=0;
    for(int i=cnt-1;i>=1;i--){
        int p=s[i];
        if(prt[p]==root){
            val[p]=1;
            tprt[p]=p;
        }
        else{
            assert(N[p]->Query(pos[p],pos[p]));
            int last=tprt[prt[p]];
            int cnt=N[last]->Query(pos[p]-len[p]+(len[prt[last]]+1),pos[p]);
            if(cnt>=2){
                val[p]=val[last]+1;
                tprt[p]=p;
            }
            else{
                val[p]=val[last];
                tprt[p]=last;
            }
        }
        ans=std::max(ans,val[p]);
    }
    printf("%d\n",ans);
    return 0;
}

void Node::Insert(int x){
    ++this->cnt;
    if(this->l!=this->r){
        int mid=(this->l+this->r)>>1;
        if(x<=mid){
            if(this->lch==NULL)
                this->lch=new Node(this->l,mid);
            this->lch->Insert(x);
        }
        else{
            if(this->rch==NULL)
                this->rch=new Node(mid+1,this->r);
            this->rch->Insert(x);
        }
    }
}

int Extend(char x){
    int p=last;
    int np=++cnt;
    N[last=np]=new Node(1,n);
    len[np]=len[p]+1;
    while(p&&!chd[p].count(x))
        chd[p][x]=np,p=prt[p];
    if(!p)
        prt[np]=root;
    else{
        int q=chd[p][x];
        if(len[q]==len[p]+1)
            prt[np]=q;
        else{
            int nq=++cnt;
            N[nq]=new Node(1,n);
            len[nq]=len[p]+1;
            chd[nq]=chd[q];
            prt[nq]=prt[q];
            prt[q]=nq;
            prt[np]=nq;
            while(p&&chd[p][x]==q)
                chd[p][x]=nq,p=prt[p];
        }
    }
    return np;
}

Node* Merge(Node* a,Node* b){
    if(a==NULL)
        return b;
    if(b==NULL)
        return a;
    Node* cur=new Node(a->l,b->r);
    cur->cnt=a->cnt+b->cnt;
    cur->lch=Merge(a->lch,b->lch);
    cur->rch=Merge(a->rch,b->rch);
    return cur;
}

int Node::Query(int l,int r){
    if(l<=this->l&&this->r<=r)
        return this->cnt;
    else{
        int ans=0;
        if(this->lch&&l<=this->lch->r)
            ans+=this->lch->Query(l,r);
        if(this->rch&&this->rch->l<=r)
            ans+=this->rch->Query(l,r);
        return ans;
    }
}

Node::Node(int l,int r):l(l),r(r),cnt(0),lch(NULL),rch(NULL){}