RQNOJ 328 炮兵阵地：状压dp

题目链接：https://www.rqnoj.cn/problem/328

题意：

　　司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。

　　一个N*M的地图由N行M列组成(N≤100,M≤10)，地图的每一格可能是山地（用'H' 表示），也可能是平原（用'P'表示），如下图。

　　在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；

　　一支炮兵部队在地图上的攻击范围如图中黑色区域所示：

　　　　

　　如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它能够攻击到的区域：沿横向左右各两格，沿纵向上下各两格。

　　图上其它白色网格均攻击不到。从图上可见炮兵的攻击范围不受地形的影响。

　　现在，将军们规划如何部署炮兵部队，在防止误伤的前提下（保证任何两支炮兵部队之间不能互相攻击，即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内）。

　　问在整个地图区域内最多能够摆放多少我军的炮兵部队。

题解：

　　表示状态：

　　　　m<=10，所以对每一行进行压缩。

　　　　dp[i][state1][state2] = max num of cannons（炮兵数量）

　　　　i：该摆第i行

　　　　state1：上上一行的状态(i-2)

　　　　state2：上一行的状态(i-1)

　　找出答案：

　　　　max dp[n][state1][state2]

　　　　枚举state1,state2.

　　如何转移：

　　　　now: dp[i][state1][state2]

　　　　枚举第i行填的方案为nex。

　　　　如果nex符合第i行的地形，并且与state1,state2均没有交集，则：

　　　　dp[i+1][state2][nex] = max dp[i][state1][state2] + sum[nex]

　　　　（sum[nex]为方案nex中的炮兵个数。）

　　边界条件：

　　　　dp[0][0][0] = 0

　　　　others = -1

　　　　（第0行的上两行方案均设为0，因为不填适用于任何地形）

　　优化：

　　　　（1）预处理field数组。

　　　　　　field[i]为第i行的地形。每一位上1位山地，0为平原。

　　　　　　判断nex是否适用于第i行时，只需判断是否有 state & field == 0

 

　　　　（2）预处理在一行上的合法方案。

　　　　　　在每一行上，两个炮兵之间最少相距2格。利用此性质dfs然后存起来就好。

　　　　（3）dp数组的下标state不再直接表示01状态，而是换成s代表当前方案在dfs数组中的索引。

　　　　　　省空间啊。。。

 

　　　　（4）预处理出每一种行上合法方案的sum值，存起来。

　　　　　　预处理时，最好用lowbit直接找出1，而不用逐位枚举。

AC Code:

// optimizations:
// scheme: put == 1, blank == 0
// field: mountain == 1, plain == 0
// legal: scheme & field == 0
// preprocess: legal scheme for rows
//
// state expression:
// dp[i][state1][state2] = max num of cannons
// i: considering ith row
// state1: top row
// state2: bottom row
//
// find the answer:
// max dp[n][state1][state2]
//
// transferring:
// now: dp[i][state1][state2]
// if nex & field[i] == 0
// dp[i+1][state2][nex] = max dp[i][state1][state2] + sum[nex]
//
// boundary:
// dp[0][0][0] = 0
// others = -1
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#define MAX_N 105
#define MAX_M 15
#define MAX_S 65

using namespace std;

int n,m;
int cnt;
int ans;
int sum[MAX_S];
int field[MAX_N];
int legal_state[MAX_S];
int dp[MAX_N][MAX_S][MAX_S];

void dfs(int col,int state)
{
    if(col>=m)
    {
        legal_state[cnt++]=state;
        return;
    }
    dfs(col+1,state);
    dfs(col+3,state|(1<<col));
}

int cal_sum(int state)
{
    int lowbit=state&-state;
    int cnt=0;
    while(lowbit)
    {
        cnt++;
        state^=lowbit;
        lowbit=state&-state;
    }
    return cnt;
}

void read()
{
    memset(field,0,sizeof(field));
    cin>>n>>m;
    char c;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cin>>c;
            field[i]<<=1;
            if(c=='H') field[i]|=1;
        }
    }
}

void solve()
{
    cnt=0;
    dfs(0,0);
    for(int i=0;i<cnt;i++)
    {
        sum[i]=cal_sum(legal_state[i]);
    }
    memset(dp,-1,sizeof(dp));
    dp[0][0][0]=0;
    for(int i=0;i<n;i++)
    {
        for(int s1=0;s1<cnt;s1++)
        {
            for(int s2=0;s2<cnt;s2++)
            {
                int state1=legal_state[s1];
                int state2=legal_state[s2];
                if(dp[i][s1][s2]!=-1 && !(state1&state2))
                {
                    for(int s3=0;s3<cnt;s3++)
                    {
                        int nex=legal_state[s3];
                        if(!(nex&field[i]) && !(nex&state1) && !(nex&state2))
                        {
                            dp[i+1][s2][s3]=max(dp[i+1][s2][s3],dp[i][s1][s2]+sum[s3]);
                        }
                    }
                }
            }
        }
    }
    ans=0;
    for(int s1=0;s1<cnt;s1++)
    {
        for(int s2=0;s2<cnt;s2++)
        {
            ans=max(ans,dp[n][s1][s2]);
        }
    }
}

void print()
{
    cout<<ans<<endl;
}

int main()
{
    read();
    solve();
    print();
}