计数 dp 部分例题（六~十部分）

六、转化求和顺序（線形和への分解）

例题1

题意

有一个长为 $n$ 的数组 $a$。求在 $a$ 中选择 $k$ 个数的所有方案中，每次选择的所有数的中位数的和。$n\le 10^5,k$ 为偶数。

解法

设 $B=\frac k2-1$。排序后，设在最中间的两个数为 $a_i,a_j$，则 $\frac 12(a_i+a_j)$ 在所有中位数里出现了 $\binom{i-1}B\binom{n-j-1}B$ 次，则答案为 $\frac 12\sum_{i=1}^n\sum_{j=i+1}^n(a_i+a_j)\binom{i-1}B\binom{n-j-1}B$，化简可以变成 $\frac 12\sum_{i=1}^n\binom{i-1}B\left(a_i\left(\sum_{j=i+1}^n\binom{n-j-1}B\right)+\sum_{j=i+1}^n\binom{n-j-1}Ba_j\right)$，后缀和优化计算即可。

例题2

求 $\sum_{x=0}^n\sum_{y=0}^m x{\,{\rm{XOR}}\,}y$。$n,m\le 10^9$。

解法

考虑将每个 $\rm{XOR}$ 的每一位拆开，然后合并每一位。设 $B_{x,j,0/1}$ 为满足 $\le x$ 且第 $j$ 位为 $0/1$ 的数的数量（显然可以 $O(1)$ 计算），则第 $j$ 位造成的贡献为 $2^j(B_{n,j,0}B_{m,j,1}+B_{n,j,1}B_{m,j,0})$。

例题3：Many Easy Problems

给定一棵大小为 $n$ 的无根树，定义 $f(i)$，对于所有大小为 $i$ 的点集，求出能够包含它的最小连通块大小之和。对于 $i=1 \sim n$ 的所有 $i$，求出 $f(i)\bmod 924844033$。$n\le 2\times 10^5$。（$924844033=2^{21}\times 441+1$，原根为 $5$）

解法

考虑将“能够包含每个大小为 $i$ 的点集的最小连通块大小之和”在每个点而非每个连通块处计算贡献，则其可以转化为“对于每个点，求作为包含某个大小为 $i$ 的点集的最小连通块中包含了该点的连通块数量”。

设以某个点 $u$ 为根时，其的每棵子树内大小分别为 $siz_{u,1},siz_{u,2},\cdots,siz_{u,s_u}$，则某个最小连通块内不包含 $u$ 的充要条件是内部每个点都在 $u$ 儿子的子树内，$u$ 对 $f(i)$ 的贡献即为 $\binom ni-\sum_{j=1}^{s_u}\binom{siz_{u,j}}i$，$f(i)$ 即为 $n\binom ni-\sum_{u=1}^n\sum_{j=1}^{s_u}\binom{siz_{u,j}}i$。设 $c_i=\sum_{u=1}^n\sum_{j=1}^{s_u}[siz_{u,j}=i]$，则 $f(i)=n\binom ni-\sum_{j=1}^nc_j\binom ji$。将 $\binom ji$ 拆成 $\frac{j!}{i!(j-i)!}$ 的形式，令 $F_j=(n-j)!$，则 $\sum_{j=1}^nc_j\binom ji=\sum_{j=1}^n(c_jj!)F_{n+i-j}$，就是标准的卷积形式了（差卷积）。

代码

