SGU131 Hardwood floor DP+状压

最新推荐文章于 2015-01-14 14:56:13 发布

原创最新推荐文章于 2015-01-14 14:56:13 发布 · 1k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

DP 专栏收录该内容

52 篇文章

订阅专栏

本文介绍了一个使用状态压缩动态规划方法解决硬木地板拼装问题的算法。问题的目标是在一个M×N的矩形宴会厅内，利用特定形状的地砖（2×1的矩形和2×2中缺失一个1×1正方形的L型角砖）铺满整个地面，并计算出所有可能的铺设方式的数量。文章提供了详细的代码实现和注释。

用L型和1*2型的地砖铺满n*m的地板统计有多少种方案，用状态压缩解决

一共有六种状态转移，详见代码注释。

131. Hardwood floor

time limit per test: 0.5 sec.
memory limit per test: 4096 KB

The banquet hall of Computer Scientists' Palace has a rectangular form of the size M x N (1<=M<=9, 1<=N<=9). It is necessary to lay hardwood floors in the hall. There are wood pieces of two forms:
1) rectangles (2x1)
2) corners (squares 2x2 without one 1x1 square)
You have to determine X - the number of ways to cover the banquet hall.
Remarks. The number of pieces is large enough. It is not allowed to leave empty places, or to cover any part of a surface twice, or to saw pieces.

Input

The first line contains natural number M. The second line contains a natural number N.

Output

First line should contain the number X, or 0 if there are no solutions.

Sample Input

2 3

Sample Output

#include<iostream>
#include<cstring>
#include<cstdio >
#include<string>
#include<algorithm>

using namespace std;

typedef long long LL;

int m,n;
LL f[1<<11],dp[1<<11];

//检查状态s的第i位是否能够填放
bool jud(int s,int i)
{
    return (s&(1<<i))==0;
}

void dfs(int pre,int cur,LL cnt)
{
    if(pre==(1<<m)-1) //第i行已满，cur为对应的i+1行状态
    {
        dp[cur]+=cnt;
        return;
    }
    else
    {
        for(int i=0;i<m;i++)
        {
            if(!jud(pre,i)) continue;
            //##
            //..
            if(i+1<m && jud(pre,i+1))
            {
                int state=pre|(1<<(i+1));
                state|=(1<<i);
                dfs(state,cur,cnt);
            }
            //#.
            //#.
            if(jud(cur,i))
            {
                int state1=pre|(1<<i);
                int state2=cur|(1<<i);
                dfs(state1,state2,cnt);
            }
            //#.
            //##
            if(i+1<m&&jud(cur,i)&&jud(cur,i+1))
            {
                int state1=pre|(1<<i);
                int state2=cur|(1<<i);
                state2|=(1<<(i+1));
                dfs(state1,state2,cnt);
            }
            //.#
            //##
            if(i>=1&&jud(cur,i)&&jud(cur,i-1))
            {
                int state1=pre|(1<<(i));
                int state2=cur|(1<<i);
                state2=state2|(1<<(i-1));
                dfs(state1,state2,cnt);
            }
            //##
            //#.
            if(i+1<m&&jud(pre,i+1)&&jud(cur,i))
            {
                int state1=pre|(1<<i);
                state1=state1|(1<<(i+1));
                int state2=cur|(1<<i);
                dfs(state1,state2,cnt);
            }
            //##
            //.#
            if(i+1<m&&jud(pre,i+1)&&jud(cur,i+1))
            {
                int state1=pre|(1<<i);
                state1=state1|(1<<(i+1));
                int state2=cur|(1<<(i+1));
                dfs(state1,state2,cnt);
            }
            break;// 防止重复计数，先放后方没有区别，所以每次DFS只转移一块地板的状态
        }
    }
}

int main()
{
    cin>>n>>m;
    int tot=(1<<m);
    f[tot-1]=1;
    for(int i=0;i<=n;i++) //表示第i行已经满，求出对应下一行各种状态及方案
    {
        for(int s=0;s<tot;s++) //枚举i行初始状态，求出相应i+1行的状态
            if(f[s]) dfs(s,0,f[s]); //dfs(i行初始状态i’，i’对应的i+1行状态，转移的方案数)
        for(int s=0;s<tot;s++) //滚动数组的作用。
        {
            f[s]=dp[s];
            dp[s]=0;
        }
    }
    cout<<f[0]<<endl; //第n行铺满，第n+1行0；
    return 0;
}