矩阵

题目大意

给出一个长为n宽为m大写字母矩阵，求有多少个本质不同的子矩阵。
n<=110
（该题放了一个烟雾弹说“往后缀三姐妹上想，呵呵”，于是我就没敢往那上面想，呵呵了。。。）

哈希

设ha[i][j][k]表示第i行第j列开始的宽度为k的子串的hash值，这个可以n^3预处理。
然后枚举一个宽度k，把每一列视为一个长度为n的字符串(字符即为hash值)，然后问题就变成了求m个字符串本质不同的串的个数，这个可以用后缀数组做也可以用广义后缀自动机来做。
我是用SAM做的，算上map的复杂度，总共为O(n^3log n)，实测比后缀数组慢，但编程复杂度小。

代码

#include<cstring>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<map>
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fod(i,a,b) for(i=a;i>=b;i--)
#define ll long long
using namespace std;
const int maxn=110+5;
const int mn=115*115;
const int ma=1000000007;
const int ma1=13333779;
int i,j,n,m,k,ans;
int s[maxn][maxn],ha[maxn][maxn][maxn];
struct sam{
    int pre,len;
    map<int,int> son;
} sa[mn*100];
int last,num;
char c[maxn][maxn];
void read(char &a){
    a=getchar();
    while ((a<'A')||(a>'Z')) a=getchar();
}
void add(int x){
    if (sa[last].son[x]){
        int p=last,q=sa[p].son[x];
        if (sa[q].len==sa[p].len+1)last=q;else{
            int nq=++num;
            sa[nq]=sa[q];
            sa[nq].len=sa[p].len+1;
            sa[q].pre=nq;
            while (p!=-1&&sa[p].son[x]==q) sa[p].son[x]=nq,p=sa[p].pre; 
            last=nq;
        }
        return;
    }
    int p=last,np=++num;
    sa[np].len=sa[p].len+1;
    sa[np].son.clear();
    while (p!=-1&&!sa[p].son[x]) sa[p].son[x]=np,p=sa[p].pre;
    if (p==-1) sa[np].pre=0;else{
        int q=sa[p].son[x];
        if (sa[q].len==sa[p].len+1) sa[np].pre=q;else{
            int nq=++num;
            sa[nq]=sa[q];sa[nq].len=sa[p].len+1;
            sa[q].pre=sa[np].pre=nq;
            while (p!=-1&&sa[p].son[x]==q) sa[p].son[x]=nq,p=sa[p].pre;
        }
    }  
    ans+=sa[np].len-sa[sa[np].pre].len;
    last=np;
}
int main(){
    scanf("%d%d",&n,&m);
    fo(i,1,n) fo(j,1,m) read(c[i][j]);  
    fo(i,1,n) 
    fo(j,1,m){
        int l=0,l1=0;
        fo(k,1,m-j+1) {
            l=(ll)(l*13531+c[i][j+k-1]-'A')%ma;
            l1=(ll)(l1*29+c[i][j+k-1]-'A')%ma1;
            ha[i][j][k]=l*29+l1;
        }
    }sa[0].pre=-1;
    fo(k,1,m){
        num=0;
        sa[0].son.clear();
        fo(j,1,m-k+1){
            last=0;
            fo(i,1,n) add(ha[i][j][k]);
        }
    }
    printf("%d\n",ans);
}