Mondriaan's Dream POJ - 2411（轮廓线dp 状压dp）

Squares and rectangles fascinated the famous Dutch painter Piet Mondriaan. One night, after producing the drawings in his ‘toilet series’ (where he had to use his toilet paper to draw on, for all of his paper was filled with squares and rectangles), he dreamt of filling a large rectangle with small rectangles of width 2 and height 1 in varying ways.

Expert as he was in this material, he saw at a glance that he’ll need a computer to calculate the number of ways to fill the large rectangle whose dimensions were integer values, as well. Help him, so that his dream won’t turn into a nightmare!
Input
The input contains several test cases. Each test case is made up of two integer numbers: the height h and the width w of the large rectangle. Input is terminated by h=w=0. Otherwise, 1<=h,w<=11.
Output
For each test case, output the number of different ways the given rectangle can be filled with small rectangles of size 2 times 1. Assume the given large rectangle is oriented, i.e. count symmetrical tilings multiple times.
Sample Input
1 2
1 3
1 4
2 2
2 3
2 4
2 11
4 11
0 0
Sample Output
1
0
1
2
3
5
144
51205

题意： 1x2的方块覆盖矩形，多少种方案。

思路：
状压解法：方块横放表示00，纵放表示10。那么相邻两行状态合法的条件就是，i & j = 0, i | j得到的状态中连续0必须为偶数。之后就按照行来常规dp了。
轮廓线dp：每一个格子都由m位二进制状态代表。关联的状态为包括这个格子的之前m+1个格子的状态。

1代表覆盖，0代表没有覆盖。
不放意味着当前格子为0，首位格子为1.
竖放意味着当前和首位均为1
横放首位得为1，当前位和当前位之前的格子为1。

轮廓线dp

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long ll;
int n,m,cur;
ll f[2][1 << 15];

void update(int a,int b)
{
    if(b & (1 << m))f[cur][b ^ (1 << m)] += f[cur ^ 1][a];
}

int main()
{
    while(~scanf("%d %d",&n,&m) && (n || m))
    {
        if(n > m)swap(n,m);
        memset(f,0,sizeof(f));
        cur = 0;
        f[cur][(1 << m) - 1] = 1;
        
        for(int i = 0;i < n;i++)
        {
            for(int j = 0;j < m;j++)
            {
                cur ^= 1;
                memset(f[cur],0,sizeof(f[cur]));
                for(int s = 0;s < (1 << m) ;s++)
                {
                    update(s,s << 1);//不放
                    if(i && !(s&(1 << (m - 1))))update(s,(s << 1) ^ (1 << m) ^ 1);//往上放
                    if(j && (!(s & 1)))update(s,(s<<1) ^ 3);
                }
            }
        }
        printf("%lld\n",f[cur][(1 << m) - 1]);
    }
    
    return 0;
}

状压dp

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;

typedef long long ll;
int n,m;
ll f[15][1 << 15];
ll is[1 << 15];

int main()
{
    while(~scanf("%d%d",&n,&m) && n)
    {
        for(int i = 0;i < (1 << m);i++)
        {
            int has_odd = 0,cnt = 0;
            for(int j = 0;j < m;j++)
            {
                if(i & (1 << j))
                {
                    if(cnt)break;
                }
                else
                    cnt ^= 1;
            }
            is[i] = has_odd | cnt ? 0 : 1;
        }
        
        f[0][0] = 1;
        for(int i = 1;i <= n;i++)
        {
            for(int j = 0;j < (1 << m);j++)
            {
                f[i][j] = 0;
                for(int k = 0;k < (1 << m);k++)
                {
                    if((j & k) == 0 && (is[j | k]))
                    {
                        f[i][j] += f[i - 1][k];
                    }
                }
            }
        }
        printf("%lld\n",f[n][0]);
    }
    return 0;
}