POJ 3311 Hie with the Pie (状压DP)

dp[i][j][k] i代表此层用的状态序号 j上一层用的状态序号 k是层数&1（滚动数组）

标准流程 先预处理出所有合法数据存在status里 然后独立处理第一层 然后根据前一层的max推下一层

由于最多只有60多种状态 所以这其实就是个大暴力 其实还不慢

关于为什么要反义输入地图 因为我懒得写一个地图匹配状态函数了 所以直接让地图反义匹配状态

应该算是比较简单的状压DP

然而我还是写残了WA了两次orz

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

int size, status[], num[];
int n, m, maze[], dp[][][];

inline bool ok(int a){
    return !((a & (a >> )) || (a & a >> ));
}

inline bool fit(int a, int b){
    return !(a & b);
}

void init(){
    size = ;
    memset(num, , sizeof num);
    int top =  << m;
    for(int i = ; i < top; ++i){
        if(ok(i)){
            status[size] = i;
            int tmp = i;
            while(tmp){
                if(tmp & ) num[size]++;
                tmp >>= ;
            }
            ++size;
            //cout << i << ends << num[size] << endl;
        }
    }
}

int main()
{
    while(cin >> n >> m){
        init();

        for(int i = ; i < n; ++i){
            string tmp;
            cin >> tmp;
            for(int j = ; j < m; ++j){
                maze[i] <<= ;
                //地图要反义输入
                maze[i] += (tmp[j] == 'H');
            }
            //cout << maze[i] << endl;
        }

        memset(dp, , sizeof dp);
        for(int i = ; i < size; ++i){
            if(fit(status[i], maze[])){
                dp[i][][] = num[i];
                //cout << status[i] << ends << num[i] << endl;
            }
        }
        for(int i = ; i < n; ++i){
            for(int j = ; j < size; ++j){
                if(fit(maze[i], status[j])){
                    for(int k = ; k < size; ++k){
                        if(fit(status[j], status[k])){
                            int maxx = ;
                            for(int l = ; l < size; ++l){
                                if(fit(status[j], status[l])){
                                    maxx = max(maxx, dp[k][l][!(i&)]);
                                }
                            }
                            dp[j][k][i&] = max(dp[j][k][i&], maxx + num[j]);
                        }
                    }
                }
            }
        }

        int ans = ;
        for(int i = ; i < size; ++i){
            for(int j = ; j < size; ++j){
                ans = max(ans, dp[i][j][!(n&)]);
            }
        }
        cout << ans << endl;
    }
    return ;
}