状压dp大总结1 [洛谷]
前言
状态压缩是一种\(dp\)里的暴力，但是非常优秀，状态的转移，方程的转移和定义都是状压\(dp\)的难点，本人在次总结状压dp的几个题型和例题，便于自己以后理解分析状态和定义方式
状态压缩动态规划，就是我们俗称的状压\(dp\)，是利用计算机二进制的性质来描述状态的一种\(dp\)方式。
很多棋盘问题都运用到了状压，同时，状压也很经常和BFS及\(dp\)连用。
状压\(dp\)其实就是将状态压缩成2进制来保存 其特征就是看起来有点像搜索，每个格子的状态只有\(1\)或\(0\) ，是另一类非常典型的动态规划
NO.1 Corn Fields G
题目描述
农场主\(John\)新买了一块长方形的新牧场，这块牧场被划分成\(M\)行\(N\)列\((1 \le M \le 12; 1 \le N \le 12)\)，每一格都是一块正方形的土地。\(John\)打算在牧场上的某几格里种上美味的草，供他的奶牛们享用。
遗憾的是，有些土地相当贫瘠，不能用来种草。并且，奶牛们喜欢独占一块草地的感觉，于是\(John\)不会选择两块相邻的土地，也就是说，没有哪两块草地有公共边。
\(John\)想知道，如果不考虑草地的总块数，那么，一共有多少种种植方案可供他选择？（当然，把新牧场完全荒废也是一种方案）
输入格式
第一行：两个整数\(M\)和\(N\)，用空格隔开。
第\(2\)到第\(M+1\)行：每行包含\(N\)个用空格隔开的整数，描述了每块土地的状态。第\(i+1\)行描述了第\(i\)行的土地，所有整数均为\(0\)或\(1\)，是\(1\)的话，表示这块土地足够肥沃，\(0\)则表示这块土地不适合种草。
输出格式
一个整数，即牧场分配总方案数除以\(100,000,000\)的余数。
输入输出样例
输入 #1
2 3
1 1 1
0 1 0
输出 #1
9
分析
首先看到范围，\(M\)和\(N\)的范围都极小，所以根据状压\(dp\)通性，显然要通过每行或者每一列的状态来进行转移。这个题比较灵性（恶心）的就是行为\(M\)，颠覆认知……因为每个奶牛不能挨在一起，并且不种植也是一种方案，所以合法的状态肯定是要初始化一下的，即：
g[i]=(!(i<<1)&i&&!(i&(i>>1)))
这道题就是按每一行来进行状态转移，定义\(f[i][j]\)为第\(i\)行状态为\(j\)时的方案数，所以要从上一行转移而来，那么设上一行的状态为\(k\),所以就可以根据这个列出状态转移方程：
最终的答案就是把最后一行每一个状态的答案加起来即可
具体的初始化见代码注释
代码
#include<bits/stdc++.h>
using namespace std;
const int maxn = 13;
const int mod = 100000000;
int n,m;
int jl[maxn][maxn];
int f[maxn][1<<maxn];
int ste[maxn],g[1<<maxn];
int main(){
cin>>m>>n;
for(int i=1;i<=m;++i){
for(int j=1;j<=n;++j){
cin>>jl[i][j];//记录矩阵
}
}
for(int i=1;i<=m;++i){
for(int j=1;j<=n;++j){
ste[i] = (ste[i]<<1)+jl[i][j];//用二进制记录每一行的状态（有草的地方）
}
}
f[0][0] = 1;
int ms = 1<<n;//总状态
for (int i = 0; i <ms; i++)
g[i] = ((i&(i<<1))==0) && ((i&(i>>1))==0);//初始化出所有状态中的合法状态
for(int i=1;i<=m;++i){//枚举每一行
for(int j=0;j<ms;j++){//当前行状态
if(g[j] && (j & ste[i]) == j){//该状态合法且当前放牛都是在有草的地方
for(int k=0;k<ms;k++){//上一行状态
if((k&j) == 0){//上一行与这一行不能有相同的状态，也就是牛不能相邻
f[i][j] = (f[i][j]+f[i-1][k])%mod;
}
}
}
}
}
int ans = 0;
for(int i=0;i<ms;++i){//累加每一个状态的方案
ans =(ans+f[m][i])%mod;
}
cout<<ans%mod<<endl;//记得每一次都要取模
return 0;
}
NO.2 No Change G
题目
约翰到商场购物，他的钱包里有\(K(1 \le K \le 16)\)个硬币，面值的范围是\(1..100,000,000\)。
约翰想按顺序买 \(N\)个物品\((1 \le N \le 100,000)\)，第\(i\)个物品需要花费\(c_i\)块钱，\((1 \le c_i \le 10,000)\)。
在依次进行的购买\(N\)个物品的过程中，约翰可以随时停下来付款，每次付款只用一个硬币，支付购买的内容是从上一次支付后开始到现在的这些所有物品（前提是该硬币足以支付这些物品的费用）。不幸的是，商场的收银机坏了，如果约翰支付的硬币面值大于所需的费用，他不会得到任何找零。
请计算出在购买完\(N\)个物品后，约翰最多剩下多少钱。如果无法完成购买，输出\(-1\)
输入格式
-
Line \(1\): Two integers, \(K\) and \(N\).
-
Lines \(2..1+K\): Each line contains the amount of money of one of FJ's coins.
-
Lines \(2+K..1+N+K\): These \(N\) lines contain the costs of FJ's intended purchases.
输出格式
- Line 1: The maximum amount of money FJ can end up with, or -1 if FJ cannot complete all of his purchases.
输入输出样例
输入 #1
3 6
12
15
10
6
3
3
2
3
7
输出 #1
12
说明/提示
FJ has \(3\) coins of values \(12, 15\), and \(10\). He must make purchases in sequence of value \(6, 3, 3, 2, 3\), and \(7\).
FJ spends his 10-unit coin on the first two purchases, then the 15-unit coin on the remaining purchases. This leaves him with the 12-unit coin.
分析
看到友好又有标志性的硬币数的范围，当然要从硬币使用作为状态来进行状压啦！所以我们的状态就定义为\(f[i]\)表示使用硬币状态为\(i\)的时候买的最大物品数，看题意大概就是买东西需要按顺序，所以我们维护一个前缀和来优化时间效率，并且记录一下所有硬币的价值总和，方便最后判断。与上一个题相似的是，也要把使用每个硬币的状态提前初始化一下：
表示的是只用了第\(i\)个硬币的状态。并且\(g[1]=1\)然后就可以愉快的状态转移了！状态转移就是用了状态为\(i的\)硬币时买的物品，与当前用了第\(j\)个硬币买的物品去最大值。状态转移方程比较特殊，所以一会在代码中解释。
状态转移完了就需要统计答案了，每次当前状态能买的最大物品为\(n\)时就开始统计。枚举硬币，如果当前状态用了该硬币，那么就让计数\(cnt\)加上当前硬币的价值，最后\(ans\)取最大的剩余价值。需要注意的是最后剩余可以为\(0\)，所以\(ans\)应该初始化为\(-1\)，如果小于\(0\)，那么就是不可能的情况。
代码
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e6+10;
const int mm = 19;
int f[1<<mm];
int n,k;
int sum[maxn];
int g[maxn];
int tot,cnt,ans = -1;
int c[mm],a[maxn];
int main(){
cin>>k>>n;
for(int i=1;i<=k;++i){//输入硬币数并计算总价值
cin>>c[i];
tot += c[i];
}
for(int i=1;i<=n;++i){//输入每个物品价值并求出前缀和
cin>>a[i];
sum[i] = sum[i-1]+a[i];
}
g[1] = 1;
for(int i=2;i<=k;++i){//初始化每个硬币使用的状态
g[i] = g[i-1]<<1;
}
int ms = (1<<k)-1;
for(int i=0;i<=ms;++i){//枚举所有状态
for(int j=1;j<=k;++j){//枚举所有硬币
if(i & g[j]){//当前状态用了该硬币就继续运行
int te = f[i^g[j]];//te为没用该硬币时能卖的商品数。
te = upper_bound(sum+1,sum+n+1,sum[te]+c[j])-sum;//二分求使用了第j个硬币后大于的第一个商品前缀和，就可以统计出能卖多少商品。
f[i] = max(f[i],te - 1);//此时te-1为买了的商品数，取max更新
}
}
}
for(int i=0;i<=ms;++i){//再次枚举状态
if(f[i] == n){//当前状态能够买完n个物品就继续进行
cnt = 0;
for(int j=1;j<=k;++j){
if((i & g[j])){//当前状态用了第j个硬币就加上它的价值
cnt += c[j];
}
}
ans = max(ans,tot-cnt);//求出最大的剩余价值
}
}
if(ans<0)cout<<-1<<"\n";//小于0就是不可能买完
else cout<<ans<<endl;
}
NO.3 吃奶酪
题目描述
房间里放着 \(n\) 块奶酪。一只小老鼠要把它们都吃掉，问至少要跑多少距离？老鼠一开始在 \((0,0)\) 点处。
输入格式
第一行有一个整数，表示奶酪的数量 \(n\)。
第 \(2\) 到第 \((n+1)\) 行，每行两个实数，第 \((i+1)\) 行的实数分别表示第 \(i\) 块奶酪的横纵坐标 \(x_i, y_i\)。
输出格式
输出一行一个实数，表示要跑的最少距离，保留 \(2\) 位小数。
输入输出样例
输入 #1
4
1 1
1 -1
-1 1
-1 -1
输出 #1
7.41
说明/提示
数据规模与约定
对于全部的测试点，保证 \(1\le n\le 15\)，\(|x_i|,|y_i| \le 200\)，小数点后最多有 \(3\) 位数字。
提示
对于两个点 \((x_1,y_1)\)，\((x_2, y_2)\)，两点之间的距离公式为 \(\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}\)。
分析
再一次看到友好的奶酪数据范围，显然要从吃奶酪的状态入手转移，因为需要计算距离，所以我们需要把每个点之间的距离全部求出来，并且状态数组需要一维来存储上一次的位置，所以我们定义\(f[i][j]\)为吃奶酪状态\(i\)时位置为\(j\)的走的距离，也就是吃了奶酪\(j\)，从上一个状态没吃\(j\)转移来,位置为\(k\)。所以状态转移方程就是：
\(jl\)就是距离……
而我们需要预处理一些东西，每个位置之间距离是一个，原点与每个位置之间距离也要预处理，然后就是只吃了一个奶酪的走的长度预处理，然后就可以愉快的状态转移了。最后不要忘了把每个位置吃完奶酪的走的距离都扫一边。
代码
#include<bits/stdc++.h>
using namespace std;
#define db double
const int maxn = 16;
double dp[1<<maxn][maxn];
int n;
db jl[maxn][maxn];
db jlx[maxn],jly[maxn];
db pow(db x){//求乘方
return x*x;
}
db len(db xx,db yy,db x2,db y2){//求距离
return sqrt(pow(xx-x2)+pow(yy-y2));
}
int main(){
cin>>n;
for(int i=1;i<=n;++i){
cin>>jlx[i]>>jly[i];
jl[0][i] = jl[i][0] = len(0,0,jlx[i],jly[i]);//原点到每个点的距离
}
for(int i=1;i<=n;++i){//每个位置之间的距离
for(int j=1;j<=n;++j){
jl[i][j] = len(jlx[i],jly[i],jlx[j],jly[j]);
}
}
for(int i=1;i<(1<<n);++i){//初始化极大值
for(int j=1;j<=n;++j){
dp[i][j] = 999999.0;
}
}
for(int i=1;i<=n;++i){//只吃了一个奶酪的距离
dp[1<<(i-1)][i] = jl[0][i];
}
dp[0][0] = 0.0;
for(int i=0;i<(1<<n);++i){//枚举状态
for(int j=1;j<=n;++j){
if((i & (1<<(j-1))) == 0)continue; //没吃第j个就continue
for(int k=1;k<=n;++k){
if(k == j)continue;//上个位置和这个位置相同无意义，continue
if((i & (1<<(k-1))) == 0)continue;//没吃第k个也没意义，continue
dp[i][j] = min(dp[i][j],dp[i - (1<<(j-1))][k] + jl[k][j]);//状态转移
}
}
}
db ans = 99999999.0;//一定是浮点数
for(int i=1;i<=n;++i){//从头到尾扫一边
ans = min(ans,dp[(1<<n)-1][i]);
}
printf("%.2lf",ans);
}
NO.4 中国象棋
题目描述
这次小可可想解决的难题和中国象棋有关，在一个\(N\)行\(M\)列的棋盘上，让你放若干个炮（可以是\(0\)个），使得没有一个炮可以攻击到另一个炮，请问有多少种放置方法。大家肯定很清楚，在中国象棋中炮的行走方式是：一个炮攻击到另一个炮，当且仅当它们在同一行或同一列中，且它们之间恰好 有一个棋子。你也来和小可可一起锻炼一下思维吧！
输入格式
一行包含两个整数\(N\)，\(M\)，之间由一个空格隔开。
输出格式
总共的方案数，由于该值可能很大，只需给出方案数模\(9999973\)的结果。
输入输出样例
输入 #1
1 3
输出 #1
7
说明/提示
样例说明
除了\(3\)个格子里都塞满了炮以外，其它方案都是可行的，所以一共有\(2\times 2\times 2-1=7\)种方案。
数据范围
\(100\%\)的数据中\(N\)和\(M\)均不超过\(100\)
\(50\%\)的数据中\(N\)和\(M\)至少有一个数不超过\(8\)
\(30\%\)的数据中\(N\)和\(M\)均不超过\(6\)
分析
其实这个题像极了线性dp，但是思想跟状压有一丢丢相似
想必大家都知道象棋规则吧，不知道的可以去问问度娘，按照象棋的规则，一行或者一列里最多有两个炮，所以就可以根据这个来转移了。
而且每一行也最多放两个，所以就可以一一枚举进行转移，方程过多，在这里就不列举出来了，具体见代码注释吧。
\(f[i][j][k]\)表示第\(i\)行
代码
#include<bits/stdc++.h>
using namespace std;
const int maxn = 101;
const int Mod = 9999973;
int n,m;
long long f[maxn][maxn][maxn];
int Pow(int num){
return num*(num-1)/2;
}
int main(){
ios::sync_with_stdio(false);//cin/cout优化，加不加无所谓……
cin.tie(0);
cin>>n>>m;
f[0][0][0] = 1;
for(int i=0;i<n;++i){//枚举行
for(int j=0;j<=m;++j){//枚举有一个棋子的列数
for(int k=0;j+k<=m;++k){//两个棋子的列数
if(f[i][j][k]){//上一次状态不为0才转移
f[i+1][j][k]=(f[i+1][j][k]+f[i][j][k])%Mod;//不放棋子
if(m-k-j>=1)f[i+1][j+1][k]=(f[i+1][j+1][k]+f[i][j][k]*(m-k-j))%Mod;//在没放棋子的列放一个
if(j>=1)f[i+1][j-1][k+1]=(f[i+1][j-1][k+1]+f[i][j][k]*j)%Mod;//在放了一个棋子的列放一个
if(m-k-j>=2)f[i+1][j+2][k]=(f[i+1][j+2][k]+f[i][j][k]*Pow(m-k-j))%Mod;//在没放棋子的列分别放两个
if(m-k-j>=1 && j>=1)f[i+1][j][k+1]=(f[i+1][j][k+1]+f[i][j][k]*(m-k-j)*j)%Mod;//放了一个棋子和没放棋子的列各放一个
if(j>=2)f[i+1][j-2][k+2]=(f[i+1][j-2][k+2]+f[i][j][k]*Pow(j))%Mod;//在放了一个棋子的列各放一个
}
}
}
}
long long ans= 0;
for(int i=0;i<=m;++i){
for(int j=0;i+j<=m;++j){//统计答案
ans=(ans+f[n][i][j])%Mod;
}
}
cout<<ans<<"\n";
}/*最后搞个总结，每次从上个状态转移而来，如果放了一个棋子，一定要乘以剩下能放棋子列的个数，放两个当然是要乘以组合数了，这样才能求出方案数*/
