Ignatius and the Princess I
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 16456 Accepted Submission(s):
5221
Special Judge
Problem Description
The Princess has been abducted by the BEelzebub
feng5166, our hero Ignatius has to rescue our pretty Princess. Now he gets into
feng5166‘s castle. The castle is a large labyrinth. To make the problem simply,
we assume the labyrinth is a N*M two-dimensional array which left-top corner is
(0,0) and right-bottom corner is (N-1,M-1). Ignatius enters at (0,0), and the
door to feng5166‘s room is at (N-1,M-1), that is our target. There are some
monsters in the castle, if Ignatius meet them, he has to kill them. Here is some
rules:
1.Ignatius can only move in four directions(up, down, left,
right), one step per second. A step is defined as follow: if current position is
(x,y), after a step, Ignatius can only stand on (x-1,y), (x+1,y), (x,y-1) or
(x,y+1).
2.The array is marked with some characters and numbers. We define
them like this:
. : The place where Ignatius can walk on.
X : The place is
a trap, Ignatius should not walk on it.
n : Here is a monster with n
HP(1<=n<=9), if Ignatius walk on it, it takes him n seconds to kill the
monster.
Your task is to give out the path which costs minimum seconds
for Ignatius to reach target position. You may assume that the start position
and the target position will never be a trap, and there will never be a monster
at the start position.
Input
The input contains several test cases. Each test case
starts with a line contains two numbers N and M(2<=N<=100,2<=M<=100)
which indicate the size of the labyrinth. Then a N*M two-dimensional array
follows, which describe the whole labyrinth. The input is terminated by the end
of file. More details in the Sample Input.
Output
For each test case, you should output "God please help
our poor hero." if Ignatius can‘t reach the target position, or you should
output "It takes n seconds to reach the target position, let me show you the
way."(n is the minimum seconds), and tell our hero the whole path. Output a line
contains "FINISH" after each test case. If there are more than one path, any one
is OK in this problem. More details in the Sample Output.
Sample Input
5 6
.XX.1.
..X.2.
2...X.
...XX.
XXXXX.
5 6
.XX.1.
..X.2.
2...X.
...XX.
XXXXX1
5 6
.XX...
..XX1.
2...X.
...XX.
XXXXX.
Sample Output
It takes 13 seconds to reach the target position, let me show you the way.
1s:(0,0)->(1,0)
2s:(1,0)->(1,1)
3s:(1,1)->(2,1)
4s:(2,1)->(2,2)
5s:(2,2)->(2,3)
6s:(2,3)->(1,3)
7s:(1,3)->(1,4)
8s:FIGHT AT (1,4)
9s:FIGHT AT (1,4)
10s:(1,4)->(1,5)
11s:(1,5)->(2,5)
12s:(2,5)->(3,5)
13s:(3,5)->(4,5)
FINISH
It takes 14 seconds to reach the target position, let me show you the way.
1s:(0,0)->(1,0)
2s:(1,0)->(1,1)
3s:(1,1)->(2,1)
4s:(2,1)->(2,2)
5s:(2,2)->(2,3)
6s:(2,3)->(1,3)
7s:(1,3)->(1,4)
8s:FIGHT AT (1,4)
9s:FIGHT AT (1,4)
10s:(1,4)->(1,5)
11s:(1,5)->(2,5)
12s:(2,5)->(3,5)
13s:(3,5)->(4,5)
14s:FIGHT AT (4,5)
FINISH
God please help our poor hero.
FINISH
这个题应该可以算是基础搜索吧，很久没做搜索了，在题解的帮助下成功ac。保存路径的思想以后可以借鉴。使用了优先队列。
使用优先队列，队头一直是当前耗时最小的，这个运算符重载要记住。
用flag数组保存这个结点是从哪个方向来的，每个点的方向只会更新一次，因为第一次到达该点为最优（也可以理解为到了过后就用vis标记），用于记录路径，递归回溯输出。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
#include<queue>
using namespace std;
#define INF 999999999
struct Node
{
int x,y;
int tim;
friend bool operator<(Node a,Node b)
{
return a.tim>b.tim;
}
};
char map[105][105];
int dir[4][2]= {{-1,0},{0,1},{1,0},{0,-1}};
int flag[105][105];
int vis[105][105];
int n,m;
bool inside(Node nn)
{
if(nn.x>=0&&nn.x<n&&nn.y>=0&&nn.y<m)
return 1;
return 0;
}
int ans=INF;
priority_queue<Node> pq;
int bfs()
{
Node sta;
sta.x=0;
sta.y=0;
sta.tim=0;
pq.push(sta);
vis[sta.x][sta.y]=1;
while(!pq.empty())
{
Node now=pq.top();
if(now.x==n-1&&now.y==m-1)
return 1;
pq.pop();
for(int i=0;i<4;i++)
{
Node next;
next.x=now.x+dir[i][0];
next.y=now.y+dir[i][1];
if(!vis[next.x][next.y]&&inside(next)&&map[next.x][next.y]!=‘X‘)
{
flag[next.x][next.y]=i+1;
if(map[next.x][next.y]==‘.‘)
next.tim=now.tim+1;
else
next.tim=now.tim+1+map[next.x][next.y]-‘0‘;
pq.push(next);
vis[next.x][next.y]=1;
}
}
}
return 0;
}
void printpath(int x,int y,int time)
{
if(flag[x][y]==0)
return;
int add=0;
if(map[x][y]!=‘.‘)
add=map[x][y]-‘0‘;
printpath(x-dir[flag[x][y]-1][0],y-dir[flag[x][y]-1][1],time-1-add);
if(map[x][y]!=‘.‘)
{
printf("%ds:(%d,%d)->(%d,%d)\n",time-add,x-dir[flag[x][y]-1][0],y-dir[flag[x][y]-1][1],x,y);
for(int i=1;i<=map[x][y]-‘0‘;i++)
printf("%ds:FIGHT AT (%d,%d)\n",time-add+i,x,y);}
else
printf("%ds:(%d,%d)->(%d,%d)\n",time,x-dir[flag[x][y]-1][0],y-dir[flag[x][y]-1][1],x,y);
}
int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
memset(vis,0,sizeof(vis));
memset(flag,0,sizeof(flag));
while(!pq.empty())
pq.pop();
memset(vis,0,sizeof(vis));
for(int i=0; i<n; i++)
scanf("%s",map[i]);
int findit=bfs();
if(findit)
{
printf("It takes %d seconds to reach the target position, let me show you the way.\n",pq.top().tim);
printpath(pq.top().x,pq.top().y,pq.top().tim);
}
else
printf("God please help our poor hero.\n");
printf("FINISH\n");
}
return 0;
}