HDU 2453 / UVA 4319 - Carrying Out A Task

最新推荐文章于 2019-08-13 10:37:55 发布
最新推荐文章于 2019-08-13 10:37:55 发布
阅读量1k 收藏 1
点赞数
分类专栏： ACM 文章标签： struct ini blog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/diannaok/article/details/7780391
版权
ACM 同时被 2 个专栏收录
111 篇文章 1 订阅
订阅专栏
搜索
22 篇文章 0 订阅
订阅专栏

 

简述一下题意：

20*20的地图上，一个起点S，一个终点E，障碍物#，漩涡*

一艘船从起点出发，携带充足的A类油和X升B类油。

沿上下左右四个方向行驶，不能在障碍物的格子行驶；可以进入漩涡，但每次进入船会受伤。没走过一个格子都要消耗一升A类油。

每个回合有两个操作：

1.普通航行一格

2.加速一次消耗Y升B类油，有两种加速方法，加速规则：

    a.在某一个方向连续航行d步，d步之内不能有障碍物、漩涡，不能驶出地图

    b.当下一步要驶入漩涡时，必须加速、进入漩涡后加速效果消失

询问船是否可以到达终点，输出最少多少个回合到达，前提——船受到的伤害最小（进入漩涡次数最少），其次消耗A类油最少（走过的格子数最少），再次回合数最少。

 

------------------------------题意摘自： http://hi.baidu.com/alpc62/blog/item/ceb5128216a4f7a50cf4d2f8.html---------------------------------

 

HDU题目地址： http://acm.hdu.edu.cn/showproblem.php?pid=2453

 

UVA题目地址： http://livearchive.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2320

 

2008年哈尔滨赛区的的题目。

  

简述方法：限制条件的SPFA。用优先队列，不断更新符合要求的最短路径。

                        利用num[横坐标][纵坐标][受伤次数] 来记录所剩余的最大加速次数，如果后来者所存有的加速次数比先到者的多，就再走一遍。

                        利用优先队列，按照 1. 受伤次数最少  、 2. 耗A量最少   、3. 步数最少 ，按顺序进行优先级排序，依次最少的先出队列

                        这里有两个比较好的剪枝:

                                          1. 先搜索一遍，能否到达终点 

                                          2.  num[x][y][当前受伤次数-1]的位置如果已经走过，就不再走，既然少受伤一次能都路过，现在就不必再走了

 

====================================================================================================

 

WA了几天

 

现在已经AC了~~

 

灰常感谢 helaoxuan 大牛， 问的几个人中，只有他回复了邮件！！！ 解答了我的疑惑！！！！

 

错的原因很简单，题意理解搓了， 我将B类油与A类油的消耗分开，也就是说在消耗B油加速时，所走的路不消耗A类油

 

按照我的理解， 下面注释的数据中，case1的答案应该是5，case2的答案应该是6，case4的答案应该是6.

 

但其实，真正的题意是，每走一个格子，不管是否加速状态，都需要消耗一个A的油量~~

 

 

 

#include<iostream>
#include<cstdio>
#include<queue>
#include<algorithm>
#include<cstring>

using namespace std;

const int maxn=22;
const int fy[]={0,0,-1,1};
const int fx[]={1,-1,0,0};

struct Point{ // damage ，B-cost，A-cost 
	int x,y,step,dmg,bcst,acst;
	Point(){}
	Point(int tx,int ty,int ts,int td,int ta,int tb){
		x=tx,y=ty,step=ts,dmg=td,acst=ta,bcst=tb;
	}
	bool friend operator<(Point p,Point q){
		if(p.dmg!=q.dmg) return p.dmg>q.dmg;
		if(p.acst!=q.acst) return p.acst>q.acst;
		return p.step>q.step;
	}
}; 
struct Cdnt{ // Coordinate 
	int x,y,cst;
	Cdnt(){};
	Cdnt(int tx,int ty,int tc){x=tx,y=ty,cst=tc;} 
	bool friend operator<(Cdnt p,Cdnt q){
		return p.cst>q.cst;
	}
};
char mp[maxn][maxn];
int n,m,sx,sy,dis; 

