BZOJ4180：字符串計數 （後綴自動機+二分答案+矩陣快速冪）

題目傳送門：http://www.lydsy.com/JudgeOnline/problem.php?id=4180

---

題目分析：別人眼中的好題，然而我覺得就是把SAM強套上另一個算法的題。

後綴自動機的特點使其能夠很好地解決本題，因爲它能夠識別原串的所有子串。如果從Root開始匹配模式串，而走到的當前狀態並不擁有模式串下一位的轉移，那麼原串便沒有這個子串。

接下來從靜態的問題開始考慮：假設已經給定了一個模式串，如何求出題目中最少的操作次數？做法是將模式串在SAM上貪心地向後匹配，出現空轉移時返回Root的對應兒子繼續匹配，並令操作數+1。爲什麼這樣最優呢？我們將模式串用XYZW表示，其中X，XY，ZW，YZW都是原串的子串。按照貪心的策略，應該從XY，ZW處斷開，變成兩個子串。而如果從X，YZW處斷開，最後一個子串就變長了。YZW存在的轉移ZW必然存在，而ZW卻有可能繼續向後匹配而YZW不能。所以貪心正確。

然後變爲動態的問題。假設當前節點P不存在c這個轉移，爲了方便我們將P轉移到根節點的c兒子，並令這條邊的代價爲1，代表操作數+1，其餘邊代價爲0。現在問題變成了：從Root出發，走N步，求最大的代價。

然而直接解決這個問題比較困難。我們發現這個新圖中權值爲0的邊很多，所以可以把一些無用的點刪掉，合併兩條邊，最後發現有用的點只有Root的A，B，C，D四個兒子。從A到C的邊長度爲新圖中從A向下走，走到某個擁有空轉移’C’的狀態的最短步數。然後這就濃縮成了一個4個點的完全圖。現在我們要走長度之和不超過N的邊，使得經過的邊數儘可能多。直接做依舊不好搞，可以二分答案mid，看走mid步經過的最小長度是多少。這可以用類似floyd的矩陣快速冪加速判斷。由於這題的時間主要來自SAM，所以時間爲O(|T|)$O(|T|)$ 。

其實如果這題字符集再大一些的話，二分+矩乘的時間複雜度就會比較高。然而如果字符集比較大的話，似乎會很難出數據。可能這就是T中只有A，B，C，D的原因吧。

我本來以爲這題能1A，結果我還是太naive了。一開始BFS的隊列沒有開|T|的兩倍，RE了一次（SAM節點數爲串長的2倍）；後來發現判斷mid的邊界沒有處理好；再後來我實在想不出有什麼問題，又檢查了一遍代碼，發現我的SAM居然建錯了？！總之4A，代碼還是寫得很快的。QAQ

---

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=100100;
const int maxc=4;
const long long oo=2e18;
typedef long long LL;

struct Tnode
{
    int val;
    bool vis;
    Tnode *parent,*son[maxc];
} tree[maxn<<1];
Tnode *Root,*last;
int cur=-1;

struct mat
{
    LL num[maxc][maxc];
} e;
int id;

Tnode *que[maxn<<1]; //!!!
int dep[maxn<<1]; //!!!
int tail;

char s[maxn];
int len;
LL n;

Tnode *New_node(int v)
{
    cur++;
    tree[cur].val=v;
    tree[cur].parent=NULL;
    for (int i=0; i<maxc; i++) tree[cur].son[i]=NULL;
    return tree+cur;
}

void Build()
{
    last=Root=New_node(0);
    for (int i=1; i<=len; i++)
    {
        int to=s[i-1]-'A';
        Tnode *NP=New_node(i),*P=last;
        last=NP;
        while ( P && !P->son[to] ) P->son[to]=NP,P=P->parent;
        if (!P)
        {
            NP->parent=Root;
            continue;
        }
        Tnode *Q=P->son[to];
        if (P->val+1==Q->val) NP->parent=Q;
        else
        {
            Tnode *NQ=New_node(P->val+1);
            for (int i=0; i<maxc; i++) NQ->son[i]=Q->son[i];
            NQ->parent=Q->parent;
            Q->parent=NP->parent=NQ;
            while ( P && P->son[to]==Q ) P->son[to]=NQ,P=P->parent; //!!!
        }
    }
}

void Bfs()
{
    tail=1;
    que[1]=Root->son[id];
    que[1]->vis=true;
    dep[1]=1;
    for (int i=1; i<=tail; i++)
    {
        Tnode *P=que[i];
        for (int j=0; j<maxc; j++)
            if ( P->son[j] && !P->son[j]->vis )
                P->son[j]->vis=true,que[++tail]=P->son[j],dep[tail]=dep[i]+1;
            else e.num[id][j]=min(e.num[id][j],(long long)dep[i]);
    }
}

mat Times(mat x,mat y)
{
    mat z;
    for (int i=0; i<maxc; i++)
        for (int j=0; j<maxc; j++) z.num[i][j]=oo;
    for (int i=0; i<maxc; i++)
        for (int j=0; j<maxc; j++)
            for (int k=0; k<maxc; k++)
                z.num[i][j]=min(z.num[i][j],x.num[i][k]+y.num[k][j]);
    return z;
}

mat Fast_power(LL x)
{
    if (x==1) return e;
    mat temp=Fast_power(x>>1);
    temp=Times(temp,temp);
    if (x&1) temp=Times(temp,e);
    return temp;
}

bool Judge(LL mid)
{
    //mid--;
    mat temp=Fast_power(mid);
    LL min_len=oo;
    for (int i=0; i<maxc; i++)
        for (int j=0; j<maxc; j++) min_len=min(min_len,temp.num[i][j]);
    return (min_len<n); //!!!
}

LL Binary()
{
    LL L=0,R=oo;
    while (L+1LL<R)
    {
        LL mid=(L+R)>>1;
        if ( Judge(mid) ) L=mid;
        else R=mid;
    }
    return L+1LL;
}

int main()
{
    freopen("4180.in","r",stdin);
    freopen("4180.out","w",stdout);

    scanf("%lld",&n);
    scanf("%s",s);
    len=strlen(s);

    Build();
    for (id=0; id<maxc; id++)
    {
        for (int i=0; i<=cur; i++) tree[i].vis=false;
        for (int i=0; i<maxc; i++) e.num[id][i]=oo;
        Bfs();
    }

    LL ans=Binary();
    printf("%lld\n",ans);

    return 0;
}