「算法笔记」状压 DP

一、关于状压 dp

为了规避不确定性，我们将需要枚举的东西放入状态。当不确定性太多的时候，我们就需要将它们压进较少的维数内。

常见的状态：

天生二进制（开关、选与不选、是否出现……）
爆搜出状态，给它们编号

1. 状态跟某一个信息集合内的每一条都有关。（如 dp 套 dp）

2. 若干条精简而相互独立的信息压在一起处理。 (如每个数字是否出现)

在使用状压 dp 的题目当中，往往能一眼看到一些小数据范围的量，切人点明确。而有些题，这样的量并不明显，需要更深人地分析题目性质才能找到。

二、预备知识

1. 位运算

二进制数 S 从低（0-based）到高第 i 位的值：(S>>i)&1

二进制数 S 从低（0-based）到高第 i 位的值变为 1：S|(1<<i)

二进制数 S 从低（0-based）到高第 i 位的值变为 0：S&(~(1<<i)) 或 ~((~S)|(1<<i))

二进制数 S 从低（0-based）到高第 i 位的值取反：S^(1<<i)

2. 枚举子集

for(int i=S;i!=0;i=(i-1)&S)

复杂度：

(2ⁿ-1) 的子集：2ⁿ

(2ⁿ-1) 的子集的子集和：3ⁿ

(2ⁿ-1) 的子集的子集的子集和：4ⁿ

……

三、例题

1. TSP（旅行商问题）

题目大意：一个 n 个点的带权的有向图，求一条路径，使得这条路径经过每个点恰好一次，并且路径上边的权值和最小。n≤16。

Solution：

设 dp[i][S] 表示目前走到节点 i，已经经过节点的集合为 S 的最小边权。

枚举所有的边 (i,j)∈E，令 w(i,j) 表示它的边权。

if j∉S（因为要满足经过每个点恰好一次，即不能重复经过，所以要满足 j 没有被经过），dp[i][S]+w(i,j)→dp[j][S∪{j}]

若 S&(1<<j) 的值为 0，则 j 不在 S 中；若 S&(1<<j) 的值不为 0，则 j 在 S 中。也可以判断 (S>>j)&1 是否为 1。

初始化一个节点的路径 dp[i][1<<i]=0（节点编号为 0~n-1）或 dp[i][1<<(i-1)]=0（节点编号为 1~n），其他的设为 ∞。

把 j 加入到 S：S +/|/^ (1<<j)。因为已经确认了 S 的这一位是 0，则 +，|，^ 都是可以的。

时间复杂度：O(2ⁿ·n²)

2. [USACO06NOV] 玉米田 Corn Fields

题目大意：有一个 N*M 的网格图，已知若干个格子不能选、不能有相邻的格子被选。在不限制所选格子总数的前提下，求方案数。N,M≤12。

Solution：

由于限制在相邻的格子上，若按行或按列 dp，就不需要维护之前已经决策过的格子的状态，而是维护一行或一列的格子的状态。

令 dp[i][j] 表示目前 dp 到第 i 行，这一行的状态是 j，所有 1~i 行内的格子被选的方案数。

枚举 i+1 行的状态 k，判断 k 与 j 是否有冲突（是否出现某个格子的上面一个格子被选了的情况，即是否有相邻的格子被选），只需判断 j&k 是否为 1（j 的二进制数与 k 的二进制数是否有在相同的位置同时等于 1）。

dp[i][j]→dp[i+1][k]

预处理出没有相邻的两列同时被选的状态。在一行 12 个格子的网格图中，没有相邻的两列同时被选的合法的状态大概有 377 个。

int ans=0;
for(int i=0;i<(1<<12);i++){
    bool flag=1;
    for(int j=1;j<=11;j++)
        if(((i>>(j-1))&1)&&((i>>j)&1)) flag=0;
    if(flag) ++ans;
} 
printf("%lld\n",ans);
//Output:377

所以通过预处理，可以通过此题。

Code：