int CBA(){ // E can be arrived ? Return the number of damage.
	int k;
	bool vis[maxn][maxn];
	Cdnt now,next;
	priority_queue<Cdnt>q;
	memset(vis,false,sizeof(vis));
	q.push(Cdnt(sx,sy,0));
	vis[sx][sy]=true;
	while(!q.empty()){
		now=q.top();
		q.pop();
		if(mp[now.x][now.y]=='E') return now.cst;
		for(k=0;k<4;k++){
			next.x=now.x+fx[k];
			next.y=now.y+fy[k];
			if(next.x<0 || next.x>=n || next.y<0 || next.y>=m) continue;
			if(vis[next.x][next.y] || mp[next.x][next.y]=='#') continue;
			if(mp[next.x][next.y]=='*') next.cst=now.cst+1;
			else next.cst=now.cst;
			vis[next.x][next.y]=true; 
			q.push(next);
		} 
	}
	return -1;
}

priority_queue<Point>que;

short num[maxn][maxn][maxn*maxn]; //  [x][y][number of undercurrent] for accelerate

void init_(int res){
	for(int i=0;i<n;i++)
		for(int j=0;j<m;j++)
			for(int k=0;k<=res;k++)
				num[i][j][k]=-1;
	while(!que.empty()) que.pop();
}

int bfs(int v){ // v  ->  The number of total acceleration.
	int res,k,z;
	Point now,next;
	res=CBA();
	if(res==-1 || res>v) return -1;
	init_(res+1);
	que.push(Point(sx,sy,0,1,0,v));
	num[sx][sy][1]=v;
	while(!que.empty()){
		now=que.top();
		que.pop();
//		cout<<now.x<<" "<<now.y<<endl;
		if(mp[now.x][now.y]=='E') return now.step;
		for(k=0;k<4;k++){
			if(now.bcst>res-now.dmg){
				next=now;
				for(z=0;z<dis;z++){
					next.x+=fx[k];
					next.y+=fy[k];
					if(next.x>=n || next.y>=m || next.x<0 || next.y<0) break;
					if(mp[next.x][next.y]=='#' || mp[next.x][next.y]=='*') break;
				}
				if(z==dis){
					next.step++;
					next.bcst--;
					next.acst+=dis;
					if(num[next.x][next.y][next.dmg]<next.bcst && num[next.x][next.y][next.dmg-1]==-1){
						num[next.x][next.y][next.dmg]=next.bcst;
						que.push(next);
					}
				}
			}
			next=now;
			next.x+=fx[k];
			next.y+=fy[k];
			next.step++;
			next.acst++;
			if(next.x>=n || next.y>=m || next.x<0 || next.y<0) continue;
			if(mp[next.x][next.y]=='#') continue;
			if(mp[next.x][next.y]=='*'){
				if(next.bcst>0) next.bcst--,next.dmg++;
				else continue;
			}
			if(num[next.x][next.y][next.dmg]<next.bcst && num[next.x][next.y][next.dmg-1]==-1){
				num[next.x][next.y][next.dmg]=next.bcst;
				que.push(next);
			}
		}
	}
	return -1;
}

int main(){
	int t,i,j,res;
	scanf("%d",&t);
	while(t--){
		scanf("%d%d\n",&n,&m);
		for(i=0;i<n;i++){
			gets(mp[i]);
			for(j=0;j<m;j++)
				if(mp[i][j]=='S')
		  			sx=i,sy=j;
		}
		scanf("%d",&dis);
		scanf("%d%d",&i,&j);
		res=bfs(i/j);
		if(res==-1) puts("can not reach!");
		else printf("%d\n",res);
	}	
	return 0;
}





/*
Case1:-----------------------------------
1
7 9
#########
#  ######
#S      #
# ##### #
# #   #*#
#     *E#
#########
4
4 1
answer1: 6 -----------------------------------
Case2:-----------------------------------
1
8 8
######## 
#S     #  
#  ### #
## # # #
# E  # #
# #### # 
#      #
########
5
3 1
answer2: 4 -----------------------------------
Case3:-----------------------------------
1
20 20
####################
#S                 #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                  #
#                 E#
####################
17
2 1
answer3: 2 -----------------------------------
Case4:-----------------------------------
1
20 20
####################
#S                 #
#           ###### #
#           #      #
#             #    #
#           # #### #
#           #      #
#           #      #
#           #      #
#           # ######
#                  #
#           #    # #
#           #    # #
#### ##### ##    # #
#    #           # #
#    #           # #
#    #           # #
#    ##### ####### #
#                 E#
####################
9
6 1
answer4: 18 -----------------------------------
*/

 

 

 

 

