HDU 5838 Mountain（状压DP+容斥）

[题目链接]

[题意]
给定n*m(1<=n,m<=5)的网格，每个格子的高度各不相同，且在1到n*m内。
定义一个格子为山谷，当且仅当它的高度小于周围8格（界外高度看成无穷大）。
现在给定一张地图，其中’X’表示山谷，’.’表示非山谷，问满足这个地图的高度分布情况总数。

[分析]
由于n,m<=5，山谷最多只有9个，容易想到状压每个山谷“高度是否确定”

我们从小到大的确定山谷高度，设dp[i][j]表示已经使用了前i个高度，山谷高度确定情况为j的合法方案数。
对于当前的状态（i，j），我们下一个要确定的高度是i+1，那么这个i+1可以是未确定高度的山谷，也可以是未确定高度的非山谷。

如果是山谷，$dp[i+1][j|(1<<k)] \ +=\ dp[i][j] \ $
其中k是j状态下还未确定高度的山谷的id

如果是非山谷，$dp[i+1][j] \ += \ dp[i][j] *( cnt[j] + popcount(j) - i ) \ $
其中cnt[j]表示状态j中可以被确定为非山谷的格子数，popcount(j)表示状态j下有多少个已经确定了高度的山谷（即状压值二进制表示中1的个数），那么( cnt[j] + popcount(j) - i ) 就是当前状态（i，j）下，高度可以被确定为i+1的非山谷数
popcount已经有库函数，cnt[j]则只与当前状态和当前地图有关，可以在dp前预处理
在状态j下哪些地方可以被确定为非山谷？
由于我们从小到大来填，那些被标记为’.’的地方，只要周围8格内有未确定高度的山谷，就不可能在下一步内确定高度，否则，那个山谷的高度一定比他高。

最终答案便是$\ dp[n*m][(1<<C)-1] \ $ C是山谷总数

但还没完，刚才的dp只保证了标记为’X’的地方一定为山谷，却没保证标记为’.’的地方一定不为山谷。
这里容斥原理便派上用场了。我们dfs确定有可能成为山谷的’.’，标记为’X’后再计算，根据额外山谷的数量奇减偶加。

另外，dp前先check一下地图上有没有相邻的’X’，有的话答案直接为0
说这么多不如看代码，毕竟语文不及格，有些东西还是语言描述不清的。
要说明的是，分析中的转移方程是用当前状态的方案数去更新后继，而代码中我是找前驱来更新当前状态（感觉后者略微好写一些。。。

[代码]

#include <bits/stdc++.h>
using namespace std ;
const int mod = 772002 ;

int Case , n , m ;
char s[10][10] ;
int id[10][10] ;
int dp[27][1<<9] , cnt[1<<9] , ans ;
int dx[] = { 1 , 1 , 1 , 0 , 0 , -1 , -1 , -1 } ;
int dy[] = { 1 , 0 , -1 , 1 , -1 , 1 , 0 , -1 } ;

void add( int &x , int y )
{
    if( (x += y) >= mod )
        x -= mod ;
}

bool in( int x , int y ) { return x >= 0 && x < n && y >= 0 && y < m ; }

bool can( int x , int y )
{
    for( int i = 0 ; i < 8 ; i++ )
    {
        int X = x + dx[i] , Y = y + dy[i] ;
        if( in(X,Y) && s[X][Y] == 'X' )
            return 0 ;
    }
    return 1 ;
}

int cal( int C )
{
    for( int S = 0 ; S < 1<<C ; S++ )
    {
        cnt[S] = __builtin_popcount(S) ;
        for( int i = 0 ; i < n ; i++ )
            for( int j = 0 ; j < m ; j++ )
            {
                int flag = (s[i][j] == '.') ;
                for( int k = 0 ; k < 8 && flag ; k++ )
                {
                    int x = i + dx[k] , y = j + dy[k] ;
                    if( in(x,y) && s[x][y] == 'X' && ~S&(1<<id[x][y]) )
                        flag = 0 ;
                }
                cnt[S] += flag ;
            }
    }
    dp[0][0] = 1 ;
    for( int i = 1 ; i <= n*m ; i++ )
        for( int j = 0 ; j < 1<<C ; j++ )
        {
            dp[i][j] = 1LL*dp[i-1][j]*(cnt[j]-i+1)%mod ;
            for( int k = 0 ; k < C ; k++ )
                if( j&(1<<k) )
                    add(dp[i][j],dp[i-1][j^(1<<k)]) ;
        }
    return dp[n*m][(1<<C)-1] ;
}

void dfs( int cur , int valley , int extra )
{
    if( cur == n*m )
    {
        int val = cal(valley) ;
        add(ans,extra&1?mod-val:val) ;
        return ;
    }
    int x = cur/m , y = cur%m ;
    if( s[x][y] == 'X' )
    {
        id[x][y] = valley ;
        dfs(cur+1,valley+1,extra) ;
    }
    else
    {
        dfs(cur+1,valley,extra) ;
        if( !can(x,y) ) return ;
        s[x][y] = 'X' ;
        id[x][y] = valley ;
        dfs(cur+1,valley+1,extra+1) ;
        s[x][y] = '.' ;
    }
}

int main()
{
    while( ~scanf( "%d%d" , &n , &m ) )
    {
        for( int i = 0 ; i < n ; i++ )
            scanf( "%s" , s[i] ) ;
        int flag = 1 ;
        for( int i = 0 ; i < n ; i++ )
            for( int j = 0 ; j < m ; j++ )
                if( s[i][j] == 'X' && !can(i,j) )
                    flag = 0 ;
        ans = 0 ;
        if( flag ) dfs(0,0,0) ;
        printf( "Case #%d: %d\n" , ++Case , ans ) ;
    }
    return 0 ;
}