状态压缩DP POJ3254 && POJ1185

最新推荐文章于 2017-05-05 17:16:29 发布

姜团长

最新推荐文章于 2017-05-05 17:16:29 发布

阅读量413

点赞数

本文链接：https://blog.csdn.net/angon823/article/details/51540059

版权

总结：

之前对状压只是一知半解的，今天认真的把学了一遍。

个人发现：状压DP和基础DP的区别并不大，状压只是巧妙的利用了很多位运算，本质和普通DP没什么区别。

换句话说，状压DP只是在状态的表示上利用了2进制，在判断一些状态的时候利用了位运算。

接下里同样是要想如何状态转移方程。感觉状压熟悉之后，利用二进制并不难，难的还是如何推出题目子结构性质和转移方程怎么来。

由于状压有不少位运算，所以强烈建议，对位运算还不熟练的同学先学一下位运算。

比如 x&(x<<1) 就是判断x转化为二进制之后，有没有相邻的1；x&=(x-1)可以把x的最右边的第一个1去掉；

x^(1<<（j-1）) 可以把x的右数第j为取反等等。

简单解释一下：

1) x<<1 把x左移以为，x&(x<<1) 即将x与它左移一位之后的二进制数逐位进行 “与”操作

如果有相邻的1 1，它左移一位之后，肯定会出现 1&1的情况，那么x&(x<<1)的结果就不会是0.

2) x&=(x-1) 假设k=x-1；如果x（二进制形式）的最后一位是1，那k与x的差别就在于一个1一个是0，再逐位相与，0&1=0，所以最右边的这个1就被去掉了，如果x的最后以为是0，x-1，这个0必然要向高位借一个1，如果它最近的高位还是0，继续向前借，直到找到一个1，比如11000-1 = 10111；两者相与，11000&10011=10000。结果也是去掉了最右边的第一个1。

3) x^(1<<（j-1）) 1<<j 的结果显然是 10000... 即1后面j-1个0；异或的话可以这样理解：0异或一个东西等于它本身，1异或一个东西等于它取反；所以就把x的第右数j位取反了。

如果位运算也看不懂，几乎无从谈学状压。

一篇很好的介绍位运算的博客

两个入门的题目：

POJ 3254 Corn Fields

【题目大意】一个矩阵里有很多格子，每个格子有两种状态，能放牧和不能放牧，准许放牧用1表示，不准许用0表示，在这块牧场放牛，要求两个相邻的方格不能同时放牛，即牛与牛不能相邻。问有多少种放牛方案

【分析】先假设所有的格子都是可以放牧的，1表示这个格子放牧，0表示这个格子不放牧；所以每一行的状态就能用一个十进制数来表示，这个十进制数分解上01..这样的二进制数后就代表了这一行放或不放的状态。进一步分析：第i行的格子能放牧，要在上下左右都不相邻，左右不相邻可以先预处理出来，st[]数组保存所有没有1相邻的二进制状态；上下不相邻：对于第i行的，只需要考虑第 i-1 行对它的影响。假设 t 是第 i 行的一个合法状态，那在t状态下，所有合法的 i-1 的状态数目就是 t状态下的方案数。继续看下面

【状态表示】 dp [i] [j] 表示第 i行的状态为j 时，前 i 行的方案数

【转移方程】 dp [i] [j] = Σ ( dp[i-1] [k] ) k为i-1行的所有与i行的合法状态

最后答案就是 Σ dp[n] [t] t为第n行所有合法状态

对代码第59行的解释：

mp[i] += 1<<(m-j) ，直接从二进制的角度看这句话；mp[i]一开始等于0，二进制为0000...，+=了一个2^(m-j)次方之后，即加了一个二进制为1000..（1后面（m-j)个0）的数；就变成了0001000...，即从左数第j个位置变成了1；实际效果就是：输入11100 变成 00011.

实际判断中，判断状态x能不能放到这一行，只需要 mp[i] & x ，如果等于0就说明能放。

【代码】

<span style="font-size:12px;">/* ***********************************************
Author        :angon
************************************************ */
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
#define REP(i,k,n) for(int i=k;i<n;i++)
#define REPP(i,k,n) for(int i=k;i<=n;i++)
#define scan(d) scanf("%d",&d)
#define scann(n,m) scanf("%d%d",&n,&m)
#define mst(a,k)  memset(a,k,sizeof(a));
#define LL long long
#define maxn 1005
#define mod 100000000
/*
inline int read()
{
    int s=0;
    char ch=getchar();
    for(; ch<'0'||ch>'9'; ch=getchar());
    for(; ch>='0'&&ch<='9'; ch=getchar())s=s*10+ch-'0';
    return s;
}
inline void print(int x)
{
    if(!x)return;
    print(x/10);
    putchar(x%10+'0');
}
*/