其实我还是蛮舍不得以前的代码，所以贴出来一起分享：

 

如果在消耗B类油的时候，不消耗A类油。也就是说，两种加速：不管是加速进入旋窝，还是往前加速d个单元格，都不耗A类油。

 

前提还是一样的。 第一前提：伤害最少、第二前提：A耗最少、第三前提：步数最少

 

那么代码应该如下：

 

#include<iostream>
#include<cstdio>
#include<queue>
#include<algorithm>
#include<cstring>

using namespace std;

const int maxn=22;
const int fy[]={0,0,-1,1};
const int fx[]={1,-1,0,0};

struct Point{ // damage ，B-cost，A-cost 
    int x,y,step,dmg,bcst,acst;
    Point(){}
    Point(int tx,int ty,int ts,int td,int ta,int tb){
        x=tx,y=ty,step=ts,dmg=td,acst=ta,bcst=tb;
    }
    bool friend operator<(Point p,Point q){
        if(p.dmg!=q.dmg) return p.dmg>q.dmg;
        if(p.acst!=q.acst) return p.acst>q.acst;
        return p.step>q.step;
    }
}; 
struct Cdnt{ // Coordinate 
    int x,y,cst;
    Cdnt(){};
    Cdnt(int tx,int ty,int tc){x=tx,y=ty,cst=tc;} 
    bool friend operator<(Cdnt p,Cdnt q){
        return p.cst>q.cst;
    }
};
char mp[maxn][maxn];
int n,m,sx,sy,dis; 

int CBA(){ // E can be arrived ? Return the number of damage.
    int k;
    bool vis[maxn][maxn];
    Cdnt now,next;
    priority_queue<Cdnt>q;
    memset(vis,false,sizeof(vis));
    q.push(Cdnt(sx,sy,0));
    vis[sx][sy]=true;
    while(!q.empty()){
        now=q.top();
        q.pop();
        if(mp[now.x][now.y]=='E') return now.cst;
        for(k=0;k<4;k++){
            next.x=now.x+fx[k];
            next.y=now.y+fy[k];
            if(next.x<0 || next.x>=n || next.y<0 || next.y>=m) continue;
            if(vis[next.x][next.y] || mp[next.x][next.y]=='#') continue;
            if(mp[next.x][next.y]=='*') next.cst=now.cst+1;
            else next.cst=now.cst;
            vis[next.x][next.y]=true; 
            q.push(next);
        } 
    }
    return -1;
}

priority_queue<Point>que;

short num[maxn][maxn][maxn*maxn]; //  [x][y][number of undercurrent] for accelerate
short cost[maxn][maxn][maxn*maxn]; //  cost of A

void init_(int res){
    int i,j,k;
    for(i=0;i<n;i++)
        for(j=0;j<m;j++)
            for(k=0;k<=res;k++)
                cost[i][j][k]=maxn*maxn,num[i][j][k]=-1;
    while(!que.empty()) que.pop();
}

