POJ 1185 炮兵阵地状压DP

最新推荐文章于 2019-12-18 00:53:34 发布

什么都不会的菜鸡

最新推荐文章于 2019-12-18 00:53:34 发布

阅读量172

点赞数 1

分类专栏： DP

本文链接：https://blog.csdn.net/qq_42211531/article/details/86129401

版权

DP 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

解题方法：

第一个巧妙之处：

第一步先预处理炮车能够放置的位置（其实只有几十种），如果暴力枚举的话，时间空间都不够的。

第二个巧妙之处：

将地图的每一行状压成一个数，山地位置为1，平原为0。为什么这么状压？我们预处理的炮车放置情况，能放炮车的地方为1，不能放置炮车的地方为0，假如炮车放置情况（1001），如果地图为（1100），我们发现如果二进制的某一位上，二者同时为1，则这个状态是冲突的，所以我们判断时，只需要将二者 & 即可判断。

我们用dp[i][j][k]表示第 i 行放置情况为 j ，i - 1行放置情况为 k 的数量。

那么状态转移方程 dp[i][j][k]=max(dp[i][j][k],dp[i-1][k][l]+state[j].cnt); l为i-2的放置情况。

记得先对一行进行预处理。 dp[1][i][1]=state[i].cnt; 为什么第三维是 1？，因为我们的预处理第一个状态为（0），就是不放车的情况。

其他细节请看代码。最后还有测试数据。

///#include<bits/stdc++.h>
///#include<unordered_map>
///#include<unordered_set>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<queue>
#include<bitset>
#include<set>
#include<stack>
#include<map>
#include<new>
#include<vector>
#define MT(a,b) memset(a,b,sizeof(a));
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pai=acos(-1.0);
const double E=2.718281828459;
const int mod=1e9+7;
const int INF=0x3f3f3f3f;

int n,m,sign;
int maps[105];
int dp[105][105][105];

struct node
{
    int cnt;
    int cond;
}state[105];    ///能够放置的状态

bool init_judge(int x)      ///判断是否有炮车冲突
{
    if(x&(x<<1)) return 0;
    if(x&(x<<2)) return 0;
    return 1;
}

int bit_count(int x)    ///计算1的数量
{
    int cnt=0;
    while(x)
    {
        cnt++;
        x&=(x-1);
    }
    return cnt;
}

void init()         
{
    maps[0]=(1<<m)-1;///地图没有第0行，应该全为山地，不能放置炮车
    sign=0;
    memset(dp,0,sizeof(dp));
    int up=1<<m;
    for(int i=0;i<up;i++)       ///1表示放，0表示不放
    {
        if(init_judge(i))       ///判断是否有炮车会冲突
        {
            state[++sign].cond=i;
            state[sign].cnt=bit_count(i);  ///计算炮车数量
        }
    }
}

int main()
{
    char x[15];
    scanf("%d %d",&n,&m);
    init();
    for(int i=1; i<=n; i++)
    {
        int num=0;
        scanf("%s",x);
        for(int i=0;i<m;i++)
            num=(num<<1)+(x[i]=='H');     ///1表示山地，0表示平原
        maps[i]=num;
    }
    for(int i=1;i<=sign;i++)            ///初始化第一行的
        if((maps[1]&state[i].cond)==0)
            dp[1][i][1]=state[i].cnt;
    for(int i=2;i<=n;i++)       ///第i行状态为 j，第i-1行状态为 k
    {
        for(int j=1;j<=sign;j++)
        {
            if(maps[i]&state[j].cond) continue; ///判断i行状态与地图情况是否冲突
            for(int k=1;k<=sign;k++)
            {
                if(maps[i-1]&state[k].cond)   continue;///判断i-1行状态与地图情况是否冲突
                if(state[k].cond&state[j].cond) continue;///判断i行和i-1行炮车是否冲突
                for(int l=1;l<=sign;l++)        ///第i-2行的状态 l
                {
                    if(maps[i-2]&state[l].cond)   continue;///判断i-2行状态与地图情况是否冲突
                    ///判断i,i-1,i-2三行是否冲突
                    if((state[k].cond&state[j].cond)||(state[j].cond&state[l].cond)||(state[k].cond&state[l].cond)) continue;
                    dp[i][j][k]=max(dp[i][j][k],dp[i-1][k][l]+state[j].cnt);
                }
            }
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=sign;j++)
            for(int k=1;k<=sign;k++)
                ans=max(ans,dp[i][j][k]);
    printf("%d\n",ans);
    return 0;
}

测试数据：

///测试数据
/*
100 10
HPHPHHPPPP
PHHPPPHPHP
HHPHPHHPHH
PPPPHHHPPP
PHPPPHPPPH
PPHPHPHPPP
HPHHPHPPHP
PPPHPPPPHH
HPPHPPPPPH
PPPPHHPHPH
PHPHPPHHPH
PPPHPHHPHP
PPPPPHPHHH
HHHPPPHPHP
HPHHPHPHHP
HPHPHPPPHH
HHHPHHPPPP
HHPHPPPPPP
HPPHHHHHHH
HHPPHHPPHP
HPHHHHPPPH
PPPPPHPPPH
HPPPPHPPPH
PHHHHHPPHP
HPPHPPPHPH
PHHPPPHPHP
PPHPHPPPHH
HPHPHPHPPP
PHPPPHPPHH
HPHPPHPHPH
PHHPHHPHPH
PHHHHPPHPH
PPHHHHHHPP
PPHPHHPPPH
PHHHHHHHPP
PPPHPPHPHP
HPPPPPPHPH
HHPHHPPPPH
HPHPHHHHPP
HPPPPPHPPH
PHHPPPPHPP
PPHPHPPHHH
HHHPPPHHPH
HPPPHHPPHP
PHHHHPPHPH
PPPHHHPHHP
PHPHHHHHPH
PPPPPHPHHH
PPPPHPHHPH
PPPHHHPPHH
PPPHPHPPPH
PHPPPPHPPH
PPHPHHPHHH
PPPPHPHPHH
HHPPHHPHHP
PHHPPHHHPP
HPPPHHHPPH
HPPHHHHHPP
PHHPPHHPPH
HHHHPPPPHH
HPHHPHHHPP
HPPHPPPHHH
HHHPHHPPPH
HPPPHPPPHH
PHHHPHHPPH
PHHHHPPHPP
HPPHPHHPHP
HPPPPHHHHH
PHHHHPPHHH
HPHHPHHPPH
HPHHPPHPHH
PHPPPPHPPH
PPHPHPHPHH
PPPPPHPPHH
PHPPHHHHPP
HHHPPHPHPH
PHPHHHHPHP
PPHPPHPPHH
HHHPHHHHHP
HHHPPHHHPH
PPPHHPPPHH
PHPHPPHHHH
HHPHHPPHPP
HHHPHPPPHP
HPHPPPHPPP
PPPHPPPHHP
HPPHHPHPHP
HPHHPPHPHP
HPPPPPHPPP
HHHHHPHHHH
HHPHHHHPHH
PPPPHHPPHP
HHPHPPHPHP
PPHHHPHHHP
HPPHHPHPHH
HPPHHHHHHP
HHPHHPPPPH
PPHHPPHHHP
HHHHHHHHPH
HPPHHHHPHP

ans=222


1 1
P

ans=1

1 1
H

ans=0;
*/