状压dp -- 状态压缩dp

状态压缩dp

状态压缩dp 分为两种，一种是棋盘式，也叫做基于连通性，基础题是291. 蒙德里安的梦想，另一种是集合形式的，基础题目是最短Hamilton路径。

连通性状压dp

一般讲棋盘按照行或者列分开考虑，可以先算出单行状态下的合法状态，然后下一行的合法状态受上一行的状态影响，所以可以用关系矩阵表示f(a,b)是否合法，再进行dp的转移方程。

例题

AcWing 1064. 小国王

#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;

const int maxn=10;

long long dp[maxn+2][maxn*maxn+10][1<<maxn],n,k;
vector<int> state,g[1<<maxn],cnt;

bool check(int x){
    for(int i=0;i<n;++i){
        if((x>>i&1) && (x >> i+1 &1)){
            return false;
        }
    }
    return true;
}

int count(int x){
    int t=0;
    for(int i=0;i<n;++i){
        if((x>>i&1)){
            t+=1;
        }
    }
    return t;
}

int main(void){
    cin>>n>>k;
    for(int i=0;i<1<<n;++i){
        if(check(i)){
            state.push_back(i);
            cnt.push_back(count(i));
        }
    }
    
    for(int i=0;i<state.size();++i){
        for(int j=0;j<state.size();++j){
            if((state[i]&state[j])==0 && check(state[i]|state[j])){
                g[i].push_back(j);
            }
        }
    }
    
    dp[0][0][0]=1;
    for(int i=1;i<=n+1;++i){
        for(int j=0;j<=k;++j){
            for(int a=0;a<state.size();++a){
                if(j>=cnt[a]){
                    for(int b:g[a]){
                        dp[i][j][a]+=dp[i-1][j-cnt[a]][b];
                    }
                }
            }
        }
    }
    cout<<dp[n+1][k][0]<<endl;;
}

AcWing 327. 玉米田

AcWing 292. 炮兵阵地

#include<cstdio>
#include<iostream>
#include<vector>
#include<string>
#include<cmath>
using namespace std;
const int maxn=110,maxm=1<<10;
vector<int> state,cnt;
int n,m,w[maxn];
string s;
long long dp[2][maxm][maxm],ans;

bool check(int x){
    for(int i=0;i<m;++i){
        if((x>>i&1)&&(x>>i+1&1) || (x>>i&1)&&(x>>i+2&1)){
            return false;
        }
    }
    return true;
}

int count(int x){
    int t=0;
    for(int i=0;i<m;++i){
        if(x>>i&1) t++;
    }
    return t;
}

int main(void){
    cin>>n>>m;
    for(int i=1;i<=n;++i){
        cin>>s;
        for(int j=0;j<m;++j){
            if(s[j]=='H') w[i]+=(1<<j);
        }
    }
    
    for(int i=0;i<1<<m;++i){
        if(check(i)){
            state.push_back(i);
            cnt.push_back(count(i));
        }
    }
    
    // dp[0][0][0]=0;
    for(int i=1;i<=n;++i){
        for(int j=0;j<state.size();++j){
            for(int k=0;k<state.size();++k){
                if(state[j]&state[k]) continue;
                for(int x=0;x<state.size();++x){
                    if((state[j]&state[x]) || (state[k]&state[x])) continue;
                    if(w[i]&state[j]) continue;
                    dp[i&1][j][k]=max(dp[i&1][j][k],dp[(i-1)&1][k][x]+cnt[j]);
                }
            }
        }
    }
    for(int j=0;j<state.size();++j){
        for(int k=0;k<state.size();++k){
            ans=max(ans,dp[n&1][j][k]);       
        }
    }
    cout<<ans<<endl;
}

集合覆盖

用整数的bit位表示集合

例题

最小集合覆盖和精准覆盖可以用跳舞链来解决。
跳舞链 模板

最小集合覆盖指的是Set Cover Problem，等同于以下描述：Given a set of U elements, a collections , , ...,  of subsets of U, and a number K, does there exists a collection of at most k of these sets whose union is equal to all of U?

作者：季夏37
链接：https://www.zhihu.com/question/270119452/answer/542672792

精确覆盖问题
在一个全集X中若干子集的集合为S，精确覆盖（Exactcover）是指，S的子集S*，满足X中的每一个元素在S*中恰好出现一次。在计算机科学中，精确覆盖问题指找出这样的一种覆盖，或证明其不存在。

