POJ1185

POJ1185 炮兵阵地

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

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

输入：第一行包含两个由空格分割开的正整数，分别表示N和M；

接下来的N行，每一行含有连续的M个字符('P'或者'H')，中间没有空格。按顺序表示地图中每一行的数据。N <= 100；M <= 10。

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

分析：

首先此题是状态压缩的DP，和另外一题很相似：

http://blog.youkuaiyun.com/u013480600/article/details/19758029

假设当前摆完了前i-1行的炮兵，那么在第i行如何摆放炮兵只与第i-1行和i-2行的炮兵如何摆放有关（当然还要考虑地形的因素，只有P的格子可以放兵，且第i行的兵不能互相攻击）。

在第i行可以放形如s=100100的炮兵，要求有3点：s与i-1行，i-2行的二进制兼容，s与初始给出的矩阵对应位合法（即s只能在初始矩阵为P的地方是1），s行中不会出现互相攻击的炮兵（后文统称这样的s规范）。

所以我们可以以整行摆放兵的二进制形式为一个状态分量写出状态转移方程：令d[r][s1][s2] = 3，表示第r行的摆放形式为s1（二进制表示）时，且第r-1行的摆放形式为s2时，且s1与s2兼容，且从第0行到第r行都是合法且规范的摆法，此时总共能摆放士兵的最大数目为3。

d[r][s1][s2] = max{d[r-1][s2][s3] +bitcount(s1) } 要求s1与s2与s3兼容。Si合法且规范是隐含条件，可以不用说了。

bitcount(s)=s的二进制形式中的1的总位数。

初值:d[0][s][0]= bitcount(s)。

由于r可以达到100，s1与s2最多有1024个，所以本题状态共有1亿个左右，不仅时间上慢而且空间上放不下，所以要优化。

其实我们仔细看发现对于一个m列的矩阵来说，每行状态最多只有m位有效的二进制位。S可以作为d的一个分量的前提是：兼容，合法，规范。S的兼容和合法要求，对于每一行来说都不一样，所以每行的二进制序列都不同。但是S的规范要求是每行都一样，所以我们就能从全0到全1的序列中直接求出所有规范的序列，存入数组v[maxn]中，然后在用序列的序号i，j，k来代替d[r][s1][s2] = max{d[r-1][s2][s3] +bitcount(s1) } 中的s1，s2和s3.

新的状态转移方程是：d[r][i][j] = max{d[r-1][j][k] + bitcount(v[i])}

新的初值是:d[0][i][0]= bitcount(v[i])。v[i]=S表示第i个规范的状态是S。对于10为的二进制序列来说，总共有1024个，但是规范的序列只有200个不到，所以我们直接把1亿个状态降低到了400万个。

程序中对于判断两个状态兼容，以及状态是否合法需要用位运算来提高效率，否则可能超时。

AC代码：516ms

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,m,cnt;
const int maxn = 202;
int d[102][maxn][maxn];
int a[102][15];
int b[102];
int v[maxn];
int num[maxn];
int bitcount(int x)
{
    //if(x==0)return 0;
    //return (x&1)+bitcount(x/2);
    return x? ( (x&1)+bitcount(x/2) ) : 0 ;
}
inline bool compat(int i,int j)//判断第i与第j个规范的状态是否兼容
{
    if(v[i]&v[j])
        return false;
    return true;
}
inline bool legal(int i,int r)//判断第i个规范状态在第r行是否合法
{
    if(v[i]&b[r])return false;
    return true;
}
int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        for(int i=0; i<n; i++)
        {
            b[i]=0;
            for(int j=0; j<m; j++)
            {
                char x;
                scanf(" %c",&x);
                if(x=='P')a[i][j]=1;
                else a[i][j]=0;
                if(!a[i][j]) b[i] |=(1<< (m-1-j) );
            }
        }
        int sum=0;
        cnt = 0;
        memset(d,0,sizeof(d));
        for(int i=0; i<(1<<m); i++)//预先求出所有的规范二进制序列，并保存下来
        {
            if( (i&(i<<2)) || (i&(i<<1)) )//同行士兵互相攻击，不规范
                continue;
            num[cnt]=bitcount(i);
            v[cnt++]=i;
        }
        for(int i=0; i<cnt; i++)if( legal(i,0) ) //单独计算第0行的d
        {
                d[0][i][0] = num[i];
                if(n==1) sum = max(sum,d[0][i][0]);
        }
        for(int i=0; i<cnt; i++)if( legal(i,1) ) //单独计算第1行的d
        {
                for(int j=0; j<cnt; j++)if( legal(j,0) )
                {
                        d[1][i][j] = max( d[1][i][j],d[0][j][0]+num[i] );
                        if(n==2) sum = max(sum,d[1][i][j]);
                }
        }
        for(int r=2; r<n; r++)
        {
            for(int i=0; i<cnt; i++)if( legal(i,r) ) //单独计算第1行的d
            {
                    for(int j=0; j<cnt; j++)if( legal(j,r-1) )
                    {
                        for(int k=0; k<cnt; k++)if( legal(k,r-2) )
                        {
                            if( compat(i,j)&&compat(j,k)&&compat(i,k) )
                            {
                                d[r][i][j] = max( d[r][i][j],d[r-1][j][k]+num[i] );
                                if(n-1==r) sum = max(sum,d[r][i][j]);
                            }
                        }
                    }
            }
        }
        printf("%d\n",sum);

    }
    return 0;
}