#include<bits/stdc++.h>
#define int long long 
using namespace std;
const int N=13,M=(1<<12)+5,mod=1e9;
int n,m,a[N][N],p[N],f[N][M],ans;
bool v[M];
signed main(){
    scanf("%lld%lld",&m,&n),f[0][0]=1;
    for(int i=1;i<=m;i++)
        for(int j=1;j<=n;j++){
            scanf("%lld",&a[i][j]);
            p[i]=(p[i]<<1)+a[i][j];    //记录第 i 行土地的状态 
        }
    for(int i=0;i<(1<<n);i++){
        v[i]=1;
        for(int j=1;j<n;j++)
            if(((i>>(j-1))&1)&&((i>>j)&1)) v[i]=0;
    } //记录状态 i 是否合法（预处理出没有相邻的两列同时被选的状态） 
    for(int i=1;i<=m;i++)    //枚举行 
        for(int j=0;j<(1<<n);j++)    //枚举这行的状态 
            if(v[j]&&(j&p[i])==j)    //判断状态 j 是否合法以及是否在肥沃的土地上 
                for(int k=0;k<(1<<n);k++)    //枚举上一行的状态 
                    if(!(k&j)) f[i][j]=(f[i][j]+f[i-1][k])%mod;
    for(int i=0;i<(1<<n);i++)
        ans=(ans+f[m][i])%mod;    //前 m 行的方案数累加 
    printf("%lld\n",ans);
    return 0;
}

3. TopCoder RainbowGraph

题目大意：给出一张 N 个点 M 条边的无向图。每个点有一个颜色。一条路径是合法的当且仅当它按顺序经过的节点的颜色序列写下来，同种颜色出现的位置是连续的。计算合法的经过每个节点恰好一次的路径条数。N≤100，Color≤10（颜色数），对于任意的 i，Cnt(v|Color_v=i)≤10（每种颜色的节点数）。

Solution：

既然同种颜色出现的位置是连续的。我们不妨将问题划分成两个小问题考虑：

对于颜色 c，从 i 出发到 j 结束，同时遍历完所有该颜色节点的路径条数是多少。
对于全局，有多少种安排颜色的方法、及安排颜色之间“接口”的方法。

第一个问题：将同种颜色内的串起来。

要求：（1）每个点恰好出现一次（2）相邻两点之间有边相连

令 dp[i][j][S] 表示从 i 号点出发，在 j 号点结束，经过的节点集合为 S 的路径条数。

for(int i=0;i<k;i++)    //k:当前颜色的节点个数 
    dp[i][i][1<<i]=1;    //考虑单点路径的情况 
for(int S=1;S<(1<<k);S++)    //枚举状态 
    for(int i=0;i<k;i++)    //枚举起点 
        for(int j=0;j<k;j++)    //枚举终点 
            if(dp[i][j][S])    //判断当前的 dp 状态是否合法 
                for(int p=0;p<k;p++)    //枚举下一个点 
                    if(!((S>>p)&1)&&G[j][p])    //p 在状态中没有出现过（之前没有经过这个点）并且之前路径的终点 j 能够到达下一个点 p 
                        dp[i][p][S|(1<<p)]+=dp[i][j][S];

注：这里所有的节点编号，为了方便体现，直接写成了 i 之类的。事实上，需要开一个数组维护，把全局当中的颜色为当前颜色的节点转化到 0~k 的范围内。

第二个问题：将每种颜色串起来。

要求：（1）每种颜色恰好出现一次（则需记录颜色状态 2^C）（2）相邻颜色的首尾节点间有边相连（则需记录终点 N）

对于一种颜色 c，我们使用 f[c][i][j] 来代表之前的 dp[全局中编号为 i 的点][全局中编号为 j 的点][(1<<k)-1]。

令 dp[i][S] 表示以节点 i 结尾，已经经过的颜色集合为 S 的总方案数。

for(int c=0;c<C;c++)    //枚举颜色 
    for(int i=0;i<k[c];i++)    //枚举起点  k[c]:颜色为 c 的节点个数 
        for(int j=0;j<k[c];j++)    //枚举终点 
            dp[id[j]][1<<c]+=f[c][i][j]; 
