「Gym103409H」Popcount Words
题目
点这里看题目。
分析
首先自然是研究一下 \(w()\) 有没有什么比较好的性质。
这个其实猜都猜得到，\(w()\) 显然应当存在一定的倍增结构。具体地来说，我们考察一种特殊情况：
定义 \(W_{n}=w(0,2^n-1),\overline{W_n}=w(2^n,2^{n+1}-1)\)，则我们不难得到：
- \(W_0=\mathtt{0},W_1=\mathtt{1}\)。
- \(W_n=W_{n-1}+\overline{W_{n-1}},\overline{W_n}=\overline{W_{n-1}}+W_{n-1},n\in \mathbb N_+\)。
当然，由此我们还不难得出一个简单的性质：
理解起来很容易，从 \(k2^n\) 一路 +1 到 \((k+1)2^n-1\)，真正在变化的只有低 \(n\) 位，因而 \(k\) 的 \(\operatorname{popcount}\) 可以和低位的 \(\operatorname{popcount}\) 分开。
这个性质有可能是在后面要用到的时候才想起来去找的，不过无伤大雅，反正很容易发现就是了。
下面考察一下 \(S\) 的结构。既然有了 \(W\) 这样的基础元素，我们就可以直接通过二进制，将 \(w(l,r)\) 拆分成 \(O(\log r)\) 个 \(W\) 或 \(\overline W\) 拼接的结果。
具体过程有点像是树状数组：
-
设正整数 \(x\) 在二进制下最低位为 \(\operatorname{lowbit}(x)\)。
-
先从 \(l\) 上升，每次加入 \(w(l,l+2^{\operatorname{lowbit}(l)}-1)\)，再令 \(l=l+2^{\operatorname{lowbit}(l)}\)。
当 \(l+2^{\operatorname{lowbit}(l)}>r\) 时结束。
-
再逐步逼近 \(r\)，每次加入 \(w(l,l+2^{\operatorname{lowbit}(r-l)}-1)\)，再令 \(l=l+2^{\operatorname{lowbit}(r-l)}\)。
当 \(l=r\) 时结束。
需要注意的是，最终我们形成的是 \(w(l,r-1)\)，因此需要对于右端点稍稍调整一下，无伤大雅。
回到原问题。多模式串匹配的问题，首先反手建立一个 AC 自动机不多说。哈哈哈，学麻了，一开始居然没有想到 AC 自动机，还试图多次询问单独跑 KMP
注意到，最终我们的问题，可以被转化为：求 AC 自动机上每个结点各自被经过了多少次。我们已经将 \(S\) 拆分为了 \(O(n\log r)\) 个 \(W\) 或 \(\overline W\)，所以可以看作是将 \(W,\overline W\) 按顺序放到 AC 自动机上分段转移。
注意到两点：
- 这是一个典型的离线查询的问题。
- \(W,\overline W\) 本身就含有倍增的结构。
我们不由得想到了打标记，结合 \(W,\overline W\) 则可以确定是逆序下放倍增标记的方法。
更准确地描述是：我们只需要确定起始点 \(u\) 和转移的序列 \(W_n\) 或 \(\overline {W_n}\)，即可确定标记具体打在了哪里。因此，可以考虑状态 \(g_{u,n,0/1}\)，表示从 \(u\) 出发，转移了 \(W_n\) 或者 \(\overline {W_n}\)，这样的情况在 \(S\) 中总共出现了多少次。
记录辅助状态 \(f_{u,n,0/1}\) 表示从 \(u\) 出发，转移了 \(W_n\) 或者 \(\overline{W_n}\) 后的终点；\(h_{u,n,0/1}\) 表示仅考虑由 \(S\) 拆分出来的 \(W\) 或 \(\overline W\) 序列，从 \(u\) 出发转移了 \(W_n\) 或者 \(\overline{W_n}\) 的情况出现了多少次。
可以写出如下的转移：
举个例子，当 \(k=0\) 时，简单来说就是：考虑直接出发；考虑从 \(W_{n+1}\) 拆出来的部分（前半段是 \(W_n\)）；考虑从 \(\overline{W_{n+1}}\) 拆出来的部分（后半段是 \(W_{n}\)）。
这个可以做到 \(O((\sum|p|)\log r)\) 的预处理和下放，总时间复杂度为 \(O((n+\sum|p|)\log r)\)。
小结：
-
对于 \([l,r]\) 的拆分的思想值得学习，而不应该被局限于此题。
关键在于，\(w\) 和树状数组有一定的相似性：树状数组中，每个位置记录了长为 \(2^{\operatorname{lowbit}}\) 的后缀和；而在 \(w\) 中，移动 \(2^{\operatorname{lowbit}}\) 步的字符串可以化归为 \(W\) 或者 \(\overline W\)。
-
这里的倍增标记法的联想和运用确实很巧妙。典型的离线查询问题中，标记确实是很好用的。
-
哈哈哈，下次看到多模式串匹配别再犯傻了。
代码
复杂度写得这么对，到我这儿怎么就开始卡常了？
#include <cstdio>
#define rep( i, a, b ) for( int i = (a) ; i <= (b) ; i ++ )
#define per( i, a, b ) for( int i = (a) ; i >= (b) ; i -- )
typedef long long LL;
const int MAXN = 1e5 + 5, MAXV = 5e5 + 5, MAXLOG = 35;
template<typename _T>
void read( _T &x ) {
x = 0; char s = getchar(); bool f = false;
while( ! ( '0' <= s && s <= '9' ) ) { f = s == '-', s = getchar(); }
while( '0' <= s && s <= '9' ) { x = ( x << 3 ) + ( x << 1 ) + ( s - '0' ), s = getchar(); }
if( f ) x = -x;
}
template<typename _T>
void write( _T x ) {
if( x < 0 ) putchar( '-' ), x = -x;
if( 9 < x ) write( x / 10 );
putchar( x % 10 + '0' );
}
LL cnt[MAXV];
LL g[MAXV][MAXLOG][2];
int f[MAXV][MAXLOG][2];
int q[MAXV];
int ch[MAXV][2], fail[MAXV];
int ntot = 0;
int ed[MAXN];
int segL[MAXN], segR[MAXN];
char buf[MAXV];
int N, Q;
inline int Lowbit( const int &x ) {
return x & ( - x );
}
inline int Insert( const char *str ) {
int p = 0, x;
for( int i = 0 ; str[i] ; i ++ ) {
x = str[i] - '0';
if( ! ch[p][x] ) ch[p][x] = ++ ntot;
p = ch[p][x];
}
return p;
}
inline void Build() {
int h = 1, t = 0;
if( ch[0][0] ) fail[q[++ t] = ch[0][0]] = 0;
if( ch[0][1] ) fail[q[++ t] = ch[0][1]] = 0;
while( h <= t ) {
int u = q[h ++];
( ch[u][0] ? fail[q[++ t] = ch[u][0]] : ch[u][0] ) = ch[fail[u]][0];
( ch[u][1] ? fail[q[++ t] = ch[u][1]] : ch[u][1] ) = ch[fail[u]][1];
}
}
int main() {
read( N ), read( Q );
rep( i, 1, N ) read( segL[i] ), read( segR[i] );
rep( i, 1, Q ) {
scanf( "%s", buf );
ed[i] = Insert( buf );
}
Build();
rep( i, 0, ntot )
f[i][0][0] = ch[i][0],
f[i][0][1] = ch[i][1];
rep( j, 1, 29 ) rep( i, 0, ntot )
f[i][j][0] = f[f[i][j - 1][0]][j - 1][1],
f[i][j][1] = f[f[i][j - 1][1]][j - 1][0];
int p = 0;
rep( i, 1, N ) {
int l = segL[i], r = segR[i] + 1;
while( l + Lowbit( l ) <= r ) {
g[p][__builtin_ctz( l )][__builtin_parity( l )] ++;
p = f[p][__builtin_ctz( l )][__builtin_parity( l )];
l += Lowbit( l );
}
while( l < r ) {
g[p][31 - __builtin_clz( r - l )][__builtin_parity( l )] ++;
p = f[p][31 - __builtin_clz( r - l )][__builtin_parity( l )];
l += 1u << ( 31 - __builtin_clz( r - l ) );
}
}
per( j, 28, 0 )
rep( i, 0, ntot ) {
g[i][j][0] += g[i][j + 1][0];
g[f[i][j][0]][j][1] += g[i][j + 1][0];
g[i][j][1] += g[i][j + 1][1];
g[f[i][j][1]][j][0] += g[i][j + 1][1];
}
rep( i, 0, ntot )
cnt[ch[i][0]] += g[i][0][0],
cnt[ch[i][1]] += g[i][0][1];
per( i, ntot, 1 ) {
int u = q[i];
cnt[fail[u]] += cnt[u];
}
rep( i, 1, Q )
write( cnt[ed[i]] ), putchar( '\n' );
return 0;
}
