POI2010 Hamsters

Hamsters

Tz养了一群仓鼠，他们都有英文小写的名字，现在Tz想用一个字母序列来表示他们的名字，只要他们的名字是字母序列中的一个子串就算，出现多次可以重复计算。现在Tz想好了要出现多少个名字，请你求出最短的字母序列的长度是多少。

输入

输入：第一行n（1<=n<=200）和m(1<=m<=10^9)，n表示有多少个仓鼠，m表示Tz希望出现名字的次数，接下来n行，每行都是仓鼠的名字（中间没有空格）。

名字总长度不超过10^5;

名字不会相互包含。

输出

输出：一行，最短的字母序列的长度。

首先肯定是要把一个名字接在后一个名字所需要增加的长度预处理出来,但是有些人担心这样就超时了-_-

(要是真超时了还有什么好写的……)

这部分的代码是这样:
(函数里的复杂度都是$O(1)$)

for (int i=1;i<=n;++i) {
        for (int j=1;j<=n;++j) {
            bool chk=false;
            int lA=strlen(nam[i]+1);
            int lB=strlen(nam[j]+1);
            int mi=min(lA,lB);
            for (int k=mi-1;k>=1;--k) {
                int hA=calc(i,lA-k+1,lA),hB=Hash[j][k];
                if (hA==hB) {
                    A.d[i][j]=lB-k;
                    chk=true;
                    break;
                }
            }
            if (!chk) A.d[i][j]=lB;
        }
    }

对于每两个名字(A和B),需要的最高复杂度位$O(lA)$
A要和 $n$ 个B比较,所以复杂度为 $O(lA*n)$
我们有 $n$ 个A,所以总复杂度为 $O(lA*n^2)$

但是 $lA*n$ 最大为 $10^5$
所以$lA*n^2$只有 $10^7$,不会超时.

然后,我就想用 $djistra$ 做,让一个点走 $m$ 次就好了.

结果发现 1<=m<=10^9 ,所以没办法了.

后来知道可以 倍增$Floyd$ ,写起来就跟快速幂一样,所以用 $n^3logm$ 解决了它.

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
#define chk(x,y) if(x>y)x=y
const int M=205;
const int P=1e9+7;
const int B=233;
const long long INF=1LL<<61;

int n,m;
struct Floyd {
    long long d[M][M];
    Floyd() {
        for (int i=0;i<M;++i) {
            for (int j=0;j<M;++j) d[i][j]=INF;
        }
    }
};
Floyd operator * (const Floyd &A,const Floyd &B) {
    Floyd res;
    for (int k=0;k<=n;++k) {
        for (int i=0;i<=n;++i) {
            for (int j=0;j<=n;++j) {
                chk(res.d[i][j],A.d[i][k]+B.d[k][j]);
            }
        }
    }
    return res;
}

char nam[M][100005];
int Hash[M][100005],Base[100005];

void Init() {
    Base[0]=1;
    for (int i=1;i<100005;++i) Base[i]=1LL*Base[i-1]*B%P;
    for (int i=1;i<=n;++i) {
        int len=strlen(nam[i]+1);
        for (int j=1;j<=len;++j) Hash[i][j]=(1LL*Hash[i][j-1]*B+nam[i][j])%P;
    }
}

int calc(int x,int st,int ed) {
    return ((Hash[x][ed]-1LL*Hash[x][st-1]*Base[ed-st+1]%P)%P+P)%P;
}

int main() {
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;++i) scanf("%s",nam[i]+1);
    Init();
    Floyd A,res;
    for (int i=1;i<=n;++i) {
        for (int j=1;j<=n;++j) {
            bool chk=false;
            int lA=strlen(nam[i]+1);
            int lB=strlen(nam[j]+1);
            int mi=min(lA,lB);
            for (int k=mi-1;k>=1;--k) {
                int hA=calc(i,lA-k+1,lA),hB=Hash[j][k];
                if (hA==hB) {
                    A.d[i][j]=lB-k;
                    chk=true;
                    break;
                }
            }
            if (!chk) A.d[i][j]=lB;
        }
    }

    res.d[0][0]=0;
    for (int i=1;i<=n;++i) {
        res.d[i][i]=0;
        A.d[0][i]=strlen(nam[i]+1);
    }

    while (m) {
        if (m&1) res=res*A;
        m>>=1,A=A*A;
    }
    long long ans=INF;
    for (int i=1;i<=n;++i) chk(ans,res.d[0][i]);
    cout<<ans<<endl;
    return 0;
}

这样的代码在POI好像过不掉(内存会炸)
要用vector和string
但是用了这些奇怪东西后就要发挥各种卡常数本领才能过了