状态压缩dp入门集合（HDU1429 POJ3311 POJ3254 POJ1185）

例题A 胜利大逃亡续 HDU1429 （状态压缩+bfs）

思路：就是把a 到j 10把钥匙变成一个二进制串，1所在的位置代表这个钥匙已经取到。 然后bfs搜就好。

#include<bits/stdc++.h>
using namespace std;
#define Please return
#define AC 0;
#define LL long long 
const LL INF=2e18+7;
const int maxn=2e5+7;
struct node
{
    int x,y,sta,dist;
};
bool vis[25][25][1<<11];//有没有钥匙表示状态
char g[25][25];
int n,m,t;
int sx,sy;
int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
queue<node> q;
void Init()
{
    while(q.size()) q.pop();
    memset(g,0,sizeof(g));
    memset(vis,0,sizeof(vis));
}
int main()
{
    while(~scanf("%d %d %d",&n,&m,&t)){
    Init();
    bool flag=0;//是否能到出口
    for(int i=1;i<=n;i++) scanf("%s",g[i]+1);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++) 
        {
            if(g[i][j]=='@') 
            {
                g[i][j]='.';
                sx=i,sy=j;
                break;
            }
        }
    }
    q.push({sx,sy,0,0});
    vis[sx][sy][0]=true;
    node h;
    while(q.size() && !flag)
    {
        h=q.front();
        q.pop();
        for(int i=0;i<4;i++)
        {
            int X=h.x+dx[i],Y=h.y+dy[i];
            if(X>=1 && X<=n && Y>=1 && Y<=m  && g[X][Y]!='*')
            {
                if(g[X][Y]=='.' && !vis[X][Y][h.sta])
                {
                    q.push({X,Y,h.sta,h.dist+1});//普通格子，状态不变，权值+1
                    vis[X][Y][h.sta]=true;
                }
                else if(g[X][Y]=='^')
                {
                    if(h.dist+1>=t) cout<<-1<<'\n';
                    else cout<<h.dist+1<<'\n';
                    flag=1;
                    break;
                }
                else if('a'<=g[X][Y] && g[X][Y]<='j')
                {
                    int id=1<<(g[X][Y]-'a');
                    if(vis[X][Y][h.sta|id]) continue;//第二次搜到这个顶点的这个状态 ，肯定不是最短路了
                    q.push({X,Y,h.sta|id,h.dist+1});
                    vis[X][Y][h.sta|id]=true;
                }
                else if('A'<=g[X][Y] && g[X][Y]<='J')
                {
                    int id=1<<(g[X][Y]-'A');
                    if(vis[X][Y][h.sta|id] || !(h.sta&id)) continue;//分别对应 已经搜过 / 没带钥匙 两种不能走的情况
                    q.push({X,Y,h.sta|id,h.dist+1});
                    vis[X][Y][h.sta|id]=true;
                }
            }
        }
    }
    if(!flag) cout<<-1<<'\n';
    }
    Please AC
}

POJ 3311 （最短路+状压dp）

题意：给定一个矩阵，表示点与点之间的距离，要求从0出发，经过1~n至少一次，回到0，最短路程是多少 。 （1<=n<=10）

思路：n的范围暗示了状压dp ，这题给出邻接矩阵，我们得先求出各个点之间的最短路 。把是否经过一个点用二进制1/0表示， 然后用dp[i][k] 表示当前状态为k 停在i顶点的最短路程 。

PS:当然这题直接bfs也行

