POJ1185（炮兵阵地） 状压DP

最新推荐文章于 2018-11-18 22:37:38 发布
最新推荐文章于 2018-11-18 22:37:38 发布
阅读量489 收藏 1
点赞数 1
分类专栏： DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26572969/article/details/46655773
版权

每一行的状态是取决于上一行和上上一行的，所以每次更新的时候需要记录当前行的状态和下一行的状态，然后再进行递推。。。不过估算了一下复杂度是10的11次方，吓得我都没敢写啊！！！看了一下别人的博客，居然真有这样写过的，于是就自己实现一边啦【最后看了以下讨论版，处理一下复杂度可以降低的，最后贴讨论版代码】

思路：令P为1，H为0。用一个数组存下每一行的状态。

1.先有数组num[] 存下各个状态的1的个数。

2.设dp[i][j][k] 为考虑了前i-1行，第i-1行的状态为j，第i-2行的状态为k的最大炮兵数。

那么有递推式dp[i][j][k] = max(dp[i][j][k],dp[i-1][k][t] + num[j]);且j,k,t满足(j & k) = 0,(k & t) = 0,(j & t) = 0;

然后考虑特例n=1和边界n=2。

3.直接开数组应该会爆的，所以滚动数组实现。


我的代码：

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;
const int maxn = 105;
const int maxm = 10;

int n,m,S[maxn];
int dp[2][1<<maxm][1<<maxm];
int num[1<<maxm];

void init(){
    int tmp,cnt;
    for(int i=0;i<(1<<maxm);i++){
        cnt = 0;tmp = i;
        while(tmp){
            if(tmp & 1) cnt++;
            tmp >>= 1;
        }
        num[i] = cnt;
    }
}

bool islegal(int i,int x){
    if((~S[i]) & x) return false;
    if((x & (x << 1)) || (x & (x << 2)) || (x & (x >> 1)) || (x & (x >> 2))) return false;
    return true;
}

int main(){
    init();
    scanf("%d%d",&n,&m);getchar();
    for(int i=0;i<n;i++){
        char ch;
        for(int j=m-1;j>=0;j--){
            ch = getchar();
            if(ch == 'P') S[i] += (1 << j);
        }
        getchar();
    }
    int top = (1 << m);
    if(n == 1){
        int res = 0;
        for(int j=0;j<top;j++) if(islegal(0,j)) res = max(res,num[j]);
        printf("%d\n",res);
        return 0;
    }
    for(int j=0;j<top;j++){
        if(!islegal(1,j)) continue;
        for(int k=0;k<top;k++){
            if(islegal(0,k) && !(j & k))
                dp[1][j][k] = num[j] + num[k];
        }
    }
    for(int i=2;i<n;i++){
        int v = i & 1,u = (i + 1) & 1;
        for(int j=0;j<top;j++){
            if(!islegal(i,j)) continue;
            for(int k=0;k<top;k++){
                if(!islegal(i-1,k) || (j & k)) continue;
                for(int t=0;t<top;t++){
                    if((t & j) || (t & k)) continue;
                    dp[v][j][k] = max(dp[v][j][k],dp[u][k][t] + num[j]);
                }
            }
        }
    }
    int u = (n - 1) & 1;
    int res = 0;
    for(int j=0;j<top;j++){
        for(int k=0;k<top;k++){
            res = max(res,dp[u][j][k]);
        }
    }
    printf("%d\n",res);
    return 0;
}




讨论版上某神牛的代码orz： 

/*这题关键就是对状态的理解，由于每个炮能打2格的位置
我们可以先dfs出，每一行可能摆放的各种炮兵状态，canState[],canNum[]
经预先计算得出，m=10时最大的状态数为60
其次，没放过一行时，该行有两个有意义的状态。
一个是当前行的状态，一个是他上一行的状态。
这样一来，每一行就有60*60种状态。
我们可以定义dp[l][i][j],l表示第几层,i表示当前层的状态,j表示上一层的状态
那么 dp[l][i][j] = max{dp[l-1][j][k]} + canNum[i]
canNum[i]表示dfs预处理得出的第i个状态对应的编号
剩下的，就跟背包的更新极为类似了。
*/


#include<cstdio>
#include<cstring>

#define compatible(a,b) (((a)&(b))==0)
#define MN 110
#define MS 61
#define MM 11


