POJ 1185 炮兵阵地 状压DP

炮兵阵地
Time Limit: 2000MS Memory Limit: 65536K
Total Submissions: 22851 Accepted: 8837
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

题意：略；

首先状态压缩，用0表示没有P点的地方，用1表示放P点的地方，两个P之间必须有两个0。所以可以预处理出来可以枚举出来的所有状态，保存为一个数，存在一个sta[]数组里面，后面的状态都用位运算来表示，然后用这个来判断就方便很多。然后存下每种状态下P的个数，也就是1的个数，状态合法就加上num[i]。

存图（maze[110]表示），把H点的地方都存为1，然后在sta[]数组里面去遍历一遍，如果存在mazep[110]&sta[i]为真，也就是与其中一种状态有冲突，就跳过这种状态，不冲突就加上对应这种状态的1的个数num[i]。

我是从0行开始输入的，从第二行开始，以每一行为最底层，可以枚举自己的状态，上一行状态和上上一行状态，合法状态大概有60种，所以每一行对应要处理60*60*60次，每一种状态都要与对应这一行的maze[i]进行与运算，确保状态合法。因为当前行只与上一行和上上一行有关，在学长的领导下，学会了使用滚动数组，开一个dp[2][65][65]来保存就是，状态为dp[now][i][j]，now为当前行数，i为上一行，j为上上行，枚举到每一行的时候就把这一行当成i（把这一行当成下一行的上一行），上一行当成j（下一行的上上一行），在枚举本行的每一种状态，上一行(j)和上上一行(k)枚举每种状态的时候进行更新。可以根据这个dp方程来理解。
dp[now][i][j] = max(dp[now][i][j],dp[now^1][j][k]+num[i]);

#include"stdio.h"
#include"iostream"
#include"algorithm"
#include"string.h"
const int maxn = 100+10;
typedef long long LL;
using namespace std;

int n,m;
int ns;                ///ns种状态
int maze[maxn];       ///存图
int num[maxn];       ///每种合法状态的1的个数
int sta[maxn];      ///存合法状态
int dp[2][70][70]; ///上一行和上上一行每种状态对应存的最多1的个数

void init()
{
    ns = 0;
    memset(num,0,sizeof num);
    for(int i = 0;i < 1<<10;i++)   ///极限情况就是m为10
    {
        int i1 = i>>1;           ///右移一位
        int i2 = i>>2;          ///右移2位
        if(!(i1&i) && !(i2&i)) ///与i进行与运算，都为0时状态合法
        {
            sta[ns] = i;
            num[ns++] = __builtin_popcount(i);  ///这个函数计算一个数里面二进制1的个数，交g++
        }
    }
}


int main(void)
{
    init();
    while(scanf("%d%d",&n,&m) != EOF)
    {
        if(n == 0 || m == 0)
        {
            printf("0\n");
            continue;
        }
        memset(maze,0,sizeof maze);
        memset(dp,0,sizeof dp);
        for(int i = 0;i < n;i++)     ///输入图，不需要单独存，用一个记录状态的数组就行了
        {
            for(int j = 0;j < m;j++)
            {
                char c;
                cin>>c;
                if(c == 'H')
                    maze[i] |= (1<<j);       ///点为'H'时，就可以存进状态
            }
        }
        int now = 0;   ///第几行状态
        int ret = 0;  ///记录最大值
        for(int i = 0;i < ns;i++)         ///预处理第0行
        {
            if(sta[i] >= (1<<m)) break;  ///开的状态，后面相同的都是这个意思
            if(maze[0]&sta[i]) continue;///maze[i]里面的状态和合法状态有冲突，就跳过
            dp[now][i][0] = num[i];
            ret = max(ret,dp[now][i][0]);
        }
        if(n == 1)
        {
            printf("%d\n",ret);
            continue;
        }
        now ^= 1;  ///滚动数组记录的行数，进行切换，1变为0，0变为1，以下皆是如此，也可以写成now = 1-now
        for(int i = 0;i < ns;i++) ///预处理第1行
        {
            if(sta[i] >= (1<<m)) break;
            if(maze[1]&sta[i]) continue;
            for(int j = 0;j < ns;j++)
            {
                if(sta[i] >= (1<<m)) break;
                if(maze[0]&sta[j]) continue;
                dp[now][i][j] = max(dp[now][i][j],dp[now^1][j][0]+num[i]);
                ret = max(ret,dp[now][i][j]);
            }
        }
        now ^= 1;
        for(int f = 2;f < n;f++)             ///枚举每行
        {
            for(int i = 0;i < ns;i++)        ///枚举这一行的当前状态
            {
                if(sta[i] >= (1<<m)) break;
                if(maze[f]&sta[i]) continue;
                for(int j = 0;j < ns;j++)    ///枚举上一行状态
                {
                    if(sta[j] >= (1<<m)) break;
                    if(maze[f-1]&sta[j] || sta[i]&sta[j]) continue;  ///上一行状态不合法，上一行与这一行能互相攻击
                    for(int k = 0;k < ns;k++)///枚举上上一行状态
                    {
                        if(sta[k] >= (1<<m)) break;
                        if(maze[f-2]&sta[k]) continue;
                        if(sta[k]&sta[i] || sta[k]&sta[j]) continue;
                        dp[now][i][j] = max(dp[now][i][j],dp[now^1][j][k]+num[i]);
                        ret = max(ret,dp[now][i][j]);
                    }
                }
            }
            now ^= 1;
        }
        printf("%d\n",ret);
    }
    return 0;
}