hoj 2662 经典状压dp // MyFirst 状压dp

题目链接：http://acm.hit.edu.cn/hoj/problem/view?id=2662

1.引言：用dp解决一个问题的时候很重要的一环就是状态的表示，一般来说，一个数组即可保存状态。

但是有这样的一类题目，它们具有dp问题的特性，但状态中所包含的信息过多，如果要用数组来保存状态的话需要四维以上的数组。

于是，就要通过状态压缩来保存状态，而使用状态压缩来保存状态的dp就叫做状态压缩dp。

2.状态压缩dp的特点：状态中的某一维会比较小，一般不会超过15，多了的话状态数会急剧上升而无法压缩，一般来说需要状态压缩的也就是这一维。

3.状态压缩dp常见优化：预处理是最常见的优化，尤其是在棋盘类问题上，如果我们想进一步提高效率， 我们还可以预处理出状态之间是否可以转移而不用在每一次转移中断。

 

tips：注意灵活运用位运算。

 

下面来说这道题：

题意：有一个n*m的棋盘(n，m≤80,n*m≤80)要在棋盘上放k(k≤20)个棋子，使得任意两个棋子不相邻（每个棋子最多和周围4个棋子相邻）。求合法的方案总数。

思路：对于每一行，如果把没有棋子的地方记为0，有棋子的地方记为1，那么每一行的状态都可以表示成一个2进制数，进而将其转化成10进制。

　　   那么这个问题的状态转移方程就变成了：

　　   设dp[i][j][k]表示当前到达第i行，一共使用了j个棋子，且当前行的状态在压缩之后的十进制数为k时的状态总数。那么我们也可以类似的写出状态转移方程：

　　　dp[i][i][k]=sum(dp[i-1][j-num(k)][w])   num(k)表示 k状态中棋子的个数，w表示前一行的状态。

        最基本的做法是：首先判断k状态是否合法，也就是判断在这一行中是否有2个旗子相邻，然后枚举上一行的状态w，判断w状态是否合法，

　　　　　　　　　　　然后判断k状态和w状态上下之间是否有相邻的棋子。

　　　当然这样做的时间复杂度是很高的，也就是说有很多地方可以优化，比如：判断每一行状态是否合法，可以在程序一开始判断然后保存结果，判断k状态和w状态上下之间否 　　　有相邻的棋子，可以利用位运算，if(k&w)说明上下之间有相邻的棋子。

 

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
using namespace std;
#define ll long long
using namespace std;

ll dp[82][22][1<<9];///dp[i][j][x]第i行放了j个棋子当前状态为x时的方法数
ll mark[1<<9];///十进制标记每一行的状态
ll ans,len;

ll num(ll x) ///记录状态x中1的个数
{
    ll sum=0;
    while(x)
    {
        if(x&1)sum++;
        x=x>>1;
    }
    return sum;
}

bool judge(ll x) ///判断状态x是否有相邻的棋子放在一起
{
    if(x&(x<<1)) return false;
    return true;
}

int main()
{
    //freopen("in.txt","r",stdin);
    int n,m,k;
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        memset(mark,0,sizeof(mark));
        len=0,ans=0;
        if(m>n) swap(n,m);

        for(ll i=0; i<(1<<m); i++) ///初始化第一行的放置方法数//剔除不合法状态（所谓的预处理）
        {
            if(judge(i)) ///若i状态没有相邻的棋子放在一起
            {
                dp[1][num(i)][len]=1;///则第一行状态为len(i)时1的个数为num(i)时的方法数
                mark[len++]=i;///标记状态
            }
        }

        for(ll i=2; i<=n; i++) ///第二行到第n行
        {
            for(ll j=0; j<=k; j++) ///对于放0***n个棋子
            {
                for(ll x=0; x<len; x++) ///对于0***len-1个状态（第i行）//枚举
                {
                    for(ll y=0; y<len; y++)///对于0***len-1个状态（第i-1行）//枚举
                    {
                        ll tmp=num(mark[x]);///第i行状态x中1的个数
                        if(((mark[x]&mark[y])==0) && j>=tmp) ///若上下2行没相邻的且当前的棋子数目大于此行当前状态所用的棋子
                            dp[i][j][x]+=dp[i-1][j-tmp][y];///放法数可相加
                        ///到当前行共用了j个棋子，当前行用了tmp个棋子，状态为x，到上一行共用了j-tmp个棋子，状态为y
                    }
                }
            }
        }
        for(ll i=0; i<len; i++) ///枚举状态相加
            ans+=dp[n][k][i];
        printf("%lld\n",ans);
    }
    return 0;
}

 代码：  //0.07s

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define ll long long
const int maxn=(1<<9)+5;
const int INF=0x3f3f3f3f;

ll dp[85][25][maxn];  ///第i行用j个棋子的k状态能否达到
int mark[maxn];

int judge(int x)
{
    if(x&(x<<1)) return 0;
    return 1;
}

int num(int x)
{
    int sum=0;
    while(x)
    {
        if(x&1) sum++;
        x=(x>>1);
    }
    return sum;
}

int main()
{
    //freopen("in.txt","r",stdin);
    int n,m,k;
    while(scanf("%d%d%d",&n,&m,&k)==3)
    {
        memset(dp,0,sizeof(dp));
        memset(mark,0,sizeof(mark));
        int len=0;
        if(m>n) swap(n,m);
        for(int i=0; i<(1<<m); i++)
        {
            if(judge(i))
            {
                dp[1][num(i)][len]=1;
                mark[len++]=i;
            }
        }

        for(int i=2; i<=n; i++)
        for(int j=0; j<=k; j++)
        for(int x=0; x<len; x++) ///当前行
        for(int y=0; y<len; y++) ///当前行的前一行
            if(((mark[x]&mark[y])==0) && j>=num(mark[x]) )
                dp[i][j][x]+=dp[i-1][j-num(mark[x])][y];

        ll ans=0;
        for(int i=0; i<len; i++)
            ans+=dp[n][k][i];
        printf("%lld\n",ans);
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/a-clown/p/6145462.html