poj185 炮兵阵地状压DP

最新推荐文章于 2020-04-12 12:11:52 发布

原创最新推荐文章于 2020-04-12 12:11:52 发布 · 365 阅读

0 ·

CC 4.0 BY-SA版权

DP 专栏收录该内容

11 篇文章

订阅专栏

本文介绍了一道经典的动态规划与状态压缩问题——如何在N*M矩阵中放置最多数量的大炮，使得它们不在彼此的攻击范围内。通过状态压缩与DP算法解决，并采用映射技术减少内存消耗。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

题意：在一个N*M的矩阵上最多能放多少门大炮，大炮只能放在平原上，且保证任何两支炮兵部队之间不能互相攻击，即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内（横向纵向两个格子）。

思路： 1、这是经典的状态压缩题，由于当前第i行的状态不仅和第i-1行有关，还和第i-2行有关，所以要开一个三维的数组同时记录当前行和上一行的状态

所以dp[i][j][p]表示第i行状态为j时i-1行状态为p时所放的大炮数

2、状态转移方程：dp[i][j][p] = max(dp[i][j][p], dp[i-1][p][q]+num[j]) p, q 和j都没有冲突

3、不过这样做的话数组是开不下的而且枚举的时候很容易超时，刚开始我就是这样做的，结果发现越写越乱，后来就想到建立一个映射，由于m<=10,可行状态最多有60种，一下就好很多。

4，然后就是可以说就是Debug了好几个小时，刚开始时二进制处理时没处理好，然后WA了两发后发现读做题意，然后又WA，然后有发现了一个小小的错误最后1954ms飘过，然后剪枝到313ms。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
const int maxn = 65;
const int INF = 0x7f7f7f7f;
const int mode = 100000000;

int mapping[1100], cnt_1[1100], rem[maxn];
int f[105][maxn][maxn];


char maze[105][12];
int n, m;
int cnt;
inline bool can(int st, int r)//检查大炮是否放在了山地上
{
	int i = m, t = st;
	while(t) {
		if (t%2 == 1 && maze[r][i] == 'H') return false;
		i--;
		t >>= 1;
	}
	return true;
}

inline bool check(int x, int y)//检查相邻两行的关系
{
	if (x&y)return false;
	return true;
}
inline int bit_cnt(int i)//有多少个1
{
    int ret = 0;
    while(i)
    {
        i &= i - 1;
        ++ret;
    }
    return ret;
}
void build()
{
    for (int st = 0; st < (1<<m); st++)
    {
        if (!(st&(st<<1))&&!(st&(st<<2))) {
            mapping[st] = cnt;
            cnt_1[st] = bit_cnt(st);
            rem[cnt++] = st;
        }
    }
}
int main()
{
    //freopen("input.txt", "r", stdin);
    while (cin >> n >> m)
    {
        cnt = 0;
        build();//建立映射
    	for (int i = 0; i <= n; i++)
            for (int j = 0; j < cnt; j++)
                for (int k = 0; k < cnt; k++)f[i][j][k] = -1;//初始化
        for (int i = 1; i <= n; i++)
			scanf("%s", maze[i]+1);
		for (int st = 0; st < (1<<m); st++)
		{
			if (can(st, 1)) {
				f[1][mapping[st]][0] = cnt_1[st];
			}
		}
        for (int i = 2; i <= n; i++)
		{
			for (int j = 0; j < cnt; j++)//第i行
            {
                if (!can(rem[j],i)) continue;
                for (int p = 0; p < cnt; p++)//i-1
                {
                    if (check(rem[j],rem[p])) {
                        for (int q = 0; q < cnt; q++)//i-2
                        {
                            if (f[i-1][p][q] == -1)continue;
                            if (check(rem[j],rem[q]))
                            {
                                if (f[i][j][p] < f[i-1][p][q]+cnt_1[rem[j]])
                                {
                                    f[i][j][p] = f[i-1][p][q]+cnt_1[rem[j]];
                                }
                            }
                        }
                    }
                }
            }
		}
		int ans = -1;
		for (int j = 0; j < 60; j++)
            for (int p = 0; p < 60; p++)
            if (ans < f[n][j][p]) ans = f[n][j][p];
        cout << ans << endl;
    }
    return 0;
}