for(int S=1;S<(1<<C);S++)
    for(int i=0;i<N;i++)
        if(dp[i][S]) for(int c=0;c<C;c++)    //枚举下一个颜色  C:颜色数 
            if(!((S>>c)&1))    //这个颜色在之前的状态中没有出现过 
                for(int j=0;j<k[c];j++)    //枚举下一个颜色的起点 
                    if(G[i][id[j]])    //当前的终点与下一个起点有边可以到达 
                        for(int q=0;q<k[c];q++)    //枚举下一个颜色的终点 
                            dp[id[q]][S|(1<<c)]+=dp[i][S]*f[c][j][q];

4. TopCoder CheeseRolling

题目大意：N 个人打淘汰赛。N 是 2 的幂次。给出两两单挑的胜负情况。一共有 N! 种赛程安排方案，对于每个人，你需要输出有多少种方案使他最终获胜。n≤16。

Solution：

令 dp[i][S] 表示编号为 i 的选手是选手集合 S 中的优胜者的方案数。

那么最后每个点的答案就是 dp[i][(1<<N)-1]

枚举 i 能够战胜的对手 j，然后将集合 S 等分为两个一个包含 i 一个包含 j 的集合。

for(int i=0;i<N;i++)
    dp[i][1<<i]=1; 
for(int S=1;S<(1<<n);S++)    //枚举集合 S 
    if(valid(S))    //只处理大小为 2 的幂次的集合 
        for(int i=0;i<N;i++)    //枚举集合中的胜出者 i 
            if((S>>i)&1)    //集合 S 包含 i 
                for(int j=0;j<N;j++)    //枚举 i 所击败的对手 j 
                    if(i!=j&&G[i][j])    //i 和 j 不是同一个人并且 i 能够击败 j 
                        for(int k=(S-1)&S;k!=0;k=(k-1)&S)    //枚举子集 
                            dp[i][S]+=2LL*dp[i][k]*dp[j][S^k];

复杂度为 O(3ⁿ·n²)，偏高，需要优化。

优化 1：valid 这部分有很多冗余状态，可以预处理出来有效的部分。
优化 2：把子集改成 dfs 精确枚举等分子集。

5. AtCoder 058E Iroha and Haiku

题目大意：

一个有 N 个元素且每个元素的取值都在 1~10 范围内的序列被称为好的当且仅当存在下标 x,y,z,w（0≤x<y<z<w≤N）

a_x+a_x+1+...+a_y-1=X
a_y+a_y+1+...+a_z-1=Y
a_z+a_z+1+...+a_w-1=Z

计数。并对 10⁹+7 取模。3≤N≤40，1≤X≤5，1≤Y≤7，1≤Z≤5。

Solution：

做法 1：当你不知道如何优雅地设计状态/不知道状态的规模有多大时，不妨暴力一点。

因为 X≤5，Y≤7，Z≤5，所以 X+Y+Z≤5+7+5，即 X+Y+Z≤17，a_x+a_x+1+...+a_y-1+a_y+a_y+1+...+a_z-1+a_z+a_z+1+...+a_w-1≤17。

只需维护取值 1~10，和≤17 的序列。

#include<bits/stdc++.h>
#define int long long
using namespace std;
int cnt;
void dfs(int x){
    if(x>17) return ;
    ++cnt;
    for(int i=1;i<=10;i++) dfs(x+i);
}
signed main(){
    dfs(0),printf("%lld\n",cnt);
    return 0;
} 
//Output:130624

大约 10⁵个状态，做法就显而易见了。

一个 dp 序列当中的元素，每次只保留最靠后的值不超过 17 的元素队列。

dp[i][S][0/1] 表示当前 dp 到序列中第 i 个元素，队列的状态为 S，是否出现过题中所述条件。

一些优化：

优化 1：每个状态是否满足题中条件可预处理。
优化 2：每个状态遇到了 1~10 后转移到什么状态可预处理。（需要一个作用在 vector上的 map 或是 set、二分等）
优化 3：状态当中的第三维可以通过求补集而去掉。

不难观察得到，算法的复杂度瓶颈主要是由状态的 vector 形态带来的。

做法 2：思路和前面类似，只不过考虑换个形式表示“和不超过 17”这个状态。

