POJ 2502 Subway-经过预处理的最短路

Description

You have just moved from a quiet Waterloo neighbourhood to a big, noisy city. Instead of getting to ride your bike to school every day, you now get to walk and take the subway. Because you don't want to be late for class, you want to know how long it will take you to get to school. 
You walk at a speed of 10 km/h. The subway travels at 40 km/h. Assume that you are lucky, and whenever you arrive at a subway station, a train is there that you can board immediately. You may get on and off the subway any number of times, and you may switch between different subway lines if you wish. All subway lines go in both directions.

Input

Input consists of the x,y coordinates of your home and your school, followed by specifications of several subway lines. Each subway line consists of the non-negative integer x,y coordinates of each stop on the line, in order. You may assume the subway runs in a straight line between adjacent stops, and the coordinates represent an integral number of metres. Each line has at least two stops. The end of each subway line is followed by the dummy coordinate pair -1,-1. In total there are at most 200 subway stops in the city.

Output

Output is the number of minutes it will take you to get to school, rounded to the nearest minute, taking the fastest route.

Sample Input

0 0 10000 1000
0 200 5000 200 7000 200 -1 -1
2000 600 5000 600 10000 600 -1 -1

Sample Output

21

Source

Waterloo local 2001.09.22

---

这道题的思路简单来说就是将所有地铁站转换成点，然后预处理所有点间的边权（即将距离转换成时间），然后用最短路算法（例如SPFA）求出起点和目标点的距离。

但是！！！

说的简单，实现起来真TM麻烦。

第一：

需要四舍五入得到答案。

四舍五入的函数不难写，但是在哪里四舍五入是个问题。

回忆了一下做数学题的教训，前面一直用double保存边权，到最后再四舍五入误差最小。

第二：

每点间的距离处理。

你需要判断他们间的路是在地铁里还是人行道，所以我加了一个初始为1的变量p，每次输入-1，-1是就p++。

然后每次在两点间赋权的时候判断是不是在同一条地铁线上。

第三：
现在还没解决的问题，如果两条地铁线交叉，那么赋权就又有问题了，所以我希望可以用坐标来表示点，但是由于坐标可能给的很大，所以一直不知道怎么处理。

 

