状态压缩DP poj—1185 炮兵阵地 和 cf 111 Problem C Petya and Spiders （经典）

之所以把这两题放在一起，是这两题的思路是一样的，这一类的状态与行的关系比较紧密；

poj-1185 炮兵阵地

题目链接： http://poj.org/problem?id=1185

题意： 中文题目，无需多说了；

分析： 对于当前行的状态S，S的二进制中的1表示放置炮弹，那么很显然S中不能有两个1的距离小于3了；

借此可以踢出很多不用的状态； 那么对于当前状态S受那些行的状态影响呢？ 通过题意我们知道当前行状态S

只和上两行的状态有关。那么设计状态时是否就要记录前两行的状态呢？其实是不用的，因为状态转移方向是向下的。

可以至上而下dp就可以避免这个问题了；只需记录上一行和当前行的状态就行了；

dp[i][j][t] = max(dp[i][j][t], dp[i-1][k][j]+num[t] );

dp[i][j][t] 表示第i行的状态是t和上一行的状态j；

#include <iostream> 
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace :: std;

const int maxn = 108;
const int maxm = 11;
int n, m;
int s[100], cur[maxn];
int num[100];
#define max( a, b ) (a)> (b)? (a): (b)

bool ok( int x ) { // 预处理出每一行 可能 合法的状态；
    return (  (x&(x<<2)) || (x&(x<<1))  ) == 0? 1:0;
};

int dp[maxn][70][70];

bool in( int x, int y ) { //判断当前状态是否合法，并不是所有格子都可以放炮弹的
    for ( int i=0; i<m; ++i) if( (x&(1<<i) ) ) {
         if( !(y&(1<<i) ) ) return 0;
    }
    return true;
};

void solve(){
    memset (dp, -1, sizeof dp);
    int ans = 0;
    memset (dp[1], 0, sizeof 0);
    for ( int i=1; i<=s[0]; ++i ) if(in(s[i], cur[1]) ) {
        dp[1][1][i] = num[i];
        if(ans < num[i]) ans = num[i];
    }
    for ( int i=2; i<=n; ++i ) {
        for ( int t=1; t<=s[0]; ++t )
        {
            if(!in(s[t], cur[i]) ) continue;
            for ( int j=1; j<=s[0]; ++j )
            {
                if( s[t]&s[j] )  continue;
                for ( int k=1; k<=s[0]; ++k ){
                     if ( s[t]&s[k] ) continue;
                     if (dp[i-1][k][j] == -1 ) continue;
                     if(dp[i][j][t] == -1) dp[i][j][t] = dp[i-1][k][j]+num[t];
                     else
                     dp[i][j][t] = max( dp[i][j][t], dp[i-1][k][j]+num[t] );
                }
                if(dp[i][j][t] > ans) ans= dp[i][j][t];
            }
        }
    }
    printf ("%d\n", ans);
};


int main(  ) {
    char str[102][12];
    while ( ~scanf ("%d%d", &n, &m) ) {
          for ( int i=0; i<n; ++i )
             scanf ("%s", str[i]);
          for ( int i=0; i<n; ++i ){
              cur[i+1] = 0;
              for ( int j=0; j<m; ++j ) if(str[i][j] == 'P')
              {
                  cur[i+1] += (1<<(m-1-j) );
              }
          }
          int M = 1<<m;  s[0] = 0;
          for ( int i=0; i<M; ++i )
             if( ok(i) ) s[++s[0] ] = i;  //cout << s[0];

          for ( int i=1; i<=s[0]; ++i ) {
               num[i] = __builtin_popcount(s[i] );
          }
         /* for ( int i=1; i<=s[0]; ++i )
            cout << s[i] << endl;*/
          solve();
    }
};

codeforces：111 Problem C Petya and Spiders

题目链接： http://www.codeforces.com/contest/111/problem/C

题意是：给出大小n*m的格子块；每个格子都有一只蜘蛛，蜘蛛可以保持不动，或上下左右移动(可能的话)，问题是求在1s后有多少格子会是空的。

分析： n*m<=40,数据这么小，很明显会想到是状态压缩DP吧。把min(n, m)当做列来处理。无论是n*m,还是m*n结果都是一样的。分析当前行的状态和那些行的状态有关，开始弱弱的以为只和上一行有关，就着急写了代码，结果是没测几组数据就把我搞挂了。

当前行状态和上一行以及下一行的状态都是相关的。设计状态时只能二维记录状态了。

dp[i][k][l] = max( dp[i][k][l], dp[i-1][j][k] + num[k] ) if( ok(j, k, l) );

dp[i][k][l] 表示当前行的状态是k下一行的状态是l可以得到的最多空格子；

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

#define maxn 10
int n, m;
int dp[40][1<<maxn][1<<maxn];
int num[1<<maxn];
// dp[i][k][l] = max( dp[i][k][l], dp[i-1][j][k]+num[j] );

int count( int x ) {
    int cnt = 0;
    for ( int i=0; i<m; ++i )
      if(x&(1<<i) ) ++cnt;
    return m-cnt;
};

bool ok( int x, int y, int z ) {
    for ( int i=0; i<m; ++i )
      if(!(y&(1<<i)) )
      {
          if((x&(1<<i)) || (z&(1<<i)) || ( (y&(1<<(i+1)))&&(i+1<m) ) || (i-1>=0&&(y&(1<<(i-1))) ) )
            continue;
          return 0;
      }
      return  1;
};

int a[1<<20], b[1<<20], c[1<<20];

int main( ) {

     while(cin >> n >> m)
     {
         if(n < m) swap(n, m);
         if(n == 1 || m == 1) {
             m = n;
             printf ("%d\n", m-(m+2)/3);  continue;
         }
         int M = (1<<m);
         for ( int i=0; i<=n+1; ++i )
           for ( int j=0; j<M; ++j )
             for ( int k=0; k<M; ++k )
              dp[i][j][k] = -1111111111;
         for ( int i=0; i<M; ++i )
           dp[0][0][i]=0,  num[i] = count(i);
         /*把可以更新的状态预处理 */  
         a[0] = b[0] = c[0] = 0;
         for ( int i=0; i<M; ++i )
           for ( int j=0; j<M; ++j )
             for ( int k=0; k<M; ++k )
               if(ok(i, j, k) )
               {
                   a[++a[0] ] = i;
                   b[++b[0] ] = j;
                   c[++c[0] ] = k;
               }

         for ( int i=1, j, k, l; i<=n; ++i )
         {
             for ( int jj=1; jj<=a[0]; ++jj ){
                j = a[jj], k = b[jj], l = c[jj];
                dp[i][k][l] = max(dp[i][k][l], dp[i-1][j][k]+num[k]);
             }
         }
         int ans = 0;
         for ( int i=0; i<M; ++i )
           if(ans < dp[n][i][0] ) ans = dp[n][i][0];
         cout << ans << endl;
     }
     return 0;
}