dp[0][0]=0; 注意这里外层循环必须是状态，不能是出发点，否则会莫名wa

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<stdlib.h>
#include<string.h>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<math.h>
#include<set>
#include<deque>
using namespace std;
#define Please return
#define AC 0;
#define LL long long 
const int INF=2e9+7;
const int maxn=2e5+7;
int dp[15][1<<12];//到达i顶点  状态为j时最短时间 状态表示顶点是否走过  10111  表示1 2 3 5走过
//最终dp[i][(1<<n)-1] 表示所有的点都走过的状态
int g[15][15];
int n;
void Init()
{
    for(int i=0;i<=n;i++)
    {
        for(int j=0;j<(1<<n);j++) dp[i][j]=INF;
    }
}
void floyd()
{
    for(int i=0;i<=n;i++)
    {
        for(int j=0;j<=n;j++)
        {
            for(int k=0;k<=n;k++) g[j][k]=min(g[j][i]+g[i][k],g[j][k]);
        }
    }
}
int main()
{
    while(~scanf("%d",&n) && n)
    {
        Init();
        for(int i=0;i<=n;i++)
        {
            for(int j=0;j<=n;j++) scanf("%d",&g[i][j]);
        }
        floyd();//求出各顶点的最短路
        dp[0][0]=0;
        for(int k=0;k<(1<<n);k++)//枚举状态
        {
            for(int i=0;i<=n;i++)//出发点
            {
                if(dp[i][k]!=INF)
                {
                    for(int j=1;j<=n;j++)//i出发 到达j ，
                    //由于是最短路，所以j不会为0
                    {
                        int sta=k | (1<<(j-1)); 
                        dp[j][sta]=min(dp[j][sta],dp[i][k]+g[i][j]);
                    }
                }
            }
        }
        int ans=dp[1][(1<<n)-1]+g[1][0];
        for(int i=2;i<=n;i++)//1~n某点回到0点
        {
            ans=min(ans,dp[i][(1<<n)-1]+g[i][0]);
        }
        cout<<ans<<'\n';
    }
    Please AC
}

E - Corn Fields POJ - 3254

题意：给定一块草坪最大 12*12
有些格子不能放牛，放牛的草坪不能有边相接 问让你选若干草坪放牛，方式一共有多少种 （选0个草坪算一种）

思路：用是否选择这块草坪作为2进制状态。
用dp[i][sta]代表前i行中，第i行状态为sta的总方案数，
最终答案就是Σdp[n][sta]

dp[i][sta]=Σdp[i-1][pre_sta] 转移过程就暴力枚举，时间复杂度10*2^24
也就是第i行，选择sta这个状态时，能继承的第i-1行的哪些状态的方案，加起来。

当然 sta 必须合法，也就是不能有1相邻，不能在无法种草的地方有1。

pre_sta和sta之间也必须合法,不能在同一位置同时有1，也就是sta&pre_sta==0。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<stdlib.h>
#include<string.h>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<math.h>
#include<set>
using namespace std;
#define Please return
#define AC 0;
#define LL long long 
const LL INF=2e18+7;
const int maxn=2e5+7;
const int mod=1e9;
//思路：状压dp  dp[i][sta] 考虑前i行，第i行状态为sta时的方案数 
int g[14][14];
int ok[14];//标记每行的能否种草状态 不能种草的状态为1
int n,m;
int dp[14][1<<12];
//dp[i][sta]+=dp[i-1][pre_sta] 枚举sta  枚举pre_sta  时间复杂度2^24*10
void Init()
{
    memset(dp,0,sizeof(dp));
    dp[0][0]=1;
    memset(ok,0,sizeof(ok));
}
bool check(int x,int K)
{
    if(K & ok[x]) return false;//某个1所在的地方种了草
    if(K & (K<<1)) return false;//有相邻的1
    return true;
}
int main()
{
    while(~scanf("%d %d",&n,&m))
    {    
        Init();
        LL res=0;
        for(int i=1;i<=n;i++)
        {
            int sta=0;
            for(int j=1;j<=m;j++)
            {
                scanf("%d",&g[i][j]);
                if(!g[i][j])
                {
                    sta|=1<<(m-j);
                }
            }
            ok[i]=sta;//不能种草的位置标记为1
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<(1<<m);j++)
            {
                if(check(i,j))//当前行 这个状态合法
                {
                    for(int k=0;k<(1<<m);k++)
                    {
                        if(!(j & k))//没有牛相连
                        {
                            dp[i][j]+=dp[i-1][k];
                        }
                    }
                    if(i==n) res=(res+dp[i][j]%mod)%mod;
                }
            }
        }
        cout<<res<<'\n';
    }
    Please AC
}

