• 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
    ",ans);
        }
        return 0;
    }
  • 相关阅读:
    攻防世界wp--web robots
    kubernetes二: kubernetes 重要组件安装和集群管理
    kibana配置页面跳转
    二进制安装的k8s添加新的node节点
    分布式和微服务的区别
    kubernetes一: 二进制安装k8s集群
    kibana导入导出dashborad
    elk 创建一个只读用户
    x-pack模式下修改es集群密码
    docker基础命令
  • 原文地址:https://www.cnblogs.com/chenxiwenruo/p/3529252.html
Copyright © 2020-2023  润新知