点此查看代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=200010;
const int maxd=maxn<<1;
const int maxp=524300;
const int md=924844033,G=5;
int n,i,j,k,u,v,t,p,le,lm;
int h[maxn],c[maxp],d[maxp];
int r[maxp],fac[maxn],inv[maxn];
struct edge{int to,nxt;}E[maxd];
inline int Pow(int d,int z){
    int r=1;
    do{
        if(z&1) r=(1LL*r*d)%md;
        d=(1LL*d*d)%md;
    }while(z>>=1);
    return r;
}
int dfs(int p,int f){
    int lp,to,sz=1,nw;
    for(lp=h[p];lp;lp=E[lp].nxt){
        to=E[lp].to; if(to==f) continue;
        nw=dfs(to,p); sz+=nw; ++c[nw];
    }
    ++c[n-sz]; return sz;
}
inline void Add(int &x,int y){x-=((x+=y)>=md)*md;} 
void DFT(int *f){
    for(i=1;i<t;++i) if(i<r[i]) swap(f[i],f[r[i]]);
    for(i=1,le=2;le<=t;i=le,le<<=1){
        v=Pow(G,(md-1)/le);
        for(j=0;j<t;j+=le){
            for(k=0,u=1;k<i;++k,u=(1LL*u*v)%md){
                p=(1LL*f[i+j+k]*u)%md;
                Add(f[i+j+k]=f[j+k],md-p);
                Add(f[j+k],p);     
            }
        }
    }
} 
inline int C(int x,int y){return ((1LL*fac[y]*inv[x])%md*inv[y-x])%md;}
int main(){
    fac[0]=1;
    for(i=1;i<maxn;++i) fac[i]=(1LL*fac[i-1]*i)%md;
    inv[maxn-1]=Pow(fac[maxn-1],md-2);
    for(i=maxn-1;i;--i) inv[i-1]=(1LL*inv[i]*i)%md;
    scanf("%d",&n);
    for(i=1;i<n;++i){
        scanf("%d%d",&u,&v);
        E[++t]={u,h[v]}; h[v]=t;
        E[++t]={v,h[u]}; h[u]=t;
    }
    dfs(1,0); c[0]=0; d[0]=fac[n];
    for(i=1;i<=n;++i){
        d[i]=inv[n-i];
        c[i]=(1LL*c[i]*fac[i])%md;
    }
    for(u=n<<1,t=1;t<u;t<<=1); 
    for(le=t>>1,i=0;i<t;++i)
        r[i]=(r[i>>1]>>1)+(i&1)*le;
    DFT(c); DFT(d);
    for(i=0;i<t;++i) c[i]=(1LL*c[i]*d[i])%md;
    DFT(c); reverse(c+1,c+t); u=Pow(t,md-2);
    for(i=1,j=n+1;i<=n;++i,++j){
        v=((1LL*c[j]*u)%md*inv[i])%md; 
        Add(v=md-v,(1LL*n*C(i,n))%md);
        printf("%d\n",v);
    } 
    return 0;
}

七、置换群相关知识（部分群のテクニック）

置换群相关知识可以用于解决某些不可重计数问题。然而自认为后面的两个题的解法和置换群相关知识联系不大，需要者可以自行看 OI Wiki。不过这里的题目都是和“如何交换两个可交换的位置以尽量少影响其他位置/找出能够表示其他所有操作的单位操作”的思路有关。

例题1：Reverse Grid

题意

有一个 $H\times W$ 的矩阵 $a$，可以进行若干次操作，每次选择一行或一列翻转，求最后能够生成的本质不同的矩阵有多少种。$H,W\le 200,$ 矩阵内的元素均为小写字母。

解法

考虑某个 $a_{i,j}$ 只会变到 $a_{H-i+1,j},a_{i,W-j+1},a_{H-i+1,W-j+1}$ 的位置。（对于 $H,W$ 为奇数的情况，可以直接乘上中间能否变化的方案数，则其他元素都有四种可能出现的位置）所以这四个元素可以看成一个四元组整体处理。设四个位置的数分别为 $a,b,c,d$，则可以通过下面的方式使得只有 $a,b,c,d$ 之间的顺序进行变化（箭头表示行/列内其他元素的顺序）：

同理其他任意三个元素也可以按照这样的方式变化，打表可以发现这些元素出现的顺序有 $12$ 种。同时可以发现将同在一行/一列的元素调换位置可得所有 $4!$ 种方式中另外 $12$ 种出现方式，意味着某行被翻转将导致若干个四元组能够变换的位置同时变化。注意如果某个四元组内部出现了相同的数，则它们一定可以在某次变化后出现在同一行，它们在被翻转某行/某列后能够变换出的顺序一样，可以把对应的贡献先乘上；否则在翻转某行/某列后对应能够变换出的顺序会变化。

