炮兵阵地(poj1185，状态压缩的动态规划)

/*
http://poj.org/problem?id=1185
炮兵阵地
Time Limit: 2000MS Memory Limit: 65536K
Total Submissions: 16673 Accepted: 6353
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
Source


Noi 01
解析：
思路：典型的状态压缩的动态规划
   一，状态压缩：
   1.首先对当前初始可行状态进行压缩，用二进制记录，当i位置可以放炮兵部队时，
   该位置置1，否则为0。（最后结果也是计算1的最大个数）
   2.寻找每一行所有的可行性状态并记录下来
   二，动态规划
   1.动态方程：dp[i][j][k]=max{dp[i-1][k][p]}+one[s[i][j]];
   其中，dp[i][j][k]表示第i行的第j个状态，第i-1的第k状态的计量值
   s[i][j]表示第i行第j个状态值
   one[s[i][j]]则表示第i行第j个状态中1的个数
   2.剪枝判断：求解过程中还需判断当前行是否与前面两行没有冲突
   3.进一步优化结果
   
2324K 282MS C++ 2270B
*/

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include <iostream>
using namespace std;
const int maxn=110;
int one[maxn*20];
int s[maxn][maxn],sn[maxn];
int dp[maxn][70][70];
char ch[maxn];
int n,m;
int max(int a,int b)
{
    return a>b? a:b;
}
void getone()//得到每种状态下1的个数
{
    int i,j,t;
   // memset(one,0,sizeof(one));
    for(i=0;i<=(1<<10);i++)
     {
         t=0;
        for(j=0;j<=10;j++)
      {
          if(i&(1<<j))
          t++;


      }
      one[i]=t;
     }
}
int check(int i)//判断i状态与前列是否冲突
{
    if(i>1&&(i&(i>>1)))return 0;
    if(i>2&&(i&(i>>2)))return 0;
    return 1;
}
void getlawstate(int x, int p)//得到第x行的在列方向上的全部合法状态并记录
{
    for(int i=0;i<(1<<m);i++)
    {
        if(check(i)&&(i&p)==i)
        {
            sn[x]++;
            s[x][sn[x]]=i;
        }
    }
}
int main()
{
    //freopen("out.txt","w",stdout);
    int i,j,k,p,ans,t;
    getone();
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(sn,0,sizeof(sn));
        memset(s,0,sizeof(s));
        memset(dp,0,sizeof(dp));
        sn[0]=70;;//初始化第0行
        ans=0;
      for(i=1;i<=n;i++)
      {
          scanf("%s",ch);
           p=0;
          for(j=0;j<m;j++)
          {
              if(ch[j]=='P')
               p+=(1<<j);//P为当前行状态
          }
          getlawstate(i,p);
      }


      for(i=1;i<=sn[1];i++)//处理第一行
      {
       for(j=1;j<=sn[0];j++)
       {
           dp[1][i][j]=one[s[1][i]];
       }
       }
      for(i=2;i<=n;i++)
      {
          for(j=1;j<=sn[i];j++)
          {
              for(k=1;k<=sn[i-1];k++)
               { if(!(s[i][j]&s[i-1][k]))
                  {
                    t=0;
                      for(p=0;p<=sn[i-2];p++)
                    {
                       if(!(s[i][j]&s[i-2][p])&&!(s[i-1][k]&s[i-2][p]))
                       {t=max(t,dp[i-1][k][p]);
                       }
                    }

                    dp[i][j][k]=t+one[s[i][j]];
                  }

               }
          }
      }
      for(i=1;i<=sn[n];i++)
       for(j=1;j<=sn[n-1];j++)
       {
           ans=max(dp[n][i][j],ans);
       }
       printf("%d\n",ans);
    }
    return 0;


}