EOJ：Maze Stretching

Maze Stretching

Time Limit: 1000MS		Memory Limit: 65536K
Total Submits: 107		Accepted: 20

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).

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).

 

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

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.

原题地址：http://www.cn210.com/onlinejudge/problemshow.php?pro_id=200

____________________________________________________________________________________________________

题解：

题目要求的是改变之后的最短路刚好等于L，但是题目的HINT让人觉得是先求最短路，然后改变百分比使得其长度变成L。

 

题目理解对了就没什么问题了。

主要是二分答案的思想。

DIJ求最短路套了交大模板。

 

 

#include<stdio.h>
#include<math.h>
#include<string.h>
 const int inf=1000000000;
 #define maxm 100000
 #define maxn 100005
 int n,m,len,next[maxm],ev[maxm],ew[maxm];
 int mk[maxn],nbs[maxn],ps[maxn],heap[maxn];
 char str[105][105];
int r,c,i,j,t,tt,s,e,num;
double ans,ll,rr,mm,value[maxn],l;
void update(int r)
{
    int q=ps[r],p=q>>1;
    while (p&&value[heap[p]]>value[r])
    {
        ps[heap[p]]=q;
        heap[q]=heap[p];
        q=p;
        p=q>>1;
    }
    heap[q]=r;ps[r]=q;
}
int getmin()
{
    int ret=heap[1],p=1,q=2,r=heap[len--];
    while(q<=len)
    {
        if (q<len&&value[heap[q+1]]<value[heap[q]]) q++;
        if (value[heap[q]]<value[r])
        {
            ps[heap[q]]=p;
            heap[p]=heap[q];
            p=q;q=p<<1;
        }
        else break;
    }
        heap[p]=r;
        ps[r]=p;
        return ret;
}
void dijkstra(int src,int dst,double l)
{
    int i,j,u,v;
    double lv;
    for (i=1;i<=n;i++)
    {
        value[i]=inf;
        mk[i]=ps[i]=0;
    }
    value[src]=0;
    heap[len=1]=src;
    ps[src]=1;
    while (!mk[dst])
    {
        if (len==0) return;
        u=getmin();
        mk[u]=1;
        for (j=nbs[u];j;j=next[j])
        {
            v=ev[j];
            if (ew[j]==-1)
                lv=l;
            else lv=ew[j];
            if (!mk[v]&&value[u]+lv<value[v])
            {
                if (ps[v]==0)
                {
                    heap[++len]=v;
                    ps[v]=len;
                }
                value[v]=value[u]+lv;
                update(v);
            }
        }
    }
}
void creat(int u,int v,int w)
{
    next[++num]=nbs[u];
    nbs[u]=num;
    ev[num]=v;
    ew[num]=w;
}
int main()
{
    scanf("%d",&tt);
    for (t=1;t<=tt;t++)
    {
        memset(nbs,0,sizeof(nbs));
        memset(next,0,sizeof(next));
        scanf("%lf%d",&l,&r);
        getchar();
        for (i=0;i<r;i++)
            gets(str[i]);
        c=strlen(str[0]);
        num=0;
        for (i=0;i<r-1;i++)
            for (j=0;j<c-1;j++)
            {
                if (str[i][j]=='S')
                    s=j+i*c+1;
                if (str[i][j]=='E')
                    e=j+i*c+1;
                if (str[i][j]!='#')
                {
                    if (str[i+1][j]!='#')
                    {
                        creat(j+c*i+1,j+c*(i+1)+1,-1);
                        creat(j+c*(i+1)+1,j+c*i+1,-1);
                    }
                    if (str[i][j+1]!='#')
                    {
                        creat(j+c*i+1,j+2+c*i,1);
                        creat(j+2+c*i,j+c*i+1,1);
                    }
                }
            }
        rr=1000.000;
        ll=0.000;
        n=r*c;
        while (1)
        {
            mm=(ll+rr)/2;
            dijkstra(s,e,mm/100);
            if (fabs(value[e]-l)<0.000001) 
            {
                ans=mm;
                break;
            }
            if (value[e]>l) rr=mm;
            else ll=mm;
        }
        printf("Case #%d: %.3lf%%\n",t,ans);
    }
    return 0;
}