如果我们将这“X+Y+Z”点贡献展开看成一条长度为 X+Y+Z 的格子，一个数可以占领 1~10 个格子。那么我们关心的即为位置在 X、X+Y、X+Y+Z 的三个格子是否是一个数所占领格子的末尾。我们考虑将一个数末尾标为 1，其他格子标为 0。

例子：X=Y=Z=2，后缀状态：

2+2+2	010101
1+1+2+2	110101
2+1+1+2	011101
1+2+2+1	101011

Code：

//开始的格子为 1 的写法 
#include<bits/stdc++.h>
#define int long long
using namespace std; 
const int N=50,M=(1<<17)+5,mod=1e9+7; 
int n,x,y,z,st,dp[N][M],sum=1,k,ans;
signed main(){
    scanf("%lld%lld%lld%lld",&n,&x,&y,&z); 
    st=((1<<(x+y+z-1)))|(1<<(y+z-1))|(1<<(z-1));    //目标从后往前数的第 X+Y+Z、Y+Z、Z 的位置为 1
    dp[0][0]=1;
    for(int i=1;i<=n;i++){
        sum=sum*10%mod;     //计算总方案数（n 位数字，就有 10^n 种方案） 
        for(int S=0;S<(1<<(x+y+z));S++)    //枚举状态 
            if(dp[i-1][S]&&(S&st)!=st)
                for(int c=1;c<=10;c++){     //枚举第 i 位添加的数字 
                    k=((S<<c)|(1<<(c-1)))&((1<<(x+y+z))-1);
                    //(S<<c)|(1<<(c-1)): 比如 4 的二进制数为 1000，4 后面加上 2 为 4 2，用 100010 表示，即将 4 的二进制向前两位再加上 10。 
                    //...&((1<<(x+y+z))-1: 防止溢出 
                    dp[i][k]=(dp[i][k]+dp[i-1][S])%mod;
                } 
    } 
    for(int S=0;S<(1<<(x+y+z));S++)
        if((S&st)!=st) ans=(ans+dp[n][S])%mod;
    printf("%lld\n",(sum-ans)%mod);    //总方案数减不符合条件的方案 
    return 0;
}

6. AtCoder XOR Tree

题目大意：给出一棵 N 个节点的树，每条树边有一个边权。.每次操作你可以将一条路径上的边权异或上某个值。问最少进行多少次操作可以达到边权全 0。N≤10⁵，0≤边权≤15。

Solution：

首先定义一个点的点权为与其相邻的所有边的边权异或和。

容易证明边权全为 0 等价于点权全为0。

边权为 0→点权为 0：根据定义显然
点权为 0→边权为 0：来自树的性质，总是存在叶子结点。叶子结点上的点权为 0 可推出一条边权为 0。删去后重复这一过程。

每次操作就可以看成是将任意两个点异或上同一个数。

如果是两个相同的数，一次操作就可以直接将这俩消去。
如果是两个不同的数 a,b，那么一次操作可以消去一个，剩下一个 a^b。

思考一下要不要考虑同时异或一个不为 a 也不为 b 的数 x。

因为一共只有 16 种取值，我们先将重复的直接消去。剩下的信息只有 0~15 每个数字是否出现过，可以压成一个 2¹⁶ 的状态。

每次枚举一下要操作哪两个数。

x^y∉S：转移到的状态就是 S∪x^y，即 S^(1<<(x^y))。
x^y∈S：此次操作之后就会产生一对相等的 pair，我们直接在此时将它们一并消去，增加一次操作，并将 x^y 从 S 中去掉即可。

7. Codeforces 16E Fish

题目大意：有 n 条鱼，刚开始它们都自由地生活在水里。接下来每一时刻会有两条鱼相遇。所有可能的“鱼对”之间都是等概率出现这一事件的。鱼 i 和鱼 j 相遇后，i 吃掉 j 的概率为 a[i][j]。反之 j 吃掉 i 的概率为 1-a[i][j]。求每条鱼 i 活到最后的概率。N≤19。

Solution：

令 dp[S] 表示剩下集合中的鱼状态为 S 的概率。

初始化：dp[2ⁿ-1]=1（刚开始全部的鱼都存活）

