POJ 1185 状态压缩DP

炮兵阵地
Time Limit: 2000MS Memory Limit: 65536K
Total Submissions: 23343 Accepted: 9035
Description

司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成，地图的每一格可能是山地（用”H” 表示），也可能是平原（用”P”表示），如下图。在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击范围如图中黑色区域所示：

如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它能够攻击到的区域：沿横向左右各两格，沿纵向上下各两格。图上其它白色网格均攻击不到。从图上可见炮兵的攻击范围不受地形的影响。
现在，将军们规划如何部署炮兵部队，在防止误伤的前提下（保证任何两支炮兵部队之间不能互相攻击，即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内），在整个地图区域内最多能够摆放多少我军的炮兵部队。
Input

第一行包含两个由空格分割开的正整数，分别表示N和M；
接下来的N行，每一行含有连续的M个字符(‘P’或者’H’)，中间没有空格。按顺序表示地图中每一行的数据。N <= 100；M <= 10。
Output

仅一行，包含一个整数K，表示最多能摆放的炮兵部队的数量。
Sample Input

5 4
PHPP
PPHH
PPPP
PHPP
PHHP
Sample Output

6

题意：

中文题。 。

题解：

首先，每一行可以放的位置可以先都枚举出来。可以发现每一行可以放的位置最多为60种。
那么我们先给每个可以放的状态编个号。
然后第i行的状态只和第i-1行和第i-2行的状态有关。我们定义dp[i][j][k]为第i行为j号状态，第i+1行为第号状态。由第i行和第i+1行就可以确定第i+2行的状态，那么就是推出了第dp[i+1][k][k1],我们让dp[i+1][k][k1]取所有可能里的最大值。递推下去就是结果。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <stack>
#include <string>
#include <set>
#include <cmath>
#include <map>
#include <queue>
#include <bitset>
#include <sstream>
#include <vector>
#include <iomanip>
#define m0(a) memset(a,0,sizeof(a))
#define mm(a) memset(a,0x3f,sizeof(a))
#define m_1(a) memset(a,-1,sizeof(a))
#define f(i,a,b) for(i = a;i<=b;i++)
#define fi(i,a,b) for(i = a;i>=b;i--)
#define lowbit(a) ((a)&(-a))
#define FFR freopen("data.in","r",stdin)
#define FFW freopen("data.out","w",stdout)
#define INF 0x3f3f3f3f
typedef long long ll;
typedef long double ld;
const ld PI = acos(-1.0);

using namespace std;
#define SIZE ( )

struct Po
{
    int h;
    int Map;
};

int m, n;
int G[105];
char s[105];
Po SIGN[63];
int dp[105][63][63];
int cnt;
int ans;

int main()
{
    //ios_base::sync_with_stdio(false); cin.tie(0);
    scanf("%d%d", &n, &m);
    int i, j, k;
    m0(G);
    f(i, 1, n) {
        scanf("%s", s);
        f(j, 0, m - 1)
            if (s[j] == 'H')
                G[i] |= 1 << j;
    }
    cnt = 1;
    f(i, 0, (1 << m) - 1) {
        int sum = 0;
        f(j, 0, m - 1)
            if (i&(1 << j)) {
                sum++;
                if (j == m - 1) {
                }
                else if (j == m - 2) {
                    if (i&(1 << (j + 1)))
                        break;
                }
                else {
                    if ((i&(1 << (j + 1))) || (i&(1 << (j + 2))))
                        break;
                }
            }
        if (j == m) {
            SIGN[cnt].Map = i;
            SIGN[cnt++].h = sum;
        }
    }
    cnt--;

    int k1;

    m0(dp);
    if (n == 1) {
        f(i, 1, cnt)
            if (!((SIGN[i].Map)&G[1]))
                dp[0][i][1] = SIGN[i].h;
    }
    else {
        f(i, 1, cnt)
            f(j, 1, cnt)
                if ((!((SIGN[i].Map)&G[1])) && (!((SIGN[j].Map)&G[2])) && (!((SIGN[j].Map)&(SIGN[i].Map))))
                    dp[1][i][j] = SIGN[i].h + SIGN[j].h;
    }

    f(i, 1, n-2)
        f(j, 1, cnt)
            f(k, 1, cnt) 
                f(k1, 1, cnt)
                    if (!(SIGN[k1].Map&G[i+2])&&!((SIGN[k1].Map) & ((SIGN[k].Map) | (SIGN[j].Map))))
                        dp[i + 1][k][k1] = max(dp[i + 1][k][k1], dp[i][j][k] + SIGN[k1].h);

    ans = -INF;
    f(i, 1, cnt)
        f(j, 1, cnt)
            ans = max(dp[n-1][i][j], ans);
    printf("%d\n", ans);
    return 0;
}