int bfs(int v){ // v  ->  The number of total acceleration.
    int res,k,z;
    Point now,next;
    res=CBA();
    if(res==-1 || res>v) return -1;
    init_(res+1);
    que.push(Point(sx,sy,0,1,0,v));
    cost[sx][sy][1]=0;
    num[sx][sy][1]=v;
    while(!que.empty()){
        now=que.top();
        que.pop();
//        cout<<now.x<<" "<<now.y<<endl;
        if(mp[now.x][now.y]=='E') return now.step;
        for(k=0;k<4;k++){
            if(now.bcst>res-now.dmg){
                next=now;
                for(z=0;z<dis;z++){
                    next.x+=fx[k];
                    next.y+=fy[k];
                    if(next.x>=n || next.y>=m || next.x<0 || next.y<0) break;
                    if(mp[next.x][next.y]=='#' || mp[next.x][next.y]=='*') break;
                }
                if(z==dis){
                    next.step++;
                    next.bcst--;
                    if((cost[next.x][next.y][next.dmg]>next.acst || num[next.x][next.y][next.dmg]<next.bcst)&& num[next.x][next.y][next.dmg-1]==-1){
                        if(cost[next.x][next.y][next.dmg]>next.acst)
                            cost[next.x][next.y][next.dmg]=next.acst;
                        if(num[next.x][next.y][next.dmg]<next.bcst)
                            num[next.x][next.y][next.dmg]=next.bcst;
                        que.push(next);
                    }
                }
            }
            next=now;
            next.x+=fx[k];
            next.y+=fy[k];
            next.step++;
            next.acst++;
            if(next.x>=n || next.y>=m || next.x<0 || next.y<0) continue;
            if(mp[next.x][next.y]=='#') continue;
            if(mp[next.x][next.y]=='*'){
                if(next.bcst>0) next.bcst--,next.acst--,next.dmg++;
                else continue;
            }
            if((cost[next.x][next.y][next.dmg]>next.acst || num[next.x][next.y][next.dmg]<next.bcst)&& num[next.x][next.y][next.dmg-1]==-1){
                if(cost[next.x][next.y][next.dmg]>next.acst)
                    cost[next.x][next.y][next.dmg]=next.acst;
                if(num[next.x][next.y][next.dmg]<next.bcst)
                    num[next.x][next.y][next.dmg]=next.bcst;
                que.push(next);
            }
        }
    }
    return -1;
}

int main(){
    int t,i,j,res;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d\n",&n,&m);
        for(i=0;i<n;i++){
            gets(mp[i]);
            for(j=0;j<m;j++)
                if(mp[i][j]=='S')
                      sx=i,sy=j;
        }
        scanf("%d",&dis);
        scanf("%d%d",&i,&j);
        res=bfs(i/j);
        if(res==-1) puts("can not reach!");
        else printf("%d\n",res);
    }    
    return 0;
}


 


 