AcWing 524. 愤怒的小鸟

#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
typedef pair<double,double> PDD;
const int maxn=20,maxm=1<<18;
const double eps=1e-7;

int T,n,m,g[maxn][maxn],dp[maxm];
PDD points[maxn];

int cmp(double x1,double x2){
    if(fabs(x1-x2)<eps) return 0;
    else if(x1<x2) return -1;
    return 1;
}

int main(void){
    cin>>T;

    while(T--){
        cin>>n>>m;
        for(int i=0;i<n;++i)
            cin>>points[i].first>>points[i].second;
        
        memset(g,0,sizeof g);
        for(int i=0;i<n;++i){
            double x1=points[i].first,y1=points[i].second;
            g[i][i]=1<<i;
            for(int j=i+1;j<n;++j){
                int t=1<<i;
                double x2=points[j].first,y2=points[j].second;
                if(!cmp(x1,x2)) continue;
                double b=(y1*x2*x2-y2*x1*x1)/(x1*x2*(x2-x1)),a=(y2-b*x2)/(x2*x2);
                // cout<<a<<" "<<b<<endl;
                if(a>=-eps) continue;
                // t|=(1<<j);
                for(int k=0;k<n;++k){
                    double tx=points[k].first,ty=points[k].second;
                    if(!cmp(a*tx*tx+b*tx,ty)) t|=(1<<k);
                }
                g[j][i]=g[i][j]=t;
            }
        }
        
        memset(dp,0x3f,sizeof dp);
        dp[0]=0;
        for(int i=0;i<(1<<n);++i){
            int t=-1;
            for(int j=0;j<n;++j){
                if(!(i>>j&1)){
                    t=j;
                    break;
                }
            }
            if(t>=0){
                for(int j=0;j<n;++j){
                    dp[i|g[t][j]]=min(dp[i|g[t][j]],dp[i]+1);
                }
            }
        }
        cout<<dp[(1<<n)-1]<<endl;
    }
}

AcWing 529. 宝藏
这题比较复杂，详细题解参照：
https://www.acwing.com/solution/content/4026/
https://www.acwing.com/solution/content/59439/

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
const int maxn=13,maxm=1<<12;
const int inf = 0x3f3f3f3f;
int g[maxn][maxn],tr[maxm],dp[maxm][maxn],n,m;

int main(void){
    int a,b,c;
    cin>>n>>m;
    memset(g,0x3f,sizeof g);
    for(int i=0;i<m;++i){
        cin>>a>>b>>c;
        --a,--b;
        g[a][b]=g[b][a]=min(g[a][b],c);
    }
    
    
    //贪心思想，打表预处理 所有状态能够扩展一层后能够得到的最大的下一层状态
    for(int i=1;i<(1<<n);++i){
        for(int j=0;j<n;++j){
            if(i>>j&1){
                for(int k=0;k<n;++k){
                    if(g[j][k]!=inf){
                        tr[i]|=1<<k;
                    }
                }
            }
        }
    }
    
    memset(dp,0x3f,sizeof dp);
    //dp处理,枚举所有的状态cur和对应的子状态pre
    for(int i=0;i<n;++i) dp[1<<i][0]=0;  //每一个节点都可能是根节点
    for(int cur=1;cur < 1<<n;++cur){
        for(int pre=(cur-1)&cur;pre;pre=(pre-1)&cur){
            int dif=cur^pre,cost=0;
            if(((tr[pre]|pre)&cur)!=cur) continue; //这里一定要 (tr[pre]|pre)&cur，要加括号，与运算先运算
            for(int i=0;i<n;++i){
                if(dif>>i&1){
                    int t=inf;
                    for(int j=0;j<n;++j){
                        if((pre>>j&1) && g[i][j]!=inf)
                            t=min(t,g[i][j]);  //找出当前连通块内能把该点加入所用的最小边的边长
                    }
                    cost+=t;
                }
            }
            for(int k=1;k<n;++k) dp[cur][k]=min(dp[cur][k],dp[pre][k-1]+cost*k);
        }
    }
    
    int ans=inf;
    for(int k=0;k<n;++k) ans=min(ans,dp[(1<<n)-1][k]);
    cout<<ans<<endl;
}