hdu 5766 Filling 轮廓线dp burnside

Filling 

题目连接：

http://acm.hdu.edu.cn/showproblem.php?pid=5766

Description

The board is a rectangle of unit cells with N rows and N columns. At first, cells are empty. ?? has infinite blocks with the size of 2*2. ?? can put blocks in the board as long as no two blocks overlap. ?? wants to know how many different ways to fill the board, not necessary full. Two ways are consider same if they are same by rotating.

Input

The first line of the input gives the number of test cases T; T test cases follow.
Each test case consists of one integers N, as described on the description above.

limits
T <= 20
1 <= N <= 20

Output

For each test case, output one line containing “Case #x: y” (without quotes) , where x is the test case number (starting from 1) and y is the answer you get for that case, since the answer may be too large, you should output the it modulo 1000000007 (1e9 + 7).

 

Sample Input

5
1
2
3
4
5

Sample Output

Case #1: 1
Case #2: 2
Case #3: 2
Case #4: 12
Case #5: 84

hint

In forth case, we have 12 different ways.(0 denotes unfilled,1 denoted filled)
0000   1100   0110   0000   1111   0000   1100   1100   1100   1111   1111   1111
0000   1100   0110   0110   1111   1111   1111   1100   1100   1111   1111   1111
0000   0000   0000   0110   0000   1111   0011   0011   0110   1100   0110   1111
0000   0000   0000   0000   0000   0000   0000   0011   0110   1100   0110   1111

题意：

n*n的格子里放2*2的块，相互不重叠，问旋转同构下的方案数

题解：

旋转同构很好判，根据bunrside引理，就是转0，90，180，270度下旋转不变的情况数求和除4。转90和转270是一样的，所以一共只有三种情况。

转0度：

　　就是一个n*n的格子，2*2的块不能放出限制，直接画出mask，轮廓线dp

　　以4*4为例，它的边界mask为：

　　111111

　　100001

　　100001

　　100001

　　100001

　　111111

转90度：

　　转90度的情况最为复杂，总的来说就是枚举中间十字放2*2的情况，再对一个角落跑轮廓线dp。以方便考虑，我们考虑右下角的1/4块

　　n为奇数时，中间的m[n/2+1][n/2+1]不能放，边界左上角不会冲突，那么直接枚举2^n/2的边界放置情况，顺便判是否两个两个在一起。

　　n为偶数时，如果有一个放在边界左上角，必然冲突不能旋转同构。所有的合法情况是不管那最左边的那个，直接枚举2^n/2的边界放置情况，顺便判edge>>1是否两个两个在一起。

　　0000　　0000

　　0011　　0110

　　0011　　0110

　　0000　　0000

转180度

　　我考虑下半面

　　n为奇数时，中间的m[n/2+1][n/2+1]不能放，注意边界左边低一格

　　n为偶数时，有两种情况，枚举边界的时候要注意，1是edge合法，2是edge>>1合法

　　11111 　　  　0000　　0000

　　11100　　　　0110　　0011

　　00000　　　　0110　　0011

　　00000　　　　0000　　0000

写轮廓线的时候有个地方要注意mask[X+1][t]

void dfs(LL st,int t,LL dp)　　　　//st之前状态,code上行状态，mask边界，当前在(X,t)
{
    if(t>=n+1)return;
    if(!mask[X][t]&&!mask[X][t+1]&&!code[t]&&!code[t+1]&&!mask[X+1][t])
    {
        hm[f^1].push(st^(1<<t)^(1<<(t+1)),dp);
        dfs(st^(1<<t)^(1<<(t+1)),t+2,dp);
    }
    dfs(st,t+1,dp);
}

最后写完打表就好了

第一次写轮廓线，写了很久，各种坑。。

代码

//#include <bits/stdc++.h>
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <bitset>
#include <string>
#include <time.h>
using namespace std;
long double esp=1e-11;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()
#define cle(a) while(!a.empty())a.pop()
#define mem(p,c) memset(p,c,sizeof(p))
#define mp(A, B) make_pair(A, B)
#define pb push_back
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
typedef long long int LL;
const long double PI = acos((long double)-1);
const LL INF=0x3f3f3f3fll;
const int MOD =1000000007ll;
const int maxn=11000;

