Maze Stretching Poj3897 二分+BFS

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.

 

 

题意：给出一张标记了起点和终点的图，对纵轴进行伸缩变换使从起点到终点的最短路等于给定值。

分析：

　　二分伸缩的可能情况，对于每种伸缩都有对应不同的最短路，那么对路程总值val进行标记，记录下BFS中到达每一点的最短路程，

最后返回终点的最短路程，继续二分。

 

 

 

一开始简单的认为最短路一定是固定的 ，其实不然，看张图

#######

#  S       #

#  ###   #

#  #E     #

#  #   ###

#       ###

#######

此时当纵向伸缩足够小时，就变成了从左边走为最短路。

 

然后继续简单的认为用优先队列记录step就能解决问题。。。。。。

其实不然，看张图。。。。。。

###  ###

###  ###

       E

###  ###

###  ###

 

当从四个方向接近E时可能发生这种情况：横向与竖向同时距离终点一格而竖向或横向的到终点step更小；

当然,也有可能还有其它图有各种方案到达E并且step更小（脑补）。

 

*所以这里要想不管这么多就直接暴搜全图并记录最短路径值吧。

 

Q：为什么想到二分？

A：感觉。。。。。。

 

仔细想想这题 还是蛮有意思的

 

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

#define eps 1e-9
#define INF 0x3f3f3f3f
using namespace std;

struct node
{
    int x,y;
    double step;
    friend bool operator < (node A,node B)
    {
        return A.step>B.step;
    }
};

priority_queue<node>que;

char g[105][105];
int vis[105][105];
double val[105][105];//存储每次BFS的最短路径值
int dir[][5]={{-1,0},{1,0},{0,-1},{0,1}};
int x,y,xx,yy;
int n,m;
double aim;


bool judge(int a,int b)
{
    if(a>=0&&a<n&&b>=0&&b<m) return true;
    return false;
}

double bfs(double mid)
{
    while(que.size()) que.pop();
    memset(vis,0,sizeof vis);

    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
        val[i][j]=INF;

    node k;
    k.x=x;
    k.y=y;
    k.step=0;
    que.push(k);

    while(que.size())
    {
        k=que.top();
        que.pop();

        for(int i=0;i<4;i++)
        {
            node temp=k;
            temp.x+=dir[i][0];
            temp.y+=dir[i][1];
            if(judge(temp.x,temp.y)&&g[temp.x][temp.y]!='#')
            {
                vis[temp.x][temp.y]=1;
                double T_T;
                if(i==0||i==1) T_T=mid;
                else T_T=1;
                temp.step+=T_T;//= =、 

                if(!vis[temp.x][temp.y]||(vis[temp.x][temp.y]&&temp.step<val[temp.x][temp.y]))
//未访问过或者访问过但此时值更小，记录。
                {
                    vis[temp.x][temp.y]=1;
                    val[temp.x][temp.y]=temp.step;
                    que.push(temp);
                }

            }
        }
    }
    return val[xx][yy];
}

int main()
{
    int T;
    double ans;
    scanf("%d",&T);
    for(int k=1;k<=T;k++)
    {
        scanf("%lf%d",&aim,&n);
        getchar();
        for(int i=0;i<n;i++)
            gets(g[i]);

        m=strlen(g[0]);

        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
            if(g[i][j]=='S')
            {
                x=i;
                y=j;
            }
            else if(g[i][j]=='E')
            {
                xx=i;
                yy=j;
            }


        double r=0,l=1000000;
        while(r+eps<l)
        {
            double mid=(r+l)/2;
            if(bfs(mid/100)>aim) l=mid;
            else r=mid;
        }
        ans=r;
        printf("Case #%d: %.3lf%%
",k,ans);
    }
}