考虑将每一行和每一列看成点，然后对于某个四元组 $\{a_{i,j},a_{H-i+1,j},a_{i,W-j+1},a_{H-i+1,W-j+1}\}(2i\le H,2j\le W)$，在第 $i$ 行和第 $j$ 列之间连边。在翻转某行/某列之后对应出边的四元组状态也会改变，所以可以对于某个连通块 $S$ 求出某棵生成树，然后对于树上 $2^{|S|-1}$ 种状态，自顶向下确定某行/某列是否翻转（会有两种等效的方式），进一步确定其他所有边的状态（只会有一种）。时间复杂度为 $O(HW)$。

代码

点此查看代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=210;
const int maxt=maxn<<1;
const int md=1000000007; 
int n,m,i,j,k,p,w,a,b,ans=1,c[4];
int fa[maxt],siz[maxt];
char s[maxn][maxn];
int Find(int x){
    if(x==fa[x]) return x;
    return fa[x]=Find(fa[x]);
}
inline void Merge(int x,int y){
    x=Find(x); y=Find(y);
    if(x==y) return;
    if(siz[x]>siz[y]) swap(x,y);
    fa[x]=y; siz[y]+=siz[x]; siz[x]=1;
}
int main(){
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;++i) scanf("%s",s[i]+1);
    a=(n>>1)+1; b=(m>>1)+1;
    if(n&1){
        for(i=1;s[a][i]==s[a][m-i+1]&&i<=m;++i);
        if(i<=m) ans<<=1;
    }
    if(m&1){
        for(i=1;s[i][b]==s[n-i+1][b]&&i<=n;++i);
        if(i<=n) ans<<=1;
    }
    for(i=1,j=a+b-2;i<=j;++i) fa[i]=i,siz[i]=1;
    for(i=1;i<a;++i){
        for(j=1;j<b;++j){
            char t[4]={s[i][j],s[i][m-j+1],
                       s[n-i+1][j],s[n-i+1][m-j+1]};
            sort(t,t+4); w=24;
            for(k=c[p=0]=1;k<4;++k)
                w/=(++c[p+=(t[k]!=t[k-1])]);
            if(p==3) Merge(i,a+j-1),w=12;
            ans=(1LL*ans*w)%md;
            memset(c,0,(p+1)<<2);
        }
    }
    for(i=1,j=a+b-2;i<=j;++i)
        for(w=siz[i];--w;ans-=((ans<<=1)>=md)*md); 
    printf("%d\n",ans);
}

例题2：Rotate 3x3

题意

有一个 $3\times n$ 的网格，第 $i$ 行第 $j$ 列的数为 $3(j-1)+i$。可以进行若干次操作，每次将某个 $3\times 3$ 的子矩阵旋转 $180^{\rm o}$，求能否经过若干次操作得出某个 $3\times n$ 矩阵。$n\le 10^5$。

解法

显然每一列的数不会改变，且已知每一列被翻转的次数的奇偶性，则可以将每一列压成一个数，可以用正负号表示对应的列是否翻转。此时每次操作即为取三个相邻的数一起取反，然后交换两边的数。

显然奇数/偶数位置内部才能进行变换，然后对于某两个数交换位置时，我们可以选择中间的任意一个奇偶性不同的数变号。证明考虑对于两个数 $i,j$ 和中间奇偶性不同的数 $k$，可以先将 $i$ 移动到 $k-1$ 位置（会使得中间一段数全部变号，且从 $i+1$ 开始每两个数交换一次；最后整体向左平移），再将 $j$ 移动到 $k+1$ 位置（同理，但是整体向右平移）；对 $i,k,j$ 进行操作；最后把 $i,j$ 移回 $j,i$ 原来的位置。这种操作覆盖了给出的操作，所以可以表示所有操作。同理可以在不改变其他数的情况下将任意两个奇偶性相同的数变号。端点位置也可以变号，考虑让其变成非端点位置变号再移回去即可。

综上，可以设计出任意一个方案使得每个数到达对应位置，然后判断奇数/偶数位置的负数个数是否均为偶数即可。设计方案时，令 $r_i$ 为第 $i$ 行的数的绝对值，然后考虑一张 $n$ 个点的有向图，每个 $i$ 向 $r_i$ 连一条边（显然有向图由若干个简单环组成）；则每次对于某个 $i\ne r_i$ 的 $i$ 将 $r_i$ 和 $r_{r_i}$ 交换位置时，对应在有向图上就是将 $r_i$ 移出所在的简单环，所以在不超过 $n$ 次操作后一定可以将每个数换到原来的位置。最后注意在每次操作后维护奇数/偶数位置的负数个数。