附上还没完成的代码（甚至样例都是错的），希望可以有所启发（还会不断更新，知道附上AC代码）：

 

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
#define ll long long
using namespace std;
int read()
{
    int x=,y=;
    char ch=getchar();
    while(ch<''||ch>'')
    {
        if(ch=='-')
            y=-;
        ch=getchar();
    }
    while(ch>=''&&ch<='')
    {
        x=x*+ch-'';
        ch=getchar();
    }
    return x*y;
}
int abs(int x)
{
    if(x<)
        return -x;
    else
        return x;
}
int change(double x)
{
    int r=(int)x;
    if(x-r<0.5)
        return r;
    else
        return r+;
}
double way(int x1,int y1,int x2,int y2)
{
    int r1=abs(x1-x2),r2=abs(y1-y2);
    return sqrt(r1*r1+r2*r2);
}
struct edge
{
    int next,to;
    double lon;
} e[];
int map[][],num,node[][],head[],cnt,t[],headd,tail=;
double dist[];
bool vis[];
void add(int from,int to,double lon)
{
    e[++cnt].lon=lon;
    e[cnt].to=to;
    e[cnt].next=head[from];
    head[from]=cnt;
}
int main()
{
    memset(head,-,sizeof(head));
    int x1=read(),y1=read(),x2=read(),y2=read(),x,y,p=,l=change(way(x1,y1,x2,y2)/*);
    node[++num][]=x1;
    node[num][]=y1;
    node[++num][]=x2;
    node[num][]=y2;
    add(,,l);
    add(,,l);
    while(scanf("%d%d",&x,&y)!=EOF)
    {
        if(x==-&&y==-)
        {
            p++;
            continue;
        }
        node[++num][]=x;
        node[num][]=y;
        node[num][]=p;
        for(int i=; i<num; i++)
        {
            double dis;
            if(node[i][]==p)
                dis=way(x,node[i][],y,node[i][])/*;
            else
                dis=way(x,node[i][],y,node[i][])/*;
//            printf("x=%d y=%d node[i][0]=%d node[i][1]=%d dis=%f\n",x,y,node[i][0],node[i][1],dis);
            add(num,i,dis),add(i,num,dis);
        }
    }
    for(int i=; i<=num; i++)
        dist[i]=2e8;
    t[]=;
    while(headd!=tail)
    {
        int r=head[t[headd]];
        vis[t[headd]]=;
        while(r!=-)
        {
            if(dist[e[r].to]>dist[t[headd]]+e[r].lon)
            {
                dist[e[r].to]=dist[t[headd]]+e[r].lon;
                printf("e[r].lon=%f e[r].to=%d dist=%f %f\n",e[r].lon,e[r].to,dist[t[headd]],dist[e[r].to]);
                if(!vis[e[r].to])
                {
                    vis[e[r].to]=;
                    t[tail++]=e[r].to;
                }
            }
            r=e[r].next;
        }
        headd++;
    }
    printf("%f",dist[]);
    return ;
}

//    FOR C.H

附上最新经谭姐启发写的正解方法代码（思路稍后，仍有问题在调试）：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
//    邻接链保存边
int head[],cnt,num;
struct edge
{
    int next,to;
    double lon;
} e[];
void add(int from,int to,double lon)
{
    e[++cnt].lon=lon;
    e[cnt].to=to;
    e[cnt].next=head[from];
    head[from]=cnt;
}
//    绝对值函数
int abs(int x)
{
    if(x<)
        return -x;
    else
        return x;
}
//    求两点间距离的函数
double far(int x1,int y1,int x2,int y2)
{
    int r1=abs(x1-x2),r2=abs(y1-y2);
    return sqrt(r1*r1+r2*r2);
}
//    将double转变成int的函数
int change(double x)
{
    int r=(int)x;
    if(x-r<0.5)
        return r;
    else
        return r+;
}
int map[][];
//    输入处理，自认为比以前有所进步
void scan()
{
    int x,y,p=,s=;
    while(scanf("%d%d",&x,&y)!=EOF)
    {
        if(x==-&&y==-)
        {
//            该条地铁线上的点和前后的点连无向快边
            for(int i=; i<=s; i++)
            {
                double f=far(map[num-s+i-][],map[num-s+i-][],map[num-s+i][],map[num-s+i][])/*;
                add(num-s+i-,num-s+i,f);
                add(num-s+i,num-s+i-,f);
            }
            s=;
            continue;
        }
        map[++num][]=x;
        map[num][]=y;
        s++;
    }
}
//    每点到起点的距离
double dist[];
//    SPFA的队列
int t[],headd,tail=;
bool vis[];
int main()
{
    memset(head,-,sizeof(head));
    int x1,y1,x2,y2;
    scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
    scan();
//    每个点间连一条慢边，虽然可以优化，不用全部连，但是懒得打了，反正最短路嘛
    for(int i=; i<=num; i++)
        for(int j=; j<=num; j++)
        {
            double f=far(map[i][],map[i][],map[j][],map[j][])/*;
            add(i,j,f);
        }
//    每个点和起点连一条慢边
    num++;
    for(int i=; i<num; i++)
    {
        double f=far(map[i][],map[i][],x1,y1)/*;
        add(i,num,f);
        add(num,i,f);
    }
//    除起点外和终点连一条慢边
    num++;
    for(int i=; i<num-; i++)
    {
        double f=far(map[i][],map[i][],x2,y2)/*;
        add(i,num,f);
        add(num,i,f);
    }
//    SPFA求起点到终点的最短路
    t[]=num-;
    vis[num-]=;
    for(int i=; i<=num; i++)
        dist[i]=2e8;
    dist[num-]=;
    while(headd!=tail)
    {
        int r=head[t[headd]];
        printf("r=%d\n",r);
        while(r!=-)
        {
            if(dist[e[r].to]>dist[t[headd]]+e[r].lon)
            {
                dist[e[r].to]=dist[t[headd]]+e[r].lon;
                printf("dist[e[r].to]=%f\n",dist[e[r].to]);
                if(!vis[e[r].to])
                {
                    vis[e[r].to]=;
                    t[tail++]=e[r].to;
                }
            }
            r=e[r].next;
        }
        headd++;
    }
//    输出答案
    printf("%d",change(dist[num]));
    return ;
}

//    FOR C.H

终于迎来了最后一次编辑！

之前的程序有一个小错误找了半天，就是SPFA忘记出队，最后终于找到了！

还有，我还是把每个地铁站的点到其他地铁站的距离优化了一下，少加了几条（其实蛮多）边。

最后的AC代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
//    邻接链保存边
int head[],cnt,num;
struct edge
{
    int next,to;
    double lon;
} e[];
void add(int from,int to,double lon)
{
    e[++cnt].lon=lon;
    e[cnt].to=to;
    e[cnt].next=head[from];
    head[from]=cnt;
}
//    绝对值函数
int abs(int x)
{
    if(x<)
        return -x;
    else
        return x;
}
//    求两点间距离的函数
double far(int x1,int y1,int x2,int y2)
{
    int r1=abs(x1-x2),r2=abs(y1-y2);
    return sqrt(r1*r1+r2*r2);
}
//    四舍五入的函数
int change(double x)
{
    int r=(int)x;
    if(x-r<0.5)
        return r;
    else
        return r+;
}
//    输入处理，自认为比以前有所进步
int map[][];
bool m[][];
void scan()
{
    int x,y,p=,s=;
    while(scanf("%d%d",&x,&y)!=EOF)
    {
        if(x==-&&y==-)
        {
//            该条地铁线上的点和前后的点连无向快边
            for(int i=; i<=s; i++)
            {
                double f=far(map[num-s+i-][],map[num-s+i-][],map[num-s+i][],map[num-s+i][])/*;
                add(num-s+i-,num-s+i,f);
                add(num-s+i,num-s+i-,f);
                m[num-s+i-][num-s+i]=;
            }
            s=;
            continue;
        }
        map[++num][]=x;
        map[num][]=y;
        s++;
    }
}
//    每点到起点的距离
double dist[];
//    SPFA的队列
int t[],headd,tail=;
bool vis[];
int main()
{
    memset(head,-,sizeof(head));
    int x1,y1,x2,y2;
    scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
    scan();
//    每个点间连一条慢边，如果已经连了快边了就不用连
    for(int i=; i<=num; i++)
        for(int j=; j<=num; j++)
        {
            if(m[i][j]||m[j][i]||i==j)
                continue;
            double f=far(map[i][],map[i][],map[j][],map[j][])/*;
            add(i,j,f);
        }
//    每个点和起点连条慢边
    num++;
    for(int i=; i<num; i++)
    {
        double f=far(map[i][],map[i][],x1,y1)/*;
        add(i,num,f);
        add(num,i,f);
    }
//    除起点外和终点连条慢边
    num++;
    for(int i=; i<num-; i++)
    {
        double f=far(map[i][],map[i][],x2,y2)/*;
        add(i,num,f);
        add(num,i,f);
    }
//    SPFA求起点到终点的最短路
    t[]=num-;
    vis[num-]=;
    for(int i=; i<=num; i++)
        dist[i]=2e8;
    dist[num-]=;
    while(headd!=tail)
    {
        int r=head[t[headd]];
        vis[t[headd]]=;
        while(r!=-)
        {
            if(dist[e[r].to]>dist[t[headd]]+e[r].lon)
            {
                dist[e[r].to]=dist[t[headd]]+e[r].lon;
                if(!vis[e[r].to])
                {
                    vis[e[r].to]=;
                    t[tail++]=e[r].to;
                }
            }
            r=e[r].next;
        }
        headd++;
    }
//    输出答案
    printf("%d",change(dist[num]));
    return ;
}

//    FOR C.H