拯救公主

最新推荐文章于 2016-04-30 15:33:57 发布
最新推荐文章于 2016-04-30 15:33:57 发布
阅读量323 收藏 1
点赞数
分类专栏： 搜索 动态规划 优先队列 算法 数据结构 dp 文章标签： 算法 数据结构 动态规划 dp 优先队列 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/menxiaoyuan/article/details/49850745
版权
算法 同时被 3 个专栏收录
35 篇文章 0 订阅
订阅专栏
dp
27 篇文章 0 订阅
订阅专栏
搜索
19 篇文章 0 订阅
订阅专栏
时间限制: 1 Sec   内存限制: 128 MB
[ 提交][ 状态][ 讨论版]

题目描述

公主被妖怪抓到了一个山洞里，为了尽快营救公主，王子决定不回城搬救兵去独自营救。山洞为矩形且十分空旷，其中生活着K个妖怪。幸运的是这些妖怪晚上都会睡觉并且没人守夜。但是若是离妖怪太近就会惊醒它，其他的妖怪也会被惊醒，所以我们要找一条距离所有妖怪都很远的路。我们把山洞分为了n*m个格子，走到相邻的格子（不含对角）王子需要一步，妖怪只占一个格子的大小。王子希望你给他一条尽可能安全的路，你只需要告诉他，这条路上离妖怪最近的时候距离是多少（最少走K步可到则认为最近距离为k）。入口在1行1列，公主在n行m列。

输入

n,m,k(地图为n行*m列，k为妖怪个数)（1<n,m<=1000，1<k<=n*m）
之后有k行每行两个数xi，yi（表示妖怪在xi行，yi列）

输出

离妖怪最近的距离

样例输入

3 3 21 33 1

样例输出

1

提示


k值变大



最近距离的算法为行数差加列数差（即从入口到公主的最短距离为（n-1）+（m-1）