int mp[13],st[1<<13],m,n;
int dp[13][1<<13];
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    while(~scann(n,m))
    {
        mst(mp,0);
        mst(st,0);
        mst(dp,0);
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                int x;scan(x);
                if(!x) mp[i] += 1<<(m-j);
            }
        }
        int k=0;
        for(int i=0;i<(1<<m);i++)  //预处理，把1不相邻的状态处理出来
        {
            if( (i&(i<<1)) == 0)
                st[k++]=i;
        }
        for(int i=0;i<k;i++)   //初始化第一行的状态
        {
            if( (mp[1]&st[i]) ==0)
                dp[1][i]=1;
        }
        for(int i=2;i<=n;i++)
        {
            for(int j=0;j<k;j++)   //枚举第i行的状态
            {
                if(mp[i]&st[j]) continue;
                for(int f=0;f<k;f++)   //枚举i-1行的状态
                {
                    if(mp[i-1]&st[f]) continue;
                    if( (st[j]&st[f])==0)   //如果竖着也不相邻
                        dp[i][j] += dp[i-1][f];
                }
            }
        }
        int ans=0;
        for(int i=0;i<k;i++)
            ans = (ans+dp[n][i])%mod;
        printf("%d\n",ans);
    }
    return 0;
}</span><span style="font-size:14px;">
</span>

POJ 1185 炮兵阵地

这题和上题相识；如果上题感觉不错，可以先自己想一下

【题意】中文题面，自己阅读

【分析】第 i 行的状态只受第i-1行和第i-2行的约束；发现，并不严格具有最优子结构性质，n行的格子，第 k 行达到最大的状态，并不一定是第n行最大状态的子状态。所以还是要枚举出第n行所有可能的状态在比较出最大的。

【状态表示】dp[i] [j] [k] 表示第 i 行状态为 k 第 i-1 行状态为j 是前i行的炮兵总数

【转移方程】dp[i] [k] [t] = max ( dp[i][k][t], dp[i-1][j][k] + num[t]) ; num[t]是预处理出来的状态t中1的个数

解释：第i行状态为t，i-1行状态为k时前i的炮兵数，等于前i-1行各合法状态值 + num[t] 最大的那个值

做了上一题之后我发现，二进制的利用并不是掣肘我的地方，比如判断不能有两个1的距离小于2，num数组的实现，竖直方向判断等。最优子结构的思考和状态的转移才是难点。

【代码】

/* ***********************************************
Author        :angon
************************************************ */
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
#define REP(i,k,n) for(int i=k;i<n;i++)
#define REPP(i,k,n) for(int i=k;i<=n;i++)
#define scan(d) scanf("%d",&d)
#define scann(n,m) scanf("%d%d",&n,&m)
#define mst(a,k)  memset(a,k,sizeof(a));
#define LL long long
#define maxn 1005
#define mod 100000007
/*
inline int read()
{
    int s=0;
    char ch=getchar();
    for(; ch<'0'||ch>'9'; ch=getchar());
    for(; ch>='0'&&ch<='9'; ch=getchar())s=s*10+ch-'0';
    return s;
}
inline void print(int x)
{
    if(!x)return;
    print(x/10);
    putchar(x%10+'0');
}
*/

int mp[105],st[70],num[70],dp[105][70][70],m,n;
bool ok(int x)
{
    if(x&(x<<1) || x&(x<<2))
        return false;
    return true;
}

int top;
void init()
{
    top=0;
    for(int i=0;i<(1<<m);i++)
        if(ok(i))
            st[++top]=i;
    for(int i=1;i<=top;i++)
    {
        int cnt=0;
        int t=st[i];
        while(t)
        {
            cnt++;
            t&=(t-1);
        }
        num[i]=cnt;
        if(!(mp[1]&st[i]))
            dp[1][1][i]=num[i];  //初始化第1行
    }
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    while(~scann(n,m))
    {
        char s[11];
        mst(mp,0);
        for(int i=1;i<=n;i++)
        {
            scanf("%s",s+1);
            for(int j=1;j<=m;j++)
            {
                if(s[j]=='H')
                    mp[i] += 1<<(m-j);
            }
        }
        mst(dp,-1);
        init();
        for(int i=1;i<=n;i++)
        {
            for(int t=1;t<=top;t++) //枚举第i行
            {
                if(mp[i]&st[t]) continue;
                for(int j=1;j<=top;j++)  //枚举第i-2行
                {
                    if(st[t]&st[j]) continue;
                    for(int k=1;k<=top;k++)  //枚举第i-1行
                    {
                        if(st[t]&st[k]) continue;
                        if(dp[i-1][j][k]==-1) continue;  //如果上一个状态不存在
                        dp[i][k][t]=max(dp[i][k][t],dp[i-1][j][k]+num[t]);
                    }
                }
            }
        }
        int ans=0;
        for(int k=1;k<=top;k++)
            for(int t=1;t<=top;t++)
                ans=max(ans,dp[n][k][t]);
        printf("%d\n",ans);
    }


    return 0;
}

姜团长

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
状态压缩DP POJ3254 && POJ1185

总结：之前对状压只是一知半解的，今天认真的把学了一遍。个人发现：状压DP和基础DP的区别并不大，状压只是巧妙的利用了很多位运算，本质和普通DP没什么区别。换句话说，状压DP只是在状态的表示上利用了2进制，在判断一些状态的时候利用了位运算。接下里同样是要想如何状态转移方程。感觉状压熟悉之后，利用二进制并不难，难的还是如何推出题目子结构性质和转移方程怎么来。由于状压有不少位运算，所
复制链接

扫一扫