[状态压缩DP] HDU 4539

HDU 4539 经典状态压缩DP

n*m的平原，每个士兵可以攻击到并且只能攻击到与之曼哈顿距离为2的位置以及士兵本身所在的位置。

和poj1185基本一样

两个距离，三维的dp数组
只是判断条件变成了曼哈顿距离
对位置判断如图
距离一行不能在左右上角
距离两行不能在正前方

数组一开始开小了WA
开大了又MLE
最后就照抄了

#include <cstdio>
#include <cstring>
#include <iostream>

#define maxn 120

using namespace std;

int map[ 105 ];
int dp[ 105 ][ 205 ][ 205 ];
int state[ 205 ], num[ 205 ]; //所有合法的状态，合法状态下的炮兵数(1的个数)
int n, m, vState;

//判断左右两边2的距离是否冲突，1代表有士兵
bool check ( int x ) {
        if ( x & ( x >> 2 ) )
                return false;
        return true;
}

//统计x状态下可以放多少士兵（x有多少位的1，1是可以放的位置）
int count ( int x ) {
        int ans = 0;
        for ( int i = 1; i <= x; i <<= 1 )
                if ( x & i )
                        ans++;
        return ans;
}

void init () {
        vState = 0;
        memset ( state, 0, sizeof ( state ) );
        memset ( num, 0, sizeof ( num ) );

        //枚举1<<m种合法状态
        for ( int i = 0; i < ( 1 << m ); ++i )
                if ( check ( i ) ) {
                        state[ vState ] = i;
                        num[ vState++ ] = count ( i );
                }
}

int main () {
        while ( ~scanf ( "%d%d", &n, &m ) ) {
                //有一边是0
                if ( !n && !m ) {
                        printf ( "0\n" );
                        continue;
                }

                memset ( dp, 0, sizeof ( dp ) );
                memset ( map, 0, sizeof ( map ) );
                for ( int i = 0; i < n; ++i )
                        for ( int j = 0; j < m; ++j ) {
                                int c;
                                scanf ( "%d", &c );
                                if ( c == 0 ) //空地初始化为0
                                        map[ i ] = map[ i ] | ( 1 << ( m - j - 1 ) );
                        }

                init ();

                //第一行
                for ( int i = 0; i < vState; ++i )
                        if ( !( map[ 0 ] & state[ i ] ) )
                                // 第一行，状态为i，上一行状态为0,可以放几种
                                dp[ 0 ][ i ][ 0 ] = num[ i ];
                //第二行
                for ( int i = 0; i < vState; ++i ) {
                        if ( map[ 1 ] & state[ i ] )
                                continue;
                        //枚举第一行可行的状态
                        for ( int j = 0; j < vState; ++j ) {
                                if ( map[ 0 ] & state[ j ] )
                                        continue;
                                //第二行i状态和第一行j状态之间距离小于2（不在斜对角）
                                if ( ( state[ i ] << 1 ) & state[ j ] )
                                        continue;
                                if ( ( state[ i ] >> 1 ) & state[ j ] )
                                        continue;
                                //找到第二行每个状态下的最多炮台数
                                dp[ 1 ][ i ][ j ] =
                                    max ( dp[ 1 ][ i ][ j ], dp[ 0 ][ j ][ 0 ] + num[ i ] );
                        }
                }

                第3 -- n行
                for ( int h = 2; h < n; ++h ) {
                        for ( int i = 0; i < vState; ++i ) {
                                if ( map[ h ] & state[ i ] )
                                        continue;

                                //枚举h-1行所有可行状态
                                for ( int j = 0; j < vState; ++j ) {
                                        if ( map[ h - 1 ] & state[ j ] )
                                                continue;
                                        if ( ( state[ i ] << 1 ) & state[ j ] )
                                                continue;
                                        if ( ( state[ i ] >> 1 ) & state[ j ] )
                                                continue;

                                        //第h-2行
                                        for ( int k = 0; k < vState; ++k ) {
                                                if ( map[ h - 2 ] & state[ k ] )
                                                        continue;

                                                // h-1 和 h-2没冲突
                                                if ( ( state[ j ] << 1 ) & state[ k ] )
                                                        continue;
                                                if ( ( state[ j ] >> 1 ) & state[ k ] )
                                                        continue;

                                                // h 与 h-2 没冲突
                                                if ( state[ i ] & state[ k ] )
                                                        continue;
                                                //当前行i状态j次状态 = 上一行j状态k次状态 +
                                                // h行i状态放的士兵个数
                                                dp[ h ][ i ][ j ] =
                                                    max ( dp[ h ][ i ][ j ],
                                                          dp[ h - 1 ][ j ][ k ] + num[ i ] );
                                        }
                                }
                        }
                }

                int ans = 0;
                //找到最后一行的最大可行方案
                for ( int i = 0; i < vState; ++i )
                        for ( int j = 0; j < vState; ++j )
                                if ( ans < dp[ n - 1 ][ i ][ j ] )
                                        ans = dp[ n - 1 ][ i ][ j ];
                printf ( "%d\n", ans );
        }
        return 0;
}