//双向优先队列+dp 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
const int INF=9999999;
struct node{
	int x,y,s;
	bool operator < (const node &a) const{
	  return a.s>s;
	} 
};
int n,m,k,mm,mmm,flag,sum,pd1[1110][1110],pd2[1110][1110],z[1110][1110],dp[1110][1110];
int e[1110][1110],b[1110],s[1110],map3[1110][1110],map[1110][1110],map1[1110][1110],map2[1110][1110];
int c[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int min(int a,int b){
	return a<b?a:b;
} 
int insert(int b,int c){
	if(b<1 || b>n || c<1 || c>m || e[b][c]) return false;
	return true;
}
int bfs(int x1,int y1){
	struct node t1,t2,t3,tp1,tp2,tp3;
	priority_queue<node> q1,q2;
	t1.x=x1;t1.y=y1;t1.s=map3[t1.x][t1.y];
	q1.push(t1);
	pd1[t1.x][t1.y]=1;
	tp1.x=n;tp1.y=m;tp1.s=map3[tp1.x][tp1.y];
	q2.push(tp1);
	pd2[tp1.x][tp1.y]=2;
	while(!q1.empty() && !q2.empty()){
		t2=q1.top();q1.pop();
		tp2=q2.top();q2.pop();
		if(pd1[tp2.x][tp2.y]){
			flag=1;
			int u=min(t2.s,tp2.s);
			return u;
		}
		if(pd2[t2.x][t2.y]){
			flag=1;
			int uu=min(t2.s,tp2.s);
			return uu;
		}
	    for(int i=0;i<4;i++){
	    	t3.x=t2.x+c[i][0];
	    	t3.y=t2.y+c[i][1];
	    	int q=min(map3[t3.x][t3.y],t2.s);
	    	t3.s=q;
	    	if(insert(t3.x,t3.y) && !pd1[t3.x][t3.y]){
	    		q1.push(t3);
	    		pd1[t3.x][t3.y]=1;
	    	}
	    	
	    	
	    	tp3.x=tp2.x+c[i][0];
	    	tp3.y=tp2.y+c[i][1];
	    	int qq=min(map3[tp3.x][tp3.y],tp2.s);
	    	tp3.s=qq;
	    	if(insert(tp3.x,tp3.y) && !pd2[tp3.x][tp3.y]){
	    		q2.push(tp3);
	    		pd2[tp3.x][tp3.y]=1;
	    	}
	    }
	}
	return 0;
}
int main(){
           	int x,y,mid;
	while(scanf("%d%d%d",&n,&m,&k)!=EOF){
	    flag=0;mid=0;
		memset(e,0,sizeof(e));
		memset(z,0,sizeof(z));
		memset(b,0,sizeof(b));
		memset(s,0,sizeof(s));
		memset(pd1,0,sizeof(pd1));
		memset(pd2,0,sizeof(pd2));
		memset(map,INF,sizeof(map));
		memset(map1,INF,sizeof(map1));
		memset(map2,INF,sizeof(map2));
		memset(map3,0,sizeof(map3));
		for(int i=0;i<k;i++){
		   scanf("%d%d",&x,&y);
		   e[x][y]=1;
		   b[i]=x;
		   s[i]=y;
		   map[x][y]=0;
		   for(int j=1;j<=m;j++){
		   	map[x][j]=min(abs(y-j),map[x][j]);
		   }
		}
		
		for(int j=1;j<=m;j++){
			map1[1][j]=map[1][j];
			for(int i=2;i<=n;i++){
				if(map[i][j]>map1[i-1][j]+1)
					map1[i][j]=map1[i-1][j]+1;
				else
				    map1[i][j]=map[i][j];
			}
			
			map2[n][j]=map[n][j];
		   	for(int i=n-1;i>=1;i--){
				if(map[i][j]>map2[i+1][j]+1)
				  map2[i][j]=map2[i+1][j]+1;
				else
				  map2[i][j]=map[i][j];
			}
		}
		 
		 for(int i=1;i<=n;i++){
		 	for(int j=1;j<=m;j++){
		 		map3[i][j]=min(map1[i][j],map2[i][j]);
		 	}
		 }
	 
		   int sum=bfs(1,1);
		   if(flag)
	       printf("%d\n",sum);
	       else
	       printf("0\n");
	}  
	return 0;
} 




//单向广度优先搜索 

#include<iostream>
#include<cstdio>
#include<queue>
#include<cmath>
#include<cstring>
using namespace std;
struct node{
	int x,y,s;
	bool operator < (const node &a) const{
	  return a.s>s;
	} 
};
int n,m,k,mm;
int e[1110][1110],b[1110],s[1110],dp[1110][1110];
int c[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int cmp(int xx,int yy){
	if(dp[xx][yy]) return dp[xx][yy];
	int mixn=9999999;
	for(int i=0;i<k;i++){
		int ss=abs(xx-b[i])+abs(yy-s[i]);
		if(ss<mixn)
		 mixn=ss;
	}
	dp[xx][yy]=mixn;
	return mixn;
}
int bfs(int x1,int y1){
	struct node t1,t2,t3;
	priority_queue<node> q;
	int qq=cmp(x1,y1);
	t1.x=x1;t1.y=y1;t1.s=qq;
	q.push(t1);
	while(!q.empty()){
		t2=q.top();q.pop();
		if(mm>t2.s)
		   mm=t2.s;
		for(int i=0;i<4;i++){
			t3.x=t2.x+c[i][0];
			t3.y=t2.y+c[i][1];
			int kk=cmp(t3.x,t3.y);
			t3.s=kk;
			if(t3.x<1 || t3.x>n || t3.y<1 || t3.y>m || e[t3.x][t3.y]==1)
			continue;
			if(t3.x==n && t3.y==m){
				return mm;
			} 
			q.push(t3);
			e[t3.x][t3.y]=1;
	    }
	}
	return 0; 
}
int main(){
	 	int x,y;
	while(scanf("%d%d%d",&n,&m,&k)!=EOF){
		mm=9999999;
		memset(b,0,sizeof(b));
		memset(s,0,sizeof(s));
		memset(e,0,sizeof(e));
		memset(dp,0,sizeof(dp));
		   for(int i=0;i<k;i++){
		   	  scanf("%d%d",&x,&y);
		   	  e[x][y]=1;
		   	  b[i]=x;
		   	  s[i]=y;
		   }
		   int flag=bfs(1,1);
		   if(flag)
	       printf("%d\n",flag);
	       else
	       printf("0\n");
	}  
	return 0;
} 

//广度双向优先搜索

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
struct node{
	int x,y,s;
	bool operator < (const node &a) const{
	  return a.s>s;
	} 
};
int n,m,k,mm,mmm,flag,sum,pd1[1110][1110],pd2[1110][1110],z[1110][1110],dp[1110][1110];
int e[1110][1110],b[1110],s[1110];
int c[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int min(int a,int b){
	return a<b?a:b;
}
int cmp(int xx,int yy){
	if(dp[xx][yy]) return dp[xx][yy];
	int mixn=9999999;
	for(int i=0;i<k;i++){
		int ss=abs(xx-b[i])+abs(yy-s[i]);
		if(ss<mixn)
		mixn=ss;
	}
	dp[xx][yy]=mixn;
	return mixn;
}
int insert(int b,int c){
	if(b<1 || b>n || c<1 || c>m || e[b][c]) return false;
	return true;
}
int bfs(int x1,int y1){
	struct node t1,t2,t3,tp1,tp2,tp3;
	priority_queue<node> q1,q2;
	t1.x=x1;t1.y=y1;t1.s=cmp(x1,y1);
	q1.push(t1);
	pd1[t1.x][t1.y]=1;
	tp1.x=n;tp1.y=m;tp1.s=cmp(n,m);
	q2.push(tp1);
	pd2[tp1.x][tp1.y]=2;
	while(!q1.empty() && !q2.empty()){
		t2=q1.top();q1.pop();
		tp2=q2.top();q2.pop();
		if(pd1[tp2.x][tp2.y]){
			flag=1;
			int u=min(t2.s,tp2.s);
			return u;
		}
		if(pd2[t2.x][t2.y]){
			flag=1;
			int uu=min(t2.s,tp2.s);
			return uu;
		}
	    for(int i=0;i<4;i++){
	    	t3.x=t2.x+c[i][0];
	    	t3.y=t2.y+c[i][1];
	    	int q=min(cmp(t3.x,t3.y),t2.s);
	    	t3.s=q;
	    	if(insert(t3.x,t3.y) && !pd1[t3.x][t3.y]){
	    		q1.push(t3);
	    		pd1[t3.x][t3.y]=1;
	    	}
	    	
	    	
	    	tp3.x=tp2.x+c[i][0];
	    	tp3.y=tp2.y+c[i][1];
	    	int qq=min(cmp(tp3.x,tp3.y),tp2.s);
	    	tp3.s=qq;
	    	if(insert(tp3.x,tp3.y) && !pd2[tp3.x][tp3.y]){
	    		q2.push(tp3);
	    		pd2[tp3.x][tp3.y]=1;
	    	}
	    }
	}
	return 0;
}
int main(){
		int x,y;
	while(scanf("%d%d%d",&n,&m,&k)!=EOF){
		mm=9999999;mmm=9999999;flag=0;sum=0;
		memset(b,0,sizeof(b));
		memset(s,0,sizeof(s));
		memset(e,0,sizeof(e));
		memset(pd1,0,sizeof(pd1));
		memset(pd2,0,sizeof(pd2));
		memset(z,0,sizeof(z));
		memset(dp,0,sizeof(dp));
		   for(int i=0;i<k;i++){
		   	  scanf("%d%d",&x,&y);
		   	  e[x][y]=1;
		   	  b[i]=x;
		   	  s[i]=y;
		   }
		   int sum=bfs(1,1);
		   if(flag)
	       printf("%d\n",sum);
	       else
	       printf("0\n");
	}  
	return 0;
} 



//bfs+二分 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
struct node{
	int x,y,s;
};
int n,m,k,flag,sum,dp[1110][1110],vis[1110][1110],z[1110];
int e[1110][1110],b[1110],s[1110];
int c[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int cmp(int xx,int yy){
	if(dp[xx][yy]) return dp[xx][yy];
	int mixn=9999999;
	for(int i=0;i<k;i++){
		int ss=abs(xx-b[i])+abs(yy-s[i]);
		if(ss<mixn)
		mixn=ss;
	}
	dp[xx][yy]=mixn;
	return mixn;
}
int insert(int b,int c){
	if(b<1 || b>n || c<1 || c>m || e[b][c]) return false;
	return true;
}
int cmp1(int xx,int yy){
	int maxn=0;
	for(int i=0;i<k;i++){
		int ss=abs(xx-b[i])+abs(yy-s[i]);
		if(ss>maxn)
		maxn=ss;
	}
	return maxn;
}
int bfs(int r){
	memset(vis,0,sizeof(vis));
	struct node t1,t2,t3;
	queue<node> q;
	t1.x=1;t1.y=1;t1.s=cmp(t1.x,t1.y);
	vis[t1.x][t1.y]=1;
    q.push(t1);
	while(!q.empty()){
		t2=q.front();q.pop();
		for(int i=0;i<4;i++){
			t3.x=t2.x+c[i][0];
			t3.y=t2.y+c[i][1];
			int rr=cmp(t3.x,t3.y);
			if(insert(t3.x,t3.y) && vis[t3.x][t3.y]==0 && rr>=r){
				if(t3.x==n && t3.y==m){
			       return 1;
		        }
				q.push(t3);
				vis[t3.x][t3.y]=1;
			}
		}
	}	
	return 0;
}
int main(){
			int x,y,mid;
	while(scanf("%d%d%d",&n,&m,&k)!=EOF){
	    flag=0;mid=0;
		memset(b,0,sizeof(b));
		memset(s,0,sizeof(s));
		memset(e,0,sizeof(e));
		memset(dp,0,sizeof(dp));
		memset(z,0,sizeof(z));
		memset(vis,0,sizeof(vis));
		for(int i=0;i<k;i++){
		   scanf("%d%d",&x,&y);
		   e[x][y]=1;
		   b[i]=x;
		   s[i]=y;
		}
		int kk=cmp1(1,1),left=0;
	    while(left<=kk){
	    	mid=(left+kk)/2;
	    	if(bfs(mid)){
	    		flag=1;
	    		left=mid+1;
	    	}   
	    	else{
	    		flag=2;
	    		kk=mid-1;
	    	}
	    }
	    if(flag==1)
		cout << mid << endl;
		else if(flag==2){
		   if(mid==0) cout << "0" << endl;	
	       else cout << mid-1 << endl;
	    }
	}
	return 0;
}

 

menxiaoyuan
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
拯救公主游戏源码
08-31
1.Shadow+Gun-----五星级游戏源文件 2.ShowSize+显示对象大小+Object+Size 3.Tazman-Audio.Fabric.v1.22f 4.unity_annosoft_demo 5.Unity3D+Ladders+Example+Project+军事场景
【暂无】 二叉树 扩展二叉树（add-tree.cpp）
Starlight的博客
10-02 1220
扩展二叉树（add-tree） 问题描述 由于先序、中序和后序序列中的任一个都不能唯一确定一颗二叉树，所以对二叉树作如下处理，将二叉树的空节点用“.”补齐。我们把这样处理后的二叉树成为原二叉树的扩展二叉树，扩展二叉树的先序和后序序列能唯一确定其二叉树。 现在给出扩展二叉树的先序序列，要求输出其中序和后序序列。 样例输入 ABD..EF..G..C.. 样例输出 DBFEGAC DF
Unity拯救公主游戏源码工程
07-13
Unity拯救公主游戏源码
C++小游戏源码之-拯救公主.cpp
最新发布
11-09
C++小游戏源码,可供学习及设计参考。
拯救公主游戏的附件
12-27
在本项目中，我们关注的是一个名为"拯救公主游戏"的数据结构课程设计。这个项目的核心是通过编程实现一个游戏的初始化过程，其中包含了各种数据结构的运用，如图的表示和操作。以下是对每个文件及其相关知识点的详细...
栈
木槿花非花的博客
03-31 6376
背景     栈是计算机中经典的数据结构，简单的说，栈就是限制在一端进行插入删除操作的线性表。栈有两种最重要的操作，即pop（从栈顶弹出一个元素）和push（将一个元素进栈）。     栈的重要性不言自明，任何一门数据结构的课程都会介绍栈。宁宁同学在复习栈的基本概念时，想到了一个书上没有讲过的问题，而他自己无法给出答案，所以需要你的帮忙。 描述     宁宁考虑
字串数
木槿花非花的博客
03-28 2202
题目描述 一个A和两个B一共可以组成三种字符串:"ABB","BAB","BBA". 给定若干字母和它们相应的个数,计算一共可以组成多少个不同的字符串. 输入 每组测试数据分两行,第一行为n(1 输出 对于每一组测试数据,输出一个m,表示一共有多少种字符串. 样例输入 2 1 2 3 2 2 2 0 样例输出 3 90
括号匹配（二）
木槿花非花的博客
11-01 1385
描述 给你一个字符串，里面只包含"(",")","[","]"四种符号，请问你需要至少添加多少个括号才能使这些括号匹配起来。 如： []是匹配的 ([])[]是匹配的 ((]是不匹配的 ([)]是不匹配的 输入第一行输入一个正整数N，表示测试数据组数(N 每组测试数据都只有一行，是一个字符串S，S中只包含以上所说的四种字符，S的长度不超过100输出对于每组测试数据都输出一个正整数
What day is that day?
木槿花非花的博客
01-03 1342
Description It's Saturday today, what day is it after 11 + 22 + 33 + ... + NN days? Input There are multiple test cases. The first line of input contains an integer T indicating the num
FatMouse and Cheese
木槿花非花的博客
03-17 1212
Problem Description FatMouse has stored some cheese in a city. The city can be considered as a square grid of dimension n: each grid location is labelled (p,q) where 0 <= p < n and 0 <= q < n. At eac
回文字符串
木槿花非花的博客
03-21 973
题目描述 所谓回文字符串，就是一个字符串，从左到右读和从右到左读是完全一样的，比如"aba"。当然，我们给你的问题不会再简单到判断一个字符串是不是回文字符串。现在要求你，给你一个字符串，可在任意位置添加字符，最少再添加几个字符，可以使这个字符串成为回文字符串。 输入 第一行给出整数N（0 接下来的N行，每行一个字符串，每个字符串长度不超过1000. 输出
Find a way
木槿花非花的博客
03-08 882
题目描述 Pass a year learning in Hangzhou, yifenfei arrival hometown Ningbo at finally. Leave Ningbo one year, yifenfei have many people to meet. Especially a good friend Merceki. Yifenfei’s home is at
数独
木槿花非花的博客
03-06 879
自从2006年3月10日至11日的首届数独世界锦标赛以后，数独这项游戏越来越受到人们的喜爱和重视。 据说，在2008北京奥运会上，会将数独列为一个单独的项目进行比赛，冠军将有可能获得的一份巨大的奖品———HDU免费七日游外加lcy亲笔签名以及同hdu acm team合影留念的机会。 所以全球人民前仆后继，为了奖品日夜训练茶饭不思。当然也包括初学者linle，不过他太笨了又没有多少耐性，只能做
三国志
木槿花非花的博客
03-18 836
题目描述 《三国志》是一款很经典的经营策略类游戏。我们的小白同学是这款游戏的忠实玩家。现在他把游戏简化一下，地图上只有他一方势力，现在他只有一个城池，而他周边有一些无人占的空城，但是这些空城中有很多不同数量的同种财宝。我们的小白同学虎视眈眈的看着这些城池中的财宝。 按照游戏的规则，他只要指派一名武将攻占这座城池，里面的财宝就归他所有了。不过一量攻占这座城池，我们的武将就要留守，不能撤回。
Number of Ways
木槿花非花的博客
04-30 795
Description You've got array a[1], a[2], ..., a[n], consisting of n integers. Count the number of ways to split all the elements of the array into three contiguous parts so that the sum of elemen
迷宫寻宝（一）
木槿花非花的博客
03-25 537
题目描述 一个叫ACM的寻宝者找到了一个藏宝图，它根据藏宝图找到了一个迷宫，这是一个很特别的迷宫，迷宫里有N个编过号的门（N   输入 输入可能会有多组测试数据（不超过10组）。 每组测试数据的第一行包含了两个整数M,N(1 .表示可以走的路 S:表示ACM的出发点 G表示宝藏的位置 X表示这里有墙，ACM无法进入或者穿过。 A,B,C,D,E表示这里是门，
组成最大多位数
木槿花非花的博客
11-04 439
描述 对n个数，组成最大多位数 输入 输入n，代表n个数，然后输n个数 输出 组成的最大多位数 样例输入 3 43 4 343 输出 443343 #include #include #include using namespace std; int weishu(int m){ int i=1; while(m=m/10){ i++; } return
救命！”王宫的的守卫听到公主的惊呼，推开门冲进去发现恶龙掳走了公主…… 题目描述 骑士回到王国发现公主被恶龙掳走了，骑士知道恶龙的巢穴在山谷 � y 点，而王国的位置在 � x 点。 拯救公主的路上有 � n 个补给点 ( 王国和恶龙巢穴也属于补给点 )， � n 个补给点由 � m 条双向道路连接起来，每条道路上都有一个恶龙的随从，每一个随从的战斗力不一定相同。 骑士虽然很焦急，但是他的战斗力是有限的，在找到恶龙前他并不希望遇到过于强大的敌人损耗自己的实力。所以请你规划一条从 � x 至 � y 的路线，使得经过的道路上的敌人的战斗力最大值最小。 输入格式 第一行有四个用空格隔开的 � n， � m， � x， � y，其含义见【题目描述】。 接下来 � m 行，每行三个整数 � u, � v, � w,表示有一条道路连接补给点 � u 和补给点 � v，且该道路上的敌人战斗力为 � w。 两个补给点之间可能存在多条道路，不同道路上的敌人战斗力也可能不同。 输出格式 输出一行一个整数，代表骑士遇到的敌人中的最高战斗力。 输入输出样例 输入 #1复制 4 6 1 4 1 2 1 2 3 5 3 4 2 1 3 2 1 4 3 2 4 3 输出 #1复制用c++做这道题
06-11
这道题目需要使用二分答案来解决。具体思路如下： 1. 定义一个结构体 Edge 表示边，其中包含起点、终点和边权。 2. 定义一个结构体 Node 表示节点，其中包含节点编号和从起点到该节点的最小距离。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值