代码

点此查看代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=100010;
int n,i,j,x,y,z; bool c[2];
int a[maxn][3],r[maxn];
int main(){
    scanf("%d",&n); c[0]=c[1]=1;
    for(i=0;i<3;++i)
        for(j=1;j<=n;++j)
            scanf("%d",a[j]+i);
    for(i=1;i<=n;++i){
        x=a[i][0]; 
        y=a[i][1]; 
        z=a[i][2];
        j=y/3+1;
        if(y%3!=2||(j^i)&1||
        !((y==x+1&&z==y+1)||
          (y==x-1&&z==y-1))){
            printf("No\n");
            return 0; 
        }
        r[i]=j; c[i&1]^=(y<x);
    }
    for(i=1;i<=n;++i){
        x=!(i&1);
        while(j=r[i],i!=j){
            swap(r[i],r[j]);
            c[x]^=1;
        }
    }
    if(c[0]&&c[1]) printf("Yes\n");
    else printf("No\n");
    return 0;
}

八、递归定义的运用（再帰的な定義の利用）

在分形相关的题目中，可以将 $K$ 级分形的对应内容拆成 $K-1$ 级分形的内容以 DP 计算。

例题：Chaotic Polygons

题意

求 $n$ 阶谢尔宾斯基三角形（如下）内简单闭合回路数量。$n\le 10^5$。

解法

考虑该三角形内的回路有两种：

• 只经过其中一个 $n-1$ 阶三角形内的。
• 同时经过三个 $n-1$ 阶三角形并绕回来的。

令 $S_n$ 为 $n$ 阶三角形的答案，而 $A_n$ 为从某个顶点到另一个顶点的简单路径数量，则 $S_n=3S_{n-1}+A_{n-1}^3$。同时从某个顶点到相邻顶点的简单路径也有两种：

• 只经过两个 $n-1$ 阶三角形的。
• 同时经过三个 $n-1$ 阶三角形的。

此时 $A_n=A_{n-1}^3+A_{n-1}^2$。注意简单回路的限制，路径上不能有环，所以需要减去成环（经过某个顶点两次）的方案数。设 $B_n$ 为从某个顶点到另一个顶点 且经过第三个顶点 的简单路径数，则要经过某个顶点两次时只能选择在两个 $n-1$ 阶三角形内强制经过第三个顶点，此时 $A_n=A_{n-1}^3+A_{n-1}^2-A_{n-1}B_{n-1}^2$，同理 $B_n=B_{n-1}A_{n-1}^2-B_{n-1}^3$。

代码

点此查看代码

#include <bits/stdc++.h>
using namespace std;
const int md=1000000007;
int n,i,s=1,a=2,b,c=1,d;
int main(){
    scanf("%d",&n); 
    for(i=1;i<=n;++i){
        b=(1LL*a*a)%md;
        d=md-(1LL*c*c+md-b)%md;
        s=(1LL*b*a+3LL*s)%md;
        a=(1LL*a*d+b)%md;
        c=(1LL*c*d)%md;
    }
    printf("%d\n",s);
}

九、数位 dp（桁 DP について）

例题1：Zig-Zag Numbers

题意

求满足下列条件的十进制数 $x$ 的个数模 $10000$：

• $x\ge A$ 且 $x\le B$。
• $x$ 是 $M$ 的倍数。
• $x$ 在十进制表示下，如果位数不为 $1$，则不能有相邻两位相同，且如果第 $i+2$ 位大于第 $i+1$ 位则需要第 $i+1$ 位小于第 $i$ 位。

$A,B\le 10^{500},M\le 500$。

解法

套路题，记 $dp_{i,j,0/1,r,0/1}$ 为填好了前 $i$ 位，第 $i$ 位为 $j$，模 $M$ 的值为 $r$，是否大于 $i-1$ 位，当前所填后缀是否大于 $A-1/B$ 的当前后缀的数的个数即可。

