POJ 1661 Help Jimmy （dijkstra，最短路）

刚在百度搜索了一下这道题的题解， 因为看到有别人用动态规划做的，所以想参考一下。

结果顺带发现了有那么几个网站，上面的文章竟然和我这篇一模一样（除了一些明显的错别字外），我去，作者还是同一个人Admin，还是同一天发表。

我才是原作者！！！这里特别声明，请尊重版权，可以转载或者复制，但是请注明出处！！！

 

思路：我是转化成求最短路来解的。
　　   将每个平台看作两个点，即左端点和右端点，然后将符合条件的两点相连，边长即为两点之间的垂直距离和水平距离。
　　   将jimmy起始的地点看作顶点0，而地面看作顶点2*N+1，这样就是求0到2*N+1的单源最短路径，用dijkstra就可以搞定。

有几个要注意的地方：
　　1.一开始做的时候，没仔细想，认为只要两个平台之间符合条件，就建立边的关系。
　　　忽略了一个平台下方最多只能有两个平台（即左端点下方一个，右端点下方一个）。也就是说一个点最多只能与一个点相连。
　　2.jimmy有可能可以直接落到地上
　　3.能与地面相连的点，必须保证它的下方没有阻隔的平台

#include <iostream>
#include <queue>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <string.h>

using namespace std;
const int maxn=1000*2+5;
const int INF=0x3f3f3f3f;
int N,X,Y,MAX;
long long dis[maxn];
int vis[maxn];  
int head[maxn];
int tot;
long long ans;  
struct Line {
    int l,r,h;
    bool operator<(const Line tmp)const {
        return h>tmp.h;
    }
} line[maxn];
struct Node {
    int u;
    long long dis;
    bool operator<(const Node tmp)const {
        return dis>tmp.dis;
    }
};

struct Edge {
    int to,next;
    int length;
} edge[maxn*maxn];

void add(int i,int j,int dis) {
    edge[tot].next=head[i];
    edge[tot].to=j;
    edge[tot].length=dis;
    head[i]=tot++;
}
void dijkstra(int s) {
    for(int i=0; i<maxn; i++) {
        dis[i]=INF;
        vis[i]=0;
    }
    priority_queue<Node>q;
    Node t;
    t.u=s;
    t.dis=0;
    dis[s]=0;
    q.push(t);
    int v,u;
    while(!q.empty()) {
        t=q.top();
        q.pop();
        u=t.u;
        vis[u]=1;

        if(u==2*N+1){
            ans=t.dis;
            break;
        }

        for(int k=head[u]; k!=-1; k=edge[k].next) {
            v=edge[k].to;
            if(!vis[v] && dis[u]+edge[k].length<dis[v]) {
                dis[v]=dis[u]+edge[k].length;
                t.u=v;
                t.dis=dis[v];
                q.push(t);
            }


        }
    }
}
int main() {
    int t;
    scanf("%d",&t);
    while(t--) {
        memset(head,-1,sizeof(head));
        tot=0;
        scanf("%d%d%d%d",&N,&X,&Y,&MAX);
        for(int i=1; i<=N; i++) {
            scanf("%d%d%d",&line[i].l,&line[i].r,&line[i].h);
        }
        sort(line+1,line+N+1);
        int ldis,rdis;
        for(int i=1; i<=N; i++) {
            //这里要考虑，不是所有在i平台下方符合的就可以建立边的关系
            //而只能与它最近的平台才行。
            //例如平台1,2,3，并且2、3都在1的下方，且满足条件。但1和3不能相连，因为中间隔着2，所以只能1和2相连
            int cnt1=0,cnt2=0;
            for(int j=i+1; j<=N; j++) {
                if(line[i].h-line[j].h>=0 && line[i].h-line[j].h<=MAX) {
                    if(line[j].l<=line[i].l && line[i].l<=line[j].r) {
                        cnt1++;
                        //左端下方第一个符合要求的
                        if(cnt1==1) {
                            ldis=line[i].h-line[j].h+line[i].l-line[j].l;
                            add(i*2-1,j*2-1,ldis);

                            rdis=line[i].h-line[j].h+line[j].r-line[i].l;
                            add(i*2-1,j*2,rdis);
                        }
                    }
                    if(line[j].l<=line[i].r && line[i].r<=line[j].r) {
                        cnt2++;
                        //右端点下方第一个符合要求的
                        if(cnt2==1) {
                            ldis=line[i].h-line[j].h+line[i].r-line[j].l;
                            add(i*2,j*2-1,ldis);

                            rdis=line[i].h-line[j].h+line[j].r-line[i].r;
                            add(i*2,j*2,rdis);
                        }
                    }
                }
            }
            //若要与地面连接，则必须该平台下方没有其它阻隔的平台。
            //如果该平台左端点下方没有其它平台阻隔，且满足条件，则与地面相连
            if(!cnt1 && line[i].h<=MAX) {
                add(i*2-1,2*N+1,line[i].h);
            }
            //如果该平台右端点下方没有其它平台阻隔，且满足条件，则与地面相连
            if(!cnt2 && line[i].h<=MAX) {
                add(i*2,2*N+1,line[i].h);
            }
        }
        //只能有一个平台与源点连接
        int cnt=0;
        for(int j=1; j<=N; j++) {
            if(line[j].l<=X && X<=line[j].r && Y-line[j].h>=0 && Y-line[j].h<=MAX) {
                cnt++;
                //第一个符合要求的平台
                if(cnt==1) {
                    ldis=Y-line[j].h+X-line[j].l;
                    add(0,j*2-1,ldis);

                    rdis=Y-line[j].h+line[j].r-X;
                    add(0,j*2,rdis);
                }
            }
        }
        //没有平台在jimmy的下方，也就是jimmy可以直接到达地面。。。之前都忽略了额
        if(cnt==0) {
            add(0,2*N+1,Y);
        }
        dijkstra(0);
        printf("%I64d\n",ans);
    }
    return 0;
}