【BZOJ 4180】 4180: 字符串计数 （SAM+二分+矩阵乘法）

4180: 字符串计数

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 164  Solved: 75

Description

SD有一名神犇叫做Oxer，他觉得字符串的题目都太水了，于是便出了一道题来虐蒟蒻yts1999。

他给出了一个字符串T，字符串T中有且仅有4种字符 'A', 'B', 'C', 'D'。现在他要求蒟蒻yts1999构造一个新的字符串S，构造的方法是：进行多次操作，每一次操作选择T的一个子串，将其加入S的末尾。

对于一个可构造出的字符串S，可能有多种构造方案，Oxer定义构造字符串S所需的操作次数为所有构造方案中操作次数的最小值。

Oxer想知道对于给定的正整数N和字符串T，他所能构造出的所有长度为N的字符串S中，构造所需的操作次数最大的字符串的操作次数。

蒟蒻yts1999当然不会做了，于是向你求助。

Input

第一行包含一个整数N，表示要构造的字符串长度。

第二行包含一个字符串T，T的意义如题所述。

Output

输出文件包含一行，一个整数，为你所求出的最大的操作次数。

Sample Input

5
ABCCAD

Sample Output

5

HINT

【样例说明】

例如字符串"AAAAA"，该字符串所需操作次数为5，不存在能用T的子串构造出的，且所需操作次数比5大的字符串。

【数据规模和约定】

对于100%的数据，1 ≤ N ≤ 10^18，1 ≤ |T| ≤ 10^5。

Source

By yts1999

【分析】

　　好题啊。我没想到。。

　　要用一种稍微转化一下的思维？

　　要算n最多操作次数，可以二分答案，然后询问操作次数为x的区间最小长度是多少。【我个人觉得这样想也不简单啊。

　　考虑如果S确定的话，其实是贪心的，匹配到不能匹配的时候断掉，成为新的一段。

　　在SAM上就是没有儿子的后继之后，就跳回根。

　　所以其实（10^18的时候你应该看出来要矩乘了），矩阵中不需要存SAM的每个点，也不能存，只要存现在是什么颜色就好了。

　　保证断掉的话，就是f[i][j]表示第i为开头的子串最短多少后面接j就会断。

　　这个很好求，先做SAM，求出mn[x][i]表示x这个点后面接最短多少的子串再接j之后就会断。

　　mn[x][i]=min(mn[son][i]+1)。

　　f[i][j]=mn[1的i儿子][j]。

　　然后x次操作就是f[i][j]^x，矩阵“乘法”的运算实际上是求和取min。

　　【看代码吧！

 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 using namespace std;
 #define Maxn 100010
 #define LL long long
 #define INF 0xfffffff
 #define inf 1LL<<60

 LL n;
 int mymin(int x,int y) {return x<y?x:y;}

 struct node
 {
     int pre,son[],step;
 }t[Maxn*];
 bool vis[*Maxn];

 int mn[*Maxn][];

 struct sam
 {
     int last,tot;
     void extend(int k)
     {
         int np=++tot,p=last;
         t[np].step=t[p].step+;
         while(p&&!t[p].son[k])
         {
             t[p].son[k]=np;
             p=t[p].pre;
         }
         if(!p) t[np].pre=;
         else
         {
             int q=t[p].son[k];
             if(t[q].step==t[p].step+) t[np].pre=q;
             else
             {
                 int nq=++tot;
                 memcpy(t[nq].son,t[q].son,sizeof(t[nq].son));
                 t[nq].step=t[p].step+;
                 t[nq].pre=t[q].pre;
                 t[q].pre=t[np].pre=nq;
                 while(p&&t[p].son[k]==q)
                 {
                     t[p].son[k]=nq;
                     p=t[p].pre;
                 }
             }
         }
         last=np;
     }
     void dfs(int x)
     {
         if(vis[x]) return;
         vis[x]=;
         for(int i=;i<=;i++) mn[x][i]=INF;
         for(int i=;i<=;i++)
         {
             if(!t[x].son[i]) mn[x][i]=;
             else
             {
                 dfs(t[x].son[i]);
                 for(int j=;j<=;j++) mn[x][j]=mymin(mn[x][j],mn[t[x].son[i]][j]+);
             }
         }
     }
 }sam;

 char s[Maxn];

 struct Matrix
 {
     LL w[][];
     Matrix() {memset(w,,sizeof(w));}
     inline friend Matrix operator * (const Matrix A,const Matrix B)
     {
         Matrix ret;
         for(int i=;i<=;i++)
          for(int j=;j<=;j++)
          {
             ret.w[i][j]=inf;
             for(int k=;k<=;k++) ret.w[i][j]=min(ret.w[i][j],A.w[i][k]+B.w[k][j]);
          }
         return ret;
     }
     inline friend Matrix operator ^ (const Matrix A,LL k)
     {
         Matrix ret,tmp=A;
         for(int i=;i<=;i++) for(int j=;j<=;j++) ret.w[i][j]=(i==j)?:;
         for (;k;k>>=,tmp=tmp*tmp) if(k&) ret=ret*tmp;
         return ret;
     }
 }Q;

 bool check(LL x)
 {
     Matrix B=Q^x;
     LL mn=inf;
     for(int i=;i<=;i++) for(int j=;j<=;j++) mn=min(mn,B.w[i][j]);
     return mn>=n;
 }

 int main()
 {
     scanf("%lld",&n);
     scanf("%s",s);
     int ll=strlen(s);
     sam.tot=sam.last=;
     for(int i=;i<ll;i++) sam.extend(s[i]-'A'+);
     memset(vis,,sizeof(vis));
     sam.dfs();

     for(int i=;i<=;i++) for(int j=;j<=;j++) Q.w[i][j]=mn[t[].son[i]][j];

     LL l=,r=n,ans;
     while(l<r)
     {
         LL mid=(l+r)>>;
         if(check(mid)) r=mid;
         else l=mid+;
     }
     printf("%lld\n",r);
     return ;
 }

看了CA爷的代码，感觉我的矩乘好看多啦！

写在结构体里面很有条理！！

2017-04-17 20:02:16