代码

点此查看代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=510;
const int md=10000;
int n,m,i,j,k,p,u,v,c,f,g,ans;
int dp[2][maxn][10][2][2];
char a[maxn],b[maxn];
inline void Add(int &x,int y){x-=((x+=y)>=md)*md;}
int Solve(char *x){
    n=strlen(x+1); 
    if(!n) return 0;
    auto X=dp[0],Y=dp[1]; int ret=0;
    memset(dp,0,sizeof(dp));
    c=x[1]^'0';
    for(j=0;j<10;++j) X[j%m][j][j>c][0]=1;
    for(j=1;j<10;++j) ret+=X[0][j][0][0];
    if(n==1) return ret;
    for(j=1;j<10;++j) ret+=X[0][j][1][0];
    c=x[2]^'0';
    for(j=u=0;j<10;++j){
        f=j>c; g=j>=c;
        for(k=0;k<j;++k){
            v=(u+k)%m; p=k%m;
            Add(Y[v][j][f][1],X[p][k][0][0]);
            Add(Y[v][j][g][1],X[p][k][1][0]);
        }
        for(++k;k<10;++k){
            v=(u+k)%m; p=k%m;
            Add(Y[v][j][f][0],X[p][k][0][0]);
            Add(Y[v][j][g][0],X[p][k][1][0]);
        }
        u+=10; 
    }
    for(j=1;j<10;++j) ret+=Y[0][j][0][0]+Y[0][j][0][1];
    if(n==2) return ret;
    for(j=1;j<10;++j) ret+=Y[0][j][1][0]+Y[0][j][1][1];
    swap(X,Y);
    for(i=3,v=100%m;i<=n;++i){
        memset(Y,0,sizeof(dp[0]));
        c=x[i]^'0';
        for(p=0;p<m;++p){
            for(j=0,u=p;j<10;++j){
                f=j>c; g=j>=c;
                for(k=0;k<j;++k){
                    Add(Y[u][j][f][1],X[p][k][0][0]);
                    Add(Y[u][j][g][1],X[p][k][1][0]);
                }
                for(++k;k<10;++k){
                    Add(Y[u][j][f][0],X[p][k][0][1]);
                    Add(Y[u][j][g][0],X[p][k][1][1]);
                }
                u-=((u+=v)>=m)*m;
            }
        }
        for(j=1;j<10;++j){
            Add(ret,Y[0][j][0][0]);
            Add(ret,Y[0][j][0][1]);
            if(i!=n){
                Add(ret,Y[0][j][1][0]);
                Add(ret,Y[0][j][1][1]);
            }
        }
        v=(10*v)%m; swap(X,Y);
    }
    return ret;
}
int main(){
    scanf("%s%s%d",a+1,b+1,&m); 
    reverse(a+1,a+strlen(a+1)+1);
    reverse(b+1,b+strlen(b+1)+1); 
    for(i=1;a[i]=='0';++i) a[i]='9'; 
    --a[i]; if(a[i]=='0') a[i]=0; 
    Add(ans=md-Solve(a),Solve(b));
    printf("%d\n",ans); return 0;
}

例题2

题意

有 $n$ 种硬币，第 $i$ 种硬币为 $a_i$ 元。现在每种硬币都有无穷个，求使用这些硬币凑出 $X$ 元的方案数。$n\le 20,a_i\le 30,X\le 10^{18}$。

解法

考虑在每次不只多增加一个硬币而是 $2^k$ 个（或者是对硬币数量二进制拆分）。此时对于每个 $k$，每种硬币只能有选择 $2^k$ 个或者不选择两个选项（可以使用背包处理对应的方案）；而在选择后需要当前硬币面额总和和 $X$ 的后 $k+1$ 位相等。此时可以对 $X$ 的每一位使用数位 dp 进行转移，转移时需要维护当前面额除以 $2^k$ 的商方便找出合法的 dp 值。

十、dp 优化（偏实现而非思想）（高速化のテクニック）

1. 前缀和优化（累積和の利用）

2. 数据结构优化（データ構造の利用）

3. 利用之前的数组（配列の使いまわし）

例题：Division into Two

题意