diannaok
关注
专栏目录
HDU-EID-V2-核心板1
08-03
在本话题中，我们关注的是一个名为"HDU-EID-V2-核心板1"的特定设计，它涉及到STM32的核心组件、接口、电源管理和调试配置。 首先，核心板设计中提到了F103和F207两个型号的STM32芯片。F103和F207属于STM32的不同...
HDU-EID-V2-扩展板1
08-04
HDU-EID-V2-扩展板1是一款专为STM32微控制器设计的硬件扩展板，主要用于增强核心板的功能。该扩展板具有多种接口和功能，包括ADC（模数转换器）、电位器、DAC（数模转换器）输出以及TEST_V跳线，能够满足用户在模拟...
Carrying Out A Task（bfs)
eazo的博客
08-09 286
题目描述 During the process of the military exercise, there is a ship on the sea level .The ship will go to certain place to carry out a task. For every action, the ship has two ways to sail. They are nor...
Carrying Out A Task
weixin_41370251的博客
08-13 272
题目描述 During the process of the military exercise, there is a ship on the sea level .The ship will go to certain place to carry out a task. For every action, the ship has two ways to sail. They are no...
hdu 2453
qqspeed
10-07 1323
题目 在一个n*m的海域里，B类油有限的情况下，从起点到终点的最少操作数（船的损坏最小，其次A类油用的尽量少） ‘#’不能走，其他时候有两种操作方式:1.在空白海域，一次走一格，2.在有一条长度>=d的连续空白海域，可以在消耗B类油的情况下，一次走d格，在暗流中，必须使用这种方式，但一次只能运行一格。 然后是不管在何种海域，只要走一格就要消耗一旦为 优先队列广搜，优先级：选损坏最小的，如果
hdu(数值计算 概率）
u011275047的专栏
07-23 615
Candy                                  Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Problem Description LazyChild is a lazy child who likes candy very much. D
HDU6025-Coprime Sequence-简单数学
survivorone的博客
05-07 1586
//传送门： http://acm.hdu.edu.cn/showproblem.php?pid=6025 #include #include #include #include #include #include using namespace std; #define LL long long #define N 1000005 #define M 2005 #define INF
HDU 2973 / UVa 1434 / CERC 2008 YAPTCHA (威尔逊定理及其逆定理)
AC，∑ndless
01-24 3157
http://acm.hdu.edu.cn/showproblem.php?pid=2973 思路： 当n是合数时，((n-1)!+1)/n不为整数，所以在题目的和式中该部分为0；n是质数时就为1了。 所以筛一遍素数就出符合3k+7类型的素数即可。 额外说一句，当a,b互素时，形如an+b的素数有无穷个。（wiki:Dirichlet's theorem o
UVALive5642 UVA706 HDU1332 POJ1102 LC-Display【打印图案】
海岛Blog
05-14 1561
LC-DisplayTime Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 1647    Accepted Submission(s): 656Problem Description A friend of you has just bought...
hdu-2037/akoj-1251-今年暑假不AC（C#结构体排序）
jtahstu的专栏
08-08 9232
今年暑假不AC                                                        Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)                                                   
hdu1667-IDA*-迭代加深搜索 A*算法
WilliamSun0122的博客
05-16 4793
迭代加深搜索迭代加深搜索，实质上是限定下界的深度优先搜索。即首先允许深度优先搜索K层，若没有发现可行解，再将K+1后重复以上步骤搜索（即深度优先搜索k+1层），直到搜索到可行解。在迭代加深搜索的算法中，连续的深度优先搜索被引入，每一个深度约束逐次加1，直到搜索到目标为止。可以看出，很多情况会重复搜索。但是它的好处在于： 空间开销小。每个深度下实际上是一个有深度限制的深度优先搜索。而DFS的空间消耗小
hdu-page-11-answer.rar_hdu_hdu oj第十一页_page_搜题_杭电oj
09-14
本资料"HDU Page 11 Answer"正是针对杭电OJ中第11页的题目，提供了一系列题解，旨在帮助初学者快速掌握基础算法，并提升编程能力。 一、ACM入门基础知识 ACM竞赛强调的是团队协作和快速解决问题的能力，其核心是...
hdu-OS-simple-shell，Linux_的_Shell_命令窗口_demo_版实现_shell-demo.zip
09-17
hdu-OS-simple-shell，Linux_的_Shell_命令窗口_demo_版实现_shell-demo
HDU实验板操作手册-STM32F1031
08-03
HDU实验板操作手册-STM32F1031主要涵盖了四个关键部分，旨在帮助用户熟悉并有效地使用基于STM32F1031的开发板进行嵌入式系统开发。以下是各部分的详细说明： 1. **开发板外观说明** 开发板设计紧凑，左侧和上侧...
HDU-4467-Graph（莫队思想）
sugarbliss
01-08 213
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4467 题意：给你n个点，m条边，每条边有一个权值，有两个操作，一个是修改单点的颜色（颜色只有0,1两种），一个是询问边的两个端点都为指定颜色的权值和。 思路：由于每个点的颜色只有0，1两种，那么答案只有3种情况（00,01,11），用一个数组维护即可。即ans[0]统计边的两端都是0的权值和，an...
数据分析高级培训：客户体验分析-课件
11-10
课程目标： 本课程旨在让学员了解什么是客户体验，客户服务体验的重要性以及常见指标，掌握客户体验的分析方法，学会客户问题的识别以及针对问题制定有效的解决方案。 课程大纲： 客户体验的概述 客户体验的分析方法 客户问题解决的方法论
【微电网潮流】分布式电源微电网潮流【Matlab仿真 7357期】.zip
最新发布
11-10
CSDN Matlab武动乾坤上传的资料均有对应的代码，代码均可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
Unity3d-lesson_EVAC-CITY.zip
11-10
Unity3d实例工程，供学习参考
A - LOOPS HDU - 3853
07-28
所以，问题A - LOOPS HDU - 3853是关于解决迷宫问题的一个题目。 #### 引用[.reference_title] - *1* *3* [期望DP——C - LOOPS HDU - 3853](https://blog.csdn.net/GreyBtfly/article/details/80534173)[target="_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值