- 吐槽：前两天打组队赛遇到一个字符串的题考了这个（见：http://acm.hdu.edu.cn/showproblem.php?pid=5972 ）
当时写了个KMP瞎搞然后TLE了（害），赛后去查了许多资料似乎就看见一个题考了这么个鬼东西…
问题给出
- 给一个主串(S=s_1s_2...s_n)和一个模式串(T=(t_{11}|t_{12}|...|t_{1k_1})(t_{21}|t_{22}|...t_{2k_2})...(t_{m1}|t_{m2}|...|t_{mk_m}))，对于(S)的一个子串(S'[1,m]=S[i,i+m-1])，只要第(j)个位置满足(S[j]=t_{j1},t_{j2},..t_{jk_j})中的其中一个，就算匹配成功。找到(S)中所有能和(T)匹配的子串。
- (|S|,|T|)的范围依然很大，(k_i)和字符集比较小
问题分析
- 首先想到的是去修改一下KMP里匹配成功的条件…如果在一个位置发现了失配，即(s[i] otsubset t[j+1])，那样我们希望仍然有一个合适的失配数组(nxt[])让我们跳回合适的位置，即找到一个(T[1,j])的最长公共前后缀跳回去，但是这里就出现了问题，如果要保证(S)匹配到的后缀要和新的(T)的前缀匹配，那就得保证我们找的(T)的这个前缀包含了(T)的后缀，可是这样就也要改掉(nxt[])数组的求解。
- 好那就改吧，构造失配数组的时候把匹配条件
t[i]==t[j+1]改成包含关系，即我们要让(T[1,j+1])这个前缀包含(T[i-j,i])这个后缀如果(k_i)小的话这一步仍然可以认为是(O(1))的时间，整个处理过程仍然是(O(|T|))的。嗯到这里感觉都不错，接下来进行两个字符串的匹配了，(S)和(T)的比较也改成比较是否包含。如果失配的话同样是(j=nxt[j])地往回跳，一直到(j==|T|)匹配成功…到这里似乎都没什么问题 - 但是但是…一旦匹配成功输出结果，(j)这个指针该怎么跳？(j=nxt[j])？但是很快就会发现这里这样做会漏掉一些情况…（因为如果要求【跳到的前缀包含了当前的后缀】这样一个苛刻的条件，那样可能会出现(S)串马上又可以匹配，但是我们条件太苛刻跳过了的情况）
- 想来想去没法解决这个问题…
- 好吧既然KMP没法解决…不如我们换个算法（逃
另一种字符串匹配方法
和其他算法问题一样，我们可以考虑换一个维护的对象。下标，字符集…
比如这里，我们考虑从另一个角度切入字符串匹配的问题：对于字符集比较小的匹配，对模式串(T)里每个字符出现的位置进行记录：即用一个数组(B[i][j])表示字符(i)在第(j)个位置是否出现。这样记录能够处理这题里令我们头疼的问题：模式串的一个位置允许多种取值。
朴素暴力
好了现在有了这么一个想法，先试试看最暴力地要怎么做这个问题
（约定|S|=m,|T|=n）
(O(n))地求出(B[][])数组
for(int i=1;i<=n;i++)
int k;scanf("%d",&k);
for(int j=1;j<=k;j++)
int t;scanf("%d",&t);
B[t][i]=1
每次暴力匹配(S)和(T)，时间复杂度还是(O(nm))
for(int i=1;i<=m;i++)
int j=1;
for(;j<=n&&B[s[i+j-1]][j];j++);
if(j==n+1)
match!
优化算法
和其他字符串算法的思路一样，我们尝试能不能通过维护一些前后缀的信息来减少信息的冗余：比如这里我们发现，上面的算法每次都在暴力(O(n))地比较(S[i,i+n-1])和(T[1,n])，我们可以把这个过程看成(S[1,i+n-1])的后缀和(T[1,n])的前缀进行比较，于是类似KMP的思路，也许我们可以去维护(S)的后缀和(T)的前缀相关的信息！（这就是Shift-And算法的思路！）
我们考虑再用一个数组(D[])来维护这样一个信息：(D[j]=1)当且仅当(S[i-j+1,i])和(T[1,j])匹配，即(S)的一个后缀是(T)的前缀。否则(D[j]=0)。马上我们将会发现用Bool类型储存这样一个信息的优越性。
如果我们让(i,j)两个指针一起跑（如图），能写出递推式：(D[j+1]=(D[j])&(S[i+1]==T[j+1]))。进一步我们利用前面做好的数组(B[][])，可以把相等的判定修改一下，变成：(D[j+1]=D[j]&B[S[i+1]][j+1])
到这里都还只是逐位地进行位运算的比较，但是我们注意到这个(D[])似乎可以做成一个(bitset)，把它看成是一个长度为(|T|)的二进制数的话，尝试直接用一个(D)表示这个数组，用位运算来实现这个递推。
考虑上面的过程，从(D[j])到(D[j+1])需要先把上一位(D[j])的信息复制过来，再对(j+1)位进行一个取(&)的操作，考虑从(i=1,j=1)往上递推的整个过程…对于每个(i)，每次遍历(1,2,3,...,j...,|T|)，复制信息…对应位置取(&)，这个复制信息的过程不就相当于把一个二进制数全部左移一位么？每次取(&)也很麻烦，我们把(B[i][j])的第二个维度也压掉，直接对两个二进制数按位(&)，同时为了保证(&)正确性，每次左移完了之后把最低位赋为1。
另外，对于超过(|T|)的(j)的信息我们可以直接丢掉，所以也不用担心丢失什么信息。
至此，我们已经可以抛去(j)这个指针，得到从(i)到(i+1)递推式：
(D=(D<<1|1)&B[S[i+1]])实现
核心代码
const int N=5000005;
const int M=1005;
char s[N];
char t[M];
bitset<M>B[10],D;
int n,len;
int main(){
scanf("%d",&n);
rep(i,1,n){
int k;scanf("%d",&k);
rep(j,1,k){
int t;scanf("%d",&t);
B[t].set(i,1);
}
}
scanf("%s",s+1);
len=strlen(s+1);
rep(i,1,len){
D=(D<<1).set(1)&B[s[i]-'0'];
if(D[n]){
char ch=s[i+1];
s[i+1]=0;
puts(s+i-n+1);
s[i+1]=ch;
}
}
return 0;
}