有一个长为 $n$ 的单增序列 $a$。求将其划分为两个子序列 $x,y$，满足 $x$ 中任意相邻两项之差不小于 $A$，$y$ 中任意相邻两数之差不小于 $B$ 的方案数。$n\le 10^5$。

解法

设 $dp_{i,j,0/1}$ 为考虑了前 $i$ 个数，且 $a_i$ 不在的子序列末尾为 $a_j$，$a_i$ 是否在 $y$ 子序列的方案数。转移有：

$$dp_{i+1,i,0}=dp_{i,0,1}+\sum_{a_{i+1}-a_j\ge A}dp_{i,j,1}\\dp_{i+1,i,1}=dp_{i,0,0}+\sum_{a_{i+1}-a_j\ge B}dp_{i,j,0}\\dp_{i+1,j,0}=[a_{i+1}-a_i\ge A]dp_{i,j,0}\\dp_{i+1,j,1}=[a_{i+1}-a_i\ge B]dp_{i,j,1}$$

考虑在枚举到 $a_i$ 时，只会更新 $dp_{i,i-1}$ 的值为 $dp_{i-1}$ 的某个前缀和，且如果 $a_{i+1}-a_i$ 过小则新的 $dp_{i,0}\sim dp_{i,i-2}$ 会赋为 $0$，否则新的 $dp_{i,0}\sim dp_{i,i-2}$ 可以直接赋值为 $dp_{i-1,0}\sim dp_{i,i-2}$。此时某个 $dp_{i,j}$ 被赋为 $0$ 则 $\forall k>i,dp_{k,j}$ 都会为 $0$。此时在计算 $dp_i$ 时可以直接使用 $dp_{i-1}$，维护最后一次被赋为 $0$ 的对应右端点即可。

代码

点此查看代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=100010;
const int md=1000000007;
int n,i,s0,s1,l0,l1,r0=-1,r1=-1;
int d0[maxn],d1[maxn],t0[maxn],t1[maxn];
long long a,b,w,s[maxn]; 
inline void Add(int &x,int y){x-=((x+=y)>=md)*md;}
int main(){
    scanf("%d%lld%lld%lld",&n,&a,&b,s+1); 
    s0=s1=t0[0]=t1[0]=1;
    for(i=1;i<n;++i){
        scanf("%lld",&w); s[i+1]=w; 
        while(w-s[l0+1]>=b) ++l0;
        while(w-s[l1+1]>=a) ++l1;
        if(l1>r1) Add(d0[i],t1[min(l1,i-1)]);
        if(l0>r0) Add(d1[i],t0[min(l0,i-1)]);
        if(w-s[i]<a) r0=i-1,s0=0;
        if(w-s[i]<b) r1=i-1,s1=0;
        Add(s0,d0[i]); Add(s1,d1[i]);
        t0[i]=s0; t1[i]=s1;
    }
    Add(s0,s1); printf("%d\n",s0);
    return 0;
}

4. FFT（高速フーリエ変換）

板子

点此查看代码

void DFT(int *f){
    for(i=1;i<t;++i) if(i<r[i]) swap(f[i],f[r[i]]);
    for(i=1,le=2;le<=t;i=le,le<<=1){
        v=Pow(G,(md-1)/le);
        for(j=0;j<t;j+=le){
            for(k=0,u=1;k<i;++k,u=(1LL*u*v)%md){
                p=(1LL*f[i+j+k]*u)%md;
                Add(f[i+j+k]=f[j+k],md-p);
                Add(f[j+k],p);     
            }
        }
    }
} 

属于需要背的知识。原根表。常见的原根形如 $998244353$ 原根为 $3$，$924844033$ 原根为 $5$。

5. 高维前缀和/FMT（高速ゼータ変換）

计算 $f_S=\sum_{T\in S}g_T$ 时，考虑分开处理每一位的贡献，设 $dp_{i,S}$ 为 $\sum_{j}f_j$ 且 $j$ 满足第 $i$ 位以上部分 $S,j$ 相等，第 $i$ 位以下部分 $j\in S$，则有 $dp_{i,S}\gets dp_{i-1,S}$；转移时如果 $S$ 的 $i$ 位为 $1$，则需要加上 $dp_{i,S\mathop{\rm xor} 2^i}$ 部分，表示此时的 $j$ 可以取 $i$ 位为 $0$。最后目标 dp 值即为 $f$ 值。