LL inv4=250000002ll;
const int MAXD=15;
const int HASH=30007;
const int STATE=1<<20;
struct HASHMAP
{
    int head[HASH],next[STATE],sz;
    LL state[STATE];
    LL dp[STATE];
    void init()
    {
        sz=0;
        memset(head,-1,sizeof(head));
    }
    void push(LL st,LL ans)
    {
        int i;
        int h=st%HASH;
        for(i=head[h];i!=-1;i=next[i])//这里要注意是next
          if(state[i]==st)
          {
              dp[i]=(dp[i]+ans)%MOD;
              //dp[i]+=ans;
              return;
          }
        state[sz]=st;
        dp[sz]=ans;
        next[sz]=head[h];
        head[h]=sz++;
    }
}hm[2];
int n;
bool mask[22][22];
int f,code[22],X;
void decode(LL state)
{
    for(int x=1;x<=n;x++)
        code[x]=((state>>x)&1);
    code[0]=code[n+1]=1;
}
void dfs(LL st,int t,LL dp)
{
    if(t>=n+1)return;
    if(!mask[X][t]&&!mask[X][t+1]&&!code[t]&&!code[t+1]&&!mask[X+1][t])
    {
        hm[f^1].push(st^(1<<t)^(1<<(t+1)),dp);
        dfs(st^(1<<t)^(1<<(t+1)),t+2,dp);
    }
    dfs(st,t+1,dp);
}
bool check(int s,int l)
{
    for(int x=0;x<l;x++)
        if((s>>x)&1)
        {
            if((s>>(x+1))&1)
            {
                x++;
                continue;
            }
            else
                return 0;
        }
    return 1;
}
LL lkx(int a,int b,int n)
{
    hm[0].init();
    hm[0].push(0,1);
    f=0;
    for(int x=a;x<=n;x++)
    {
        X=x;
        hm[f^1].init();
        for(int k=0;k<hm[f].sz;k++)
        {
            decode(hm[f].state[k]);
            LL dp=hm[f].dp[k];
            hm[f^1].push(0,dp);
            dfs(0,b,dp);
        }
        f^=1;
    }
    for(int k=0;k<hm[f].sz;k++)
        if(hm[f].state[k]==0)
            return hm[f].dp[k]%MOD;
}
int main()
{
    //freopen("in.txt", "r", stdin);
    //freopen("inlay.in", "r", stdin);
    //freopen("out.txt", "w", stdout);      //%I64d
    //vector<int>::iterator iter;
    //memset(m,0,sizeof(int));
    //for(int x=1;x<=n;x++)
    //for(int y=1;y<=n;y++)
    //scanf("%d",&a);
    //printf("%d\n",ans);
    for(n=1;n<=20;n++)
    {
        //***********0
        mem(mask,0);
        for(int x=0;x<=n+1;x++)
        {
            if(x==0||x==n+1)
                for(int y=0;y<=n+1;y++)
                    mask[x][y]=1;
            else
                mask[x][0]=mask[x][n+1]=1;
        }
        LL ans=0;
        ans+=lkx(1,1,n);
        //printf("0 %d %lld\n",n,ans);    ans=0;
        //***********90 270
        for(int s=0;s<(1<<(n/2));s++)
        {
            int odd=n&1;
            if(odd&&!check(s,n/2))continue;
            if(!odd&&!check(s>>1,n/2-1))continue;
            mem(mask,0);
            for(int x=n/2;x<=n+1;x++)
            {
                if(x==n/2||x==n+1)
                    for(int y=0;y<=n+1;y++)
                        mask[x][y]=1;
                else
                    mask[x][n/2+odd]=mask[x][n+1]=1;
            }
            for(int x=n/2+1+odd;x<=n;x++)
                mask[x][n/2+1+odd]=mask[n/2+1][x]=(s>>(x-n/2-1-odd))&1;
            ans+=lkx(n/2+1,n/2+1+odd,n)*2;
        }
        //printf("1 %d %lld\n",n,ans);    ans=0;
        //***********180
        for(int s=0;s<(1<<(n/2));s++)
        {
            int odd=n&1;
            if(odd&&!check(s,n/2))continue;
            if(!odd&&!(check(s,n/2)||check(s>>1,n/2-1)))continue;
            mem(mask,0);
            for(int x=n/2;x<=n+1;x++)
            {
                if(x==n/2||x==n+1)
                    for(int y=0;y<=n+1;y++)
                        mask[x][y]=1;
                else
                    mask[x][0]=mask[x][n+1]=1;
            }
            if(odd)
            for(int x=1;x<=n/2+1;x++)
                mask[n/2+1][x]=1;
            for(int x=n/2+1+odd;x<=n;x++)
                mask[n/2+1+odd][n+1-x]=mask[n/2+1][x]=(s>>(x-n/2-1-odd))&1;
            ans+=lkx(n/2+1,1,n);
        }
        //printf("3 %d %lld\n",n,ans);
        printf(",%I64d",ans%MOD*inv4%MOD);
    }

    return 0;
}

值为

LL ans[25]={1,1,2,2,12,84,1641,50788,3183091,338785462,429880385,948920428,392930107,842384602,
36468923,534250025,693507546,311288183,320259213,232751393,866290697};



2016-07-31