对于任意 1≤i≤n，dp[2ⁱ] 为鱼 i 活到最后的概率。

按从大到小枚举状态 S（按时刻进行），设 c 为 S 中 1 的个数，则有 C(c,2) 个可能的“鱼对”。枚举第一条被选的鱼 i 以及第二条被选的鱼 j，这两条鱼相遇的概率为 1/C(c,2)。

i 吃掉 j：1/C(c,2)·dp[S]·a[i][j]→dp[S-2^j]
j 吃掉 i：1/C(c,2)·dp[S]·a[j][i]→dp[S-2ⁱ]

最后输出所有的 dp[2ⁱ] 即可。

Code：C(c,2)=c*(c-1)/2

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=20,M=(1<<18)+5;
int n,x,cnt;
double a[N][N],dp[M];
signed main(){
    scanf("%lld",&n),dp[(1<<n)-1]=1;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            scanf("%lf",&a[i][j]);
    for(int S=(1<<n)-1;S>=1;S--){    //枚举状态 
        cnt=0,x=S;
        while(x) cnt+=x&1,x>>=1;    //计算 S 中 1 的个数 
        for(int i=0;i<n;i++) if(S&(1<<i))    //枚举第一条鱼 
            for(int j=i+1;j<n;j++) if(S&(1<<j)){    //枚举第二条鱼 
                dp[S-(1<<j)]+=dp[S]*a[i][j]/(1.0*cnt*(cnt-1)/2);    //i 吃掉 j 
                dp[S-(1<<i)]+=dp[S]*a[j][i]/(1.0*cnt*(cnt-1)/2);    //j 吃掉 i 
            }
    }
    for(int i=0;i<n;i++)
        printf("%.6lf%c",dp[1<<i],i==n-1?'\n':' ');
    return 0;
}

8. Codeforces 165E Compatible Numbers

题目大意：给出一个长度为 N 的序列，我们称两个数 x,y 是兼容的，当且仅当 x&y=0。对于序列中的每个数，你需要求出任意一个序列中与它兼容的数，或是声明不存在。N≤10⁶，0<a[i]≤4·10⁶。

Solution：

暴力做法：由于数值大小可以存下。令 M 为 >=max{a(i)} 的某个 2^k-1。与序列中的某个数 x 兼容的所有数可以表示为 M xor x 的子集。做一下子集枚举，我们得到了一个 O(3^k) 的做法。（本题中，k≤22），这个做法要跑 3e10。

一点改进：令 f(S) 表示 S 的子集中是否有数出现过。F(x) 表示 x 是否在序列中出现过。

那么有：f(S)=F(S)|⋁_i∈Sf(S\i)

从小到大枚举 S, 每次计算 f 的值时就不需要枚举子集，只用枚举 S 中的元素 v 即可。还能剪枝，当 f(S) 为真时就不需要再枚举下去了。

9. Codeforces 743E Vladik and cards

题目大意：给出一个长度为 N 个序列，序列中的元素取值为 1~8。求一个最长的子序列满足：

每种取值出现在子序列中的位置连续。
每种取值出现的次数相差不超过 1。N≤1000。

10. Codeforces 599E Sandy and Nuts

题目大意：有一棵 N 个点的树， 1 号点为根节点。现在你知道 M 条信息：

某些树上的边 (u,v)
某两个点的LCA (a,b,c)

现在你需要数满足条件的树形态数。N≤13，M≤100。

posted @ 2020-07-24 20:30 maoyiting 阅读(690) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

maoyiting's blog

一个蒟蒻的博客

「算法笔记」状压 DP

一、关于状压 dp

二、预备知识

1. 位运算

2. 枚举子集

三、例题

1. TSP（旅行商问题）

2. [USACO06NOV] 玉米田 Corn Fields

3. TopCoder RainbowGraph

4. TopCoder CheeseRolling

5. AtCoder 058E Iroha and Haiku

6. AtCoder XOR Tree

7. Codeforces 16E Fish

8. Codeforces 165E Compatible Numbers

9. Codeforces 743E Vladik and cards

10. Codeforces 599E Sandy and Nuts

公告