• L3-007 天梯地图 (30 分) dijkstra


    本题要求你实现一个天梯赛专属在线地图,队员输入自己学校所在地和赛场地点后,该地图应该推荐两条路线:一条是最快到达路线;一条是最短距离的路线。题目保证对任意的查询请求,地图上都至少存在一条可达路线。

    输入格式:

    输入在第一行给出两个正整数N(2 ≤ N ≤ 500)和M,分别为地图中所有标记地点的个数和连接地点的道路条数。随后M行,每行按如下格式给出一条道路的信息:

    V1 V2 one-way length time
    

    其中V1V2是道路的两个端点的编号(从0到N-1);如果该道路是从V1V2的单行线,则one-way为1,否则为0;length是道路的长度;time是通过该路所需要的时间。最后给出一对起点和终点的编号。

    输出格式:

    首先按下列格式输出最快到达的时间T和用节点编号表示的路线:

    Time = T: 起点 => 节点1 => ... => 终点
    

    然后在下一行按下列格式输出最短距离D和用节点编号表示的路线:

    Distance = D: 起点 => 节点1 => ... => 终点
    

    如果最快到达路线不唯一,则输出几条最快路线中最短的那条,题目保证这条路线是唯一的。而如果最短距离的路线不唯一,则输出途径节点数最少的那条,题目保证这条路线是唯一的。

    如果这两条路线是完全一样的,则按下列格式输出:

    Time = T; Distance = D: 起点 => 节点1 => ... => 终点
    

    输入样例1:

    10 15
    0 1 0 1 1
    8 0 0 1 1
    4 8 1 1 1
    5 4 0 2 3
    5 9 1 1 4
    0 6 0 1 1
    7 3 1 1 2
    8 3 1 1 2
    2 5 0 2 2
    2 1 1 1 1
    1 5 0 1 3
    1 4 0 1 1
    9 7 1 1 3
    3 1 0 2 5
    6 3 1 2 1
    5 3
    

    输出样例1:

    Time = 6: 5 => 4 => 8 => 3
    Distance = 3: 5 => 1 => 3
    

    输入样例2:

    7 9
    0 4 1 1 1
    1 6 1 3 1
    2 6 1 1 1
    2 5 1 2 2
    3 0 0 1 1
    3 1 1 3 1
    3 2 1 2 1
    4 5 0 2 2
    6 5 1 2 1
    3 5
    

    输出样例2:

    Time = 3; Distance = 4: 3 => 2 => 5

    dijkstrai加上了很多花样
    1. 求最短时间 如果时间相等 求最短路
    这个就是有权值的普通dijkstra 用两个dis数组处理即可
    但是这次输出路径死活调不出来
    后来找到了两种解决方法
    1.将所有dis初始化为inf (显然这种方法是正确的)
    2.将path初始化为s 我只是在别的博客里看到别人这么用 我觉得并不能保证一定正确 所以我选择第一种方法
    这题要保存好路径 最后用来对比和输出
    我之前的路径写法是一个递归来打印
    现在采用新的方法来遍历并且保存好路径更加方便

    2.要求的是最短路径 路径相同时取经过点最少的路径
    这个是新学的有关dijkstra的内容
    只要设置一个node数组即可 注意要初始化为inf 且node[s]=0;
    当路径相同时取点数少的即可

    注意路径输出的方式


    #include<bits/stdc++.h>
    using namespace std;
    //input
    #define rep(i,a,b) for(int i=(a);i<=(b);i++)
    #define repp(i,a,b) for(int i=(a);i>=(b);i--)
    #define RI(n) scanf("%d",&(n))
    #define RII(n,m) scanf("%d%d",&n,&m);
    #define RIII(n,m,k) scanf("%d%d%d",&n,&m,&k)
    #define RS(s) scanf("%s",s);
    #define LL long long
    #define REP(i,N)  for(int i=0;i<(N);i++)
    #define CLR(A,v)  memset(A,v,sizeof A)
    //////////////////////////////////
    #define N 500+5
    #define inf 0x3f3f3f3f
    int dislen[N];
    int distime[N];
    int mplen[N][N];
    int mptime[N][N];
    int vis[N];
    int path[N];
    int node[N];
    int pathtime[N];
    int pathlen[N];
    int n,m,s,e;
    int cnttime,cntlen;
    int anstime,anslen;
    
    void dijkstra_time(int s)
    {
        rep(i,0,n-1)
        vis[i]=0,distime[i]=dislen[i]=inf;
        distime[s]=dislen[s]=0;
        path[s]=-1;
    
        while(1)
        {
            int u=-1,minn=inf;
            rep(j,0,n-1)
            if(!vis[j]&&distime[j]<minn)
                minn=distime[u=j];
            if(u==-1)break;
            vis[u]=1;
            rep(j,0,n-1)
            if(!vis[j]&&distime[j]>distime[u]+mptime[u][j])
            {
                path[j]=u;
                distime[j]=distime[u]+mptime[u][j];
                dislen[j]=dislen[u]+mplen[u][j];
            }
            else if(distime[j]==distime[u]+mptime[u][j])
            if(dislen[j]>dislen[u]+mplen[u][j])
            {
                path[j]=u;
                dislen[j]=dislen[u]+mplen[u][j];
            }
        }
        cnttime=0;
        for(int i=e;i!=-1;i=path[i])
            pathtime[++cnttime]=i;
    
        anstime=distime[e];
    }
    void dijkstra_len(int s)
    {
       CLR(path,0);
       path[s]=-1;
       rep(i,0,n-1)
       vis[i]=0,dislen[i]=inf,node[i]=inf;//注意node一开始要初始化成inf
       node[s]=0;
       dislen[s]=0;
       while(1)
       {
           int u=-1,minn=inf;
           rep(j,0,n-1)
           if(!vis[j]&&dislen[j]<minn)
            minn=dislen[u=j];
           if(u==-1)
            break;
           vis[u]=1;
           rep(j,0,n-1)
           if(!vis[j]&&dislen[j]>dislen[u]+mplen[u][j])
           {
               node[j]=node[u]+1;
               path[j]=u;
               dislen[j]=dislen[u]+mplen[u][j];
           }
           else if(dislen[j]==dislen[u]+mplen[u][j]&&node[j]>node[u]+1)
           {
               node[j]=node[u]+1;
               path[j]=u;
           }
       }
       cntlen=0;
       for(int i=e;i!=-1;i=path[i])
        pathlen[++cntlen]=i;
       anslen=dislen[e];
    }
    int main()
    {
        RII(n,m);
        rep(i,0,n-1)
        rep(j,0,n-1)
        mplen[i][j]=mptime[i][j]=inf;
        rep(i,1,m)
        {
            int a,b,c,d,e;
            RIII(a,b,c);RII(d,e);
            if(c==1)
            {
                if(d<mplen[a][b])
                    mplen[a][b]=d;
                if(e<mptime[a][b])
                    mptime[a][b]=e;
            }
            else
            {
                if(d<mplen[a][b])
                    mplen[a][b]=mplen[b][a]=d;
                if(e<mptime[a][b])
                    mptime[a][b]=mptime[b][a]=e;
            }
        }
        RII(s,e);
        dijkstra_time(s);
        dijkstra_len(s);
        int ok=1;
        if(cntlen!=cnttime)
            ok=0;
        else
        {
            rep(i,1,cntlen)
            if(pathlen[i]!=pathtime[i]){ok=0;break;}
        }
        if(ok)
        {
            printf("Time = %d; Distance = %d: ",anstime,anslen);
            repp(i,cntlen,1)
            {
              printf("%d",pathtime[i]);
              if(i!=1)
                printf(" => ");
            }
        }
        else
        {
           printf("Time = %d: ",anstime);
           repp(i,cnttime,1)
           {
               printf("%d",pathtime[i]);
               if(i!=1)printf(" => ");
           }
           cout<<endl;
           printf("Distance = %d: ",anslen);
           repp(i,cntlen,1)
           {
               printf("%d",pathlen[i]);
               if(i!=1)printf(" => ");
           }
        }
        return 0;
    }
    View Code






























  • 相关阅读:
    darknet yolo 使用gpu
    Application of Opposition-Based Reinforcement Learning in Image Segmentation
    图像质量评估 (IQA) 论文笔记: Deep Neural Networks for No-Reference and Full-Reference Image Quality Assessment
    论文笔记:DEEP LEARNING FOR MONAURAL SPEECH SEPARATION
    python函数中的参数*args和**kwargs的含义和用法
    论文笔记:DualCNN(结构和细节分别训练)
    pytorch中为Module和Tensor指定GPU
    Pytorch中的torch.gather函数的含义
    Django(其二)
    第六章Django
  • 原文地址:https://www.cnblogs.com/bxd123/p/10623393.html
Copyright © 2020-2023  润新知