/*dfs函数和它用到的全局变量
dfs函数，用于打表出每行m个位置时
各种可行的状态,数字为为1表示是炮*/
int canState[MS];
int canNum[MS];
int len;
int hillp;
void dfs(int loc,int num,int m);
/******************************/
/*input函数和它用到的全局变量
此函数功能为，输入数据，并处理
得到各层的hill,数位为1表示此位置不能放炮*/
char coteau[MN][MM];
int hill[MN];
void input(int n,int m);
/*****************************/
/*dpSolve函数和它所用到的全局变量
该函数功能是利用动态规划，计算出各层
各状态中，最多能放多少炮*/
int dpAmount[MN][MS][MS];
bool dpVisit[MN][MS];
void dpSolve(int n,int m);
/*************************/
int findmx(int n);//查找dpAmount中的最大值
int main()
{
	int n,m;
	while(~scanf("%d%d",&n,&m))
	{
		input(n,m);
		dpSolve(n,m);
		printf("%d\n",findmx(n));
	}
	return 0;
}
void input(int n,int m)
{
	int i,tmp;
	char *p;
	hill[0] = -2;
	for(i=1;i<=n;i++)
	{
		scanf("%s",coteau[i]);
		tmp = 0;
		for(p=coteau[i];*p;p++)
		{
			tmp<<=1;
			if(*p=='H')
				tmp|=1;
		}
		hill[i]=tmp;
	}
}


void dfs(int loc,int num,int m)
{
	int i;
	canNum[len] = num;
	canState[len++]=hillp;
	if(loc>=m-3)
	{
		return;
	}
	for(i=loc+3;i<m;i++)
	{
		hillp|=(1<<i);
		dfs(i,num+1,m);
		hillp&=(~(1<<i));
	}
}


void dpSolve(int n,int m)
{
	int i,j,k,l,mx;
	//初始化dp所需的各元素
	len=hillp=0;
	dfs(-3,0,m);
	memset(dpAmount,-1,sizeof(dpAmount));
	memset(dpVisit,false,sizeof(dpVisit));
	dpAmount[0][0][0] = 0;dpVisit[0][0]=true;
	//进行dp
	for(l=1;l<=n;l++)
	{
		for(i=0;i<len;i++)
		{
			if(compatible(canState[i],hill[l]))
			{
				for(j=0;j<len;j++)
				{
					if((!compatible(canState[i],canState[j]))||
						(!dpVisit[l-1][j]))continue;
					mx=-1;
					for(k=0;k<len;k++)
					{
						if(dpAmount[l-1][j][k]>=0&&
							compatible(canState[i],canState[k])&&
							mx<dpAmount[l-1][j][k])
						{
							mx = dpAmount[l-1][j][k]; 
						}
					}
					if(mx>=0)
					{
						dpAmount[l][i][j] = canNum[i] + mx;
						dpVisit[l][i] = true;
					}
				}
			}
		}
	}
}
int findmx(int n)
{
	int mx=0;
	int i,j,l;
	for(l=1;l<=n;l++)
	{
		for(i=0;i<len;i++)
		{
			for(j=0;j<len;j++)
			{
				if(mx<dpAmount[l][i][j])
					mx = dpAmount[l][i][j];
			}
		}
	}
	return mx;
}


