poj3897 Maze Stretching 二分+bfs

Maze Stretching

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 765		Accepted: 206

Description

Usually the path in a maze is calculated as the sum of steps taken from the starting point until the ending point, assuming that the distance of one step is exactly 1. Lets assume that we could “stretch” (shorten or extend) the maze in vertical dimension (north-south). By stretching, we are just changing the passed distance between two cells. (it becomes X instead of one). We have a two dimensional maze which has '#' for walls, 'S' in the starting cell and 'E' at the ending cell. 
Due to outside conditions, we need to make the shortest path to be exactly L in size. We are not allowed to change the maze configuration, nor to make any changes in the horizontal dimension. We are only allowed to stretch the vertical dimension, and that can be done by any percentage. 
Find the percentage of the stretch P, for which the shortest path of the maze will be exactly L.

Input

First line of the input contains the number of test cases. For each test case, firstly two numbers L and N are given, where L is the required length of the shortest path and N is the number of lines that are given describing the maze. The following N lines describes the maze such as that each line describes a row of the maze. (Each row length is the horizontal dimension of the maze).

Output

For each test case output the percentage of the stretch in the following format: 
Case #K: P% 
- P should have leading zero if the number is between 0 and 1. 
- P should be rounded up on 3 decimals, and always formatted on 3 decimals (with trailing zeros if needed).

Sample Input

2
2.5 4
#####
#S  #
#  E#
#####
21 13
############
#S##     #E#
# ##  #  # #
#   # #  # #
### # #  # #
#   # #  # #
#  ## #  # #
##  # #  # #
### # #  # #
##  # #  # #
#  ## #    #
#     #    #
############

Sample Output

Case #1: 50.000%
Case #2: 21.053%

Hint

Constraints 
The height and width of the maze are maximum 100 cells. 
All the lines describing one maze are the same size. 
There will always be a solution. 
The result will be between 0.000 and 1000.000 inclusive 
There will be no direct horizontal only path connecting 'S' and 'E'. (the result is always unique). 

Explanation of the first test case in the example: On the original maze, the length of the shortest path is 3 because there are two horizontal steps and a vertical one. Our goal is to make the length of the shortest path to be 2.5. That’s why we have to “stretch” the vertical dimension of the maze by a percentage value less than 100. In this case it is 50% which actually changes the vertical distance between two cells to 0.5.

Source

这个其实是我在百度上看到的解题报告，好不容易看懂了又重写一遍，一直WA，最后我直接提交百度到的解题报告的代码，谁知道也是WA，这可真够无语的，第一次遇见这样的情况。。。最后才知道是标记的问题，用这种方法得用三维数组判重，因为它从x和y方向走过来的是不一样的

这题思路：二分查找最优解+bfs+优先队列+三维判重。每一次二分查找都要bfs一次

#include<iostream>
#include<queue>
#include<string.h>
#include<stdio.h>
//#include<>

using namespace std;
char map[120][120];
int vis[120][120][2],n;
int dx[]={0,0,-1,1},dy[]={1,-1,0,0},m;

struct point
{
	int x,y;
}start,end;

struct que
{
	double len;
	point p;
	friend bool operator <(que x,que y)//重载了<运算符，这里建立了一个队头尾最小距离的队列。这个运算符只能重载<,没有>d的
	{
		return x.len>y.len;
	}
};//第一次用优先队列，在网上看了不少

priority_queue<que>map2;

int equal(point x,point y)//判断是否到达终点的
{
	if(x.x==y.x&&x.y==y.y)//好吧，看起来有点乱
		return 1;
	return 0;
}

int bound(point a)//判断边界
{
	if(a.x<=m&&a.y<=n&&a.x>0&&a.y>0)
		return 1;
	else return 0;
}

double bfs(double mid)
{
	int i; 
	point t;
   que s,tem;  
	while(!map2.empty())  //清空队列
      map2.pop(); 
   s.p=start;
   s.len=0;
   map2.push(s);//入队
   memset(vis,0,sizeof(vis));
   vis[s.p.y][s.p.x][0]=1;
   vis[s.p.y][s.p.x][1]=1;
   while(!map2.empty())//这是封装的判断是否为空的函数
   {
	   que top=map2.top();//取优先级最高的那个
	   map2.pop();//这个是删除优先级最高的那个
	   for(i=0;i<4;i++)
	   {
		   t.x=top.p.x+dx[i];
		   t.y=top.p.y+dy[i];
		   if(!bound(t))
			   continue ;
		   if(vis[t.y][t.x][i/2])//已访问
			   continue;
		   if(map[t.y][t.x]!=' ')//可以走
			   continue ;
		   tem=top;
		   tem.p=t;
		   tem.len+=i<2?mid:1;
		   if(equal(t,end))//找到了
			   return tem.len;
		   vis[tem.p.y][tem.p.x][i/2]=1;//y方向是0，
		   map2.push(tem);//入队
	   }
   }
   return 1;
}
int main()
{
	int i,j,t,cas;
	double le,mid,r,tt,ans;
	char c;
	double L;
	cin>>t;
	cas=0;
	while(t--)
	{
		cas++;
		cin>>L>>n;
		getchar();
	memset(map,' ',sizeof(map));
		for(i=1;i<=n;i++)
		{
			gets(map[i]+1);
			for(j=1;map[i][j];j++)
			{
			//	c=getchar();//输入数据没有说宽度所以得用gets
				if(map[i][j]=='E')//表示可走。该题做法要求这样
				{
					map[i][j]=' ';
					end.x=j;
					end.y=i;
				}
				else if(map[i][j]=='S')
				{
					map[i][j]=' ';
					start.x=j;
					start.y=i;
				}
			}
		}
		m=strlen(map[1]+1);
		r=1000.00;
		le=0;
		ans=0;
		while(r-le>1e-7)//二分查找啦
		{
			mid=(r+le)/2;
			tt=bfs(mid);
			if(L-tt>1e-8)//小了，还要向右移动
			{
				le=mid;	
			}
			else r=mid;//大了，向左移动
		}
		ans=mid;
		printf("Case #%d: %0.3lf%%\n",cas,ans*100);
	}
	return 0;
}