I - 炮兵阵地 POJ - 1185

类似放牧种草那题的升级版 。

但是第i行的状态受i-1 i-2两行的影响。

设dp[i][sta][pre]为前i行,第i行状态为sta，第i-1行的状态为pre情况下的最优解。
最终答案就是枚举sta , pre, 求出max(dp[i][sta][pre]) 。

注意 ，这题的dp维数有三维，dp数组直接暴力设状态的话肯定mle。

我们先预处理得到所有的 不包含11 101 111的状态，也就是不会相互攻击到的的状态。 放进数组staus[]中

求出每个合法状态里面的1的个数，放进数组num[]中

把每行的H变成1，P变成0，得到的二进制数放进notok[]数组中

dp边界就是第一行

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<stdlib.h>
#include<string.h>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<math.h>
#include<set>
using namespace std;
#define Please return
#define AC 0;
#define LL long long 
const LL INF=2e18+7;
const int maxn=2e5+7;
const int mod=1e9;
int n,m;
char g[105][15];
int notok[105];
int dp[105][100][100];
//前i行 第i行状态为j  第i-1行状态为k 最大解
//dp[i][sta][pre]=max(dp[i-1][pre][ppre])+num[sta] 枚举当前行  当前行的状态  上一行的状态 上上行的状态 (1e2)^4
int staus[105];//所有的合法的状态
int num[105];//每个状态对应的1的个数
int cnt=0;//合法状态数目 从1开始 cnt个
void Init()
{
    memset(notok,0,sizeof(notok));
    memset(dp,0,sizeof(dp));
    memset(staus,0,sizeof(staus));
    memset(num,0,sizeof(num));
    cnt=0;
}
int main()
{
    while(~scanf("%d %d",&n,&m))
    {    
        Init();
        for(int i=1;i<=n;i++)
        {
            int sta=0;
            scanf("%s",g[i]+1);
            for(int j=1;j<=m;j++)
            {
                if(g[i][j]=='H')
                {
                    sta|=1<<(m-j);//不能放置的位置
                }
            }
            notok[i]=sta;
        }
        for(int i=0;i<(1<<m);i++)
        {
            if( (i & (i<<1)) || (i & (i<<2))) continue;
            int k=i,num_1=0;
            while(k)
            {
                /*if(k&1) num_1++;
                k>>=1;*/
                k=k&(k-1);
                num_1++;//更快求出一个数二进制状态下1的个数
            }
            num[++cnt]=num_1;
            staus[cnt]=i;//0是第一个状态
        }
        for(int i=1;i<=cnt;i++)
        {
            if(staus[i]&notok[1]) continue;
            dp[1][i][1]=num[i];
        }
        for(int i=2;i<=n;i++)
        {
            for(int j=1;j<=cnt;j++)//枚举当前状态
            {
                if(staus[j] & notok[i]) continue;//高地放置的情况
                for(int k=1;k<=cnt;k++)//i-1行的状态
                {
                    if(staus[k] & staus[j]) continue;
                    if(staus[k] & notok[i-1]) continue;//高地放置
                    for(int l=1;l<=cnt;l++)
                    {
                        if(staus[k] & staus[l]) continue;
                        if(staus[j] & staus[l]) continue;
                        if(staus[l] & notok[i-2]) continue;//高地放置
                        dp[i][j][k]=max(dp[i][j][k],dp[i-1][k][l]+num[j]);
                    }
                }
            }
        }
        int ans=0;
        for(int i=1;i<=cnt;i++)
        {
            for(int j=1;j<=cnt;j++) ans=max(ans,dp[n][i][j]);
        }
        cout<<ans<<'\n';
    }
    Please AC
}

小小总结一波：状压dp关键点在于把dp的某个状态维度恰当地变成一串二进制数，当然这肯定要求这一维状态数不能过多。

转移过程会涉及位运算