Neutralzz
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【动态规划】炮兵阵地
void* ptr = &OI;
02-26 958
Description 司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成，地图的每一格可能是山地（用"H" 表示），也可能是平原（用"P"表示），如下图。在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击范围如图中黑色区域所示： 如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它
POJ 1185 炮兵阵地 测试数据
08-24
标题“POJ 1185 炮兵阵地”是一个编程竞赛问题，源自著名的在线判题系统POJ（Programming Online Judge）。这个问题旨在测试参赛者的算法设计和编程能力。描述中提到“数据略弱”，意味着POJ原题目的数据范围可能较...
POJ 1185
qq_40924940的博客
11-18 473
这道题和之前的一个牛放牧的题目几乎一样。。就是个升级版。。这次打起来更加顺手了。。。 还是输入 n*m 地图 H不可放 P 就可以放，同时保证每个炮兵上下左右两格不会有别的炮兵，中文题。。。不翻译了。   之后还是很明显。。。先确保每行可行的状态，记录下来。然后先把上两行的和地图对比，再相互之间对比确保不会冲突，最后同归递推 dp [ i ] [ k ] [ t ] = max ( dp [...
poj1185
tjqACM的专栏
12-28 405
解题思路：本题是经典的状态压缩dp，由于当前行要收前两行的影响，因此我们需要一个三维的dp来解决                    dp[i][t1][t2],表示当前行i的状态为t2，i-1行的状态为t1，状态转移方程dp[i][t1][t2]=max(dp[i][t1][t2],dp[i-1][j][t1]+a2[t2])  a2[t2]表示满足t2状态下可以安排的炮兵数量。（ps：做状
算法-炮兵阵地（POJ-1185）（包含源程序）.rar
09-16
标题中的“炮兵阵地（POJ-1185）”是一个编程竞赛题目，源自国内著名的在线编程平台POJ（编程之美）。这类题目通常要求参赛者编写程序来解决特定的算法问题。在这个案例中，我们可能面临的是一个与数学、策略或者...
POJ 放炮问题 1185
08-09
总的来说，POJ1185放炮问题的解决方案利用动态规划，通过自底向上的方式逐层求解，有效避免了回溯和重复计算，提高了算法效率。这种问题解决策略在处理类似约束条件的优化问题时非常常见，是计算机科学中解决问题的...
poj dp总结，动态规划分类
08-18
### poj dp总结：动态规划分类 #### 概述 动态规划（Dynamic Programming，简称DP）是一种在计算机科学和数学中广泛使用的算法策略，用于解决最优化问题。它通过将复杂问题分解为较简单的子问题来求解，并利用这些...
poj_dp分类
03-13
### poj_dp分类解析 #### 概述 在本篇文章中，我们将深入探讨并解析PoJ (Pacific Ocean Judger) 平台上与动态规划（Dynamic Programming, DP）相关的题目分类及其特征。通过这些题目，读者可以更好地理解动态规划的...
POJ1185
code
02-23 1042
POJ1185 炮兵阵地 司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成，地图的每一格可能是山地（用"H" 表示），也可能是平原（用"P"表示），如下图。在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击范围如图中黑色区域所示： 如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色
poj 1185
志当存高远
05-05 893
<br /> 炮兵阵地Time Limit: 2000MS Memory Limit: 65536KTotal Submissions: 9240 Accepted: 3270<br />Description司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成，地图的每一格可能是山地（用"H" 表示），也可能是平原（用"P"表示），如下图。在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击范围如图中黑色区域所示： <br
POJ 1185(动态规划-状压dp)
wust_cyl的博客
01-27 209
问题描述: 司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成，地图的每一格可能是山地（用"H" 表示），也可能是平原（用"P"表示），如下图。在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击范围如图中黑色区域所示：  如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它能够攻
POJ-1185 炮兵阵地
随风而行的博客
09-27 356
地址：http://poj.org/problem?id=1185 思路：状态压缩DP,对每行的状态进行枚举，由于一个炮兵影响相邻两行，因此用 dp[i][j][k]来保存 第i行的状态为j,第 i-1行状态为k时的最大个数。 Code : #include&lt;iostream&gt; #include&lt;cstring&gt; using namespace std; co...
[POJ1088] 滑雪(递归dp)
最新发布
05-17
题目描述 给出一个$n\times m$的矩阵，每个位置上有一个非负整数，代表这个位置的海拔高度。一开始时，有一个人站在其中一个位置上。这个人可以向上、下、左、右四个方向移动，但是只能移动到海拔高度比当前位置低或者相等的位置上。一次移动只能移动一个单位长度。定义一个位置为“山顶”，当且仅当从这个位置开始移动，可以一直走到海拔高度比它低的位置上。请问，这个矩阵中最多有多少个“山顶”？ 输入格式 第一行两个整数，分别表示$n$和$m$。 接下来$n$行，每行$m$个整数，表示整个矩阵。 输出格式 输出一个整数，表示最多有多少个“山顶”。 样例输入 4 4 3 2 1 4 2 3 4 3 5 6 7 8 4 5 6 7 样例输出 5 算法1 (递归dp) $O(nm)$ 对于这道题，我们可以使用递归DP来解决，用$f(i,j)$表示以$(i,j)$为起点的路径最大长度，那么最后的答案就是所有$f(i,j)$中的最大值。 状态转移方程如下： $$ f(i,j)=\max f(x,y)+1(x,y)是(i,j)的下一个满足条件的位置 $$ 注意：这里的状态转移方程中的$x,y$是在枚举四个方向时得到的下一个位置，即： - 向上：$(i-1,j)$ - 向下：$(i+1,j)$ - 向左：$(i,j-1)$ - 向右：$(i,j+1)$ 实现过程中需要注意以下几点： - 每个点都需要搜一遍，因此需要用双重for循环来枚举每个起点； - 对于已经搜索过的点，需要用一个数组$vis$来记录，防止重复搜索； - 在进行状态转移时，需要判断移动后的点是否满足条件。 时间复杂度 状态数为$O(nm)$，每个状态转移的时间复杂度为$O(1)$，因此总时间复杂度为$O(nm)$。 参考文献 C++ 代码 算法2 (动态规划) $O(nm)$ 动态规划的思路与递归DP类似，只不过转移方程和实现方式有所不同。 状态转移方程如下： $$ f(i,j)=\max f(x,y)+1(x,y)是(i,j)的下一个满足条件的位置 $$ 注意：这里的状态转移方程中的$x,y$是在枚举四个方向时得到的下一个位置，即： - 向上：$(i-1,j)$ - 向下：$(i+1,j)$ - 向左：$(i,j-1)$ - 向右：$(i,j+1)$ 实现过程中需要注意以下几点： - 每个点都需要搜一遍，因此需要用双重for循环来枚举每个起点； - 对于已经搜索过的点，需要用一个数组$vis$来记录，防止重复搜索； - 在进行状态转移时，需要判断移动后的点是否满足条件。 时间复杂度 状态数为$O(nm)$，每个状态转移的时间复杂度为$O(1)$，因此总时间复杂度为$O(nm)$。 参考文献 C++ 代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值