POJ 1185 炮兵阵地（状态压缩DP）

题意：

求最大的炮兵摆放数量，并且使他们之间不相互误伤。

NOI 01 的题目。

思路：

1. 和 POJ 1038 类似，把行看成是一个整体，每一种摆放代表着一种状态，r-2, r-1 行的状态决定着 r 行的状态;

2. 本题状态比较稀疏，所以提前处理下炮兵的摆放无意是比较好的选择，由于没两个炮兵之间至少相距为 2，利用这个把每一行的炮兵可能摆放情况存放起来;

3. dp[r][i][j] 表示第 r 行的状态为 i 且第 r-1 行的状态为 j 时，所能摆放的最大炮兵数量，同时还需要枚举 r-2 行的炮兵摆放情况;

4. 最终有状态转移方程： dp[r][i][j] = max(dp[r][i][j], dp[r-1][j][k] + men[i]); 并且要求 dp[r-1][j][k] 存在，且 r 行能保证能摆放 i 状态;

5. 有了 POJ 1038 和 POJ 1185 的积累，我想以后做此类基于摆放的状态压缩 DP 应该能够有个比较清晰的思路了。

#include <iostream>
#include <algorithm>
using namespace std;

int row, col;
int state[60], cnt, men[60], mapstate[110];
bool grid[110][12];
int dp[2][60][60];

bool judge(int s) {
    if (s & (s<<1))
        return false;
    if (s & (s<<2))
        return false;
    return true;
}

int calcmen(int s) {
    int ans = 0;
    while (s) {
        ans += 1;
        s &= (s-1);
    }
    return ans;
}

void initstate(int endstate) {
    cnt = 0;
    for (int s = 0; s < endstate; s++) {
        if (judge(s)) {
            state[cnt] = s;
            men[cnt] = calcmen(s);
            cnt += 1;
        }
    }
}

int solvedp() {
    memset(dp[0], -1, sizeof(dp[0]));
    for (int i = 0; i < cnt; i++) {
        if (mapstate[0] & state[i])
            continue;
        dp[0][i][0] = men[i];
    }
    int T1 = 1, T2 = 0;
    for (int r = 1; r < row; r++) {
        T1 ^= 1, T2 ^= 1;
        memset(dp[T2], -1, sizeof(dp[0]));
        for (int i = 0; i < cnt; i++) {
            if (state[i] & mapstate[r]) 
                continue;
            for (int j = 0; j < cnt; j++) {
                if ((state[i] & state[j]) || (state[j] & mapstate[r-1]))
                    continue;
                for (int k = 0; k < cnt; k++) {
                    if ((state[i] & state[k]) || (state[k] & state[j]))
                        continue;
                    if (dp[T1][j][k] != -1)
                        dp[T2][i][j] = max(dp[T2][i][j], dp[T1][j][k]+men[i]);
                }
            }
        }
    }
    int ans = -1;
    for (int i = 0; i < cnt; i++)
        for (int j = 0; j < cnt; j++)
            ans = max(ans, dp[T2][i][j]);
    return ans;
}

int main() {
    scanf("%d%d", &row, &col);
    for (int i = 0; i < row; i++) {
        char s[20];
        scanf("%s", s);
        mapstate[i] = 0;
        for (int j = 0; j < col; j++) {
            mapstate[i] <<= 1;
            mapstate[i] |= s[j] == 'H' ? 1 : 0;
        }
    }
    initstate(1<<col);
    printf("%d\n", solvedp());
    return 0;
}