6. FWT（And と Add の畳み込み）

此处用了一种较为清奇（？）的思路。

(1) 或卷积（求 $C_i=\sum_{j\mathop{\rm or}k=i}A_jB_k$）

考虑多项式乘法的过程：我们会先对序列进行 DFT，然后相乘，最后进行 IDFT。此时可以使用类似的方式，用某种序列表示需要操作的序列。

令 $o(A)_i=\sum_{x\mathop{\rm or}i=i}A_x$，则 $o(C)_i=\sum_{(j\mathop{\rm or}k)\mathop{\rm or}i=i}A_jB_k$。而 $x\mathop{\rm or}i=i$ 等效于 $x$ 是 $i$ 的子集，所以 $(j\mathop{\rm or}k)\mathop{\rm or}i$ 当且仅当 $j,k$ 均是 $i$ 的子集，也就是说 $C_i=A_iB_i$。求 $o(A/B)$ 可以使用上述的方法，而从 $o(C)$ 变回 $C$ 时，考虑上述 dp 过程的逆过程：在从 $dp_i$ 推到 $dp_{i-1}$ 时，如果某个 $S$ 的第 $i$ 位为 $1$ 则 $dp_{i,S}=dp_{i-1,S}+dp_{i-1,S\mathop{\rm xor}2^i}=dp_{i-1,S}+dp_{i,S\mathop{\rm xor}2^i}$，否则 $dp_{i,S}=dp_{i-1,S}$，直接 dp 即可。

(2) 与卷积（求 $C_i=\sum_{j\mathop{\rm and}k=i}A_jB_k$）

仍然可以考虑上述的过程，设 $a(A)_i=\sum_{x\mathop{\rm and}i=i}A_x$，则同样有 $(j\mathop{\rm and}k)\mathop{\rm and}i=i$ 当且仅当 $j\mathop{\rm and}i=k\mathop{\rm and}i=i$，所以仍然有 $a(C)_i=a(A)_ia(B)_i$。求 $a(A)$ 时仍然可以使用上面 dp 的思路，但是转移时有 $dp_{i,S}=dp_{i-1,S}+[S\mathop{\rm and}2^i=0]dp_{i-1,S\mathop{\rm or}2^i}$。从 $a(C)$ 推回 $C$ 同理。

(3) 异或卷积（求 $C_i=\sum_{j\mathop{\rm xor}k=i}A_jB_k$）

考虑异或的性质，令 $c(x)$ 为 $x$ 在二进制表示下的位数，可以发现 $(c(j)+c(k)-c(j\mathop{\rm xor}k))\bmod 2=0$，同理有 $(c(j\mathop{\rm and}i)+c(k\mathop{\rm and}i)-c((j\mathop{\rm xor}k)\mathop{\rm and}i))\bmod 2=0$。令 $x_p(A)_i=\sum_{c(j\mathop{\rm and}i)\bmod 2=p}A_j$，则 $x_p(C)_i=\sum_{j,k\in\{0,1\}}[j\mathop{\rm xor}k=p]x_j(A)_ix_k(B)_i$。$x_{0/1}$ 也可以使用上述的 dp 方式计算。不过有更简洁的方式计算：设 $x(A)_i=x_0(A)_i-x_1(A)_i$，则 $x(C)_i=x(A)_ix(B)_i$。同或卷积可以直接将求得的 $C$ 翻转即可。

(4) 子集卷积（求 $C_i=\sum_{j\mathop{\rm or}k=i,j\mathop{\rm and}k=0}A_jB_k$）

考虑第二个性质等效于 $c(j)+c(k)=c(i)$。可以把所有下标按照 $c$ 的不同值分开处理，设 $o_p(A)_i$ 为 $\sum_{c(j)=p,j\mathop{\rm and}i=i}A_j$，则 $o_p(C)_i=\sum_{j+k=p}o_j(A)_io_k(B)_i$（暴力计算即可）。

7. 简单剪枝（簡単な枝刈り）