• 51nod 1459迷宫游戏,迪杰特斯拉算法


    基准时间限制:1 秒 空间限制:131072 KB 分值: 0 难度:基础题
     
    你来到一个迷宫前。该迷宫由若干个房间组成,每个房间都有一个得分,第一次进入这个房间,你就可以得到这个分数。还有若干双向道路连结这些房间,你沿着这些道路从一个房间走到另外一个房间需要一些时间。游戏规定了你的起点和终点房间,你首要目标是从起点尽快到达终点,在满足首要目标的前提下,使得你的得分总和尽可能大。现在问题来了,给定房间、道路、分数、起点和终点等全部信息,你能计算在尽快离开迷宫的前提下,你的最大得分是多少么?
    Input
    第一行4个整数n (<=500), m, start, end。n表示房间的个数,房间编号从0到(n - 1),m表示道路数,任意两个房间之间最多只有一条道路,start和end表示起点和终点房间的编号。
    第二行包含n个空格分隔的正整数(不超过600),表示进入每个房间你的得分。
    再接下来m行,每行3个空格分隔的整数x, y, z (0<z<=200)表示道路,表示从房间x到房间y(双向)的道路,注意,最多只有一条道路连结两个房间, 你需要的时间为z。
    输入保证从start到end至少有一条路径。
    Output
    一行,两个空格分隔的整数,第一个表示你最少需要的时间,第二个表示你在最少时间前提下可以获得的最大得分。
    Input示例
    3 2 0 2
    1 2 3
    0 1 10
    1 2 11
    Output示例
    21 6

    用迪杰特斯拉算法求出最短路,这个最短路要求满足耗时最短且得分最高两个条件。
    所以更新条件为:
                if(d[v]>d[u]+cost[u][v] ||
                            d[v]==d[u]+cost[u][v]&&ans[v]<ans[u]+jd[v].time)
                {
                    d[v]=d[u]+cost[u][v];
                    ans[v]=ans[u]+jd[v].time;
                    que.push(node{v,d[v]});
                }
    完整代码:
     1 #include <cstdio>
     2 #include <cstring>
     3 #include <iostream>
     4 #include <queue>
     5 #include <algorithm>
     6 #define INF 0x3f3f3f3f
     7 using namespace std;
     8 
     9 const int maxv=505;
    10 int ans[maxv];
    11 vector<int> g[maxv];
    12 struct node
    13 {
    14     int num,dis,time;
    15 };
    16 node jd[maxv];
    17 bool operator<(const node& n1,const node& n2)
    18 {
    19     if(n1.dis==n2.dis) return n1.time<n2.time;
    20     else return n1.dis<n2.dis;
    21 }
    22 int V,E,s,e,scr[maxv],cost[maxv][maxv],d[maxv];
    23 
    24 
    25 void dij(int x)
    26 {
    27     fill(d,d+V,INF);
    28     d[x]=0;
    29     priority_queue<node> que;
    30     que.push(node{s,0});
    31     while(!que.empty())
    32     {
    33         int tmp=que.top().num;
    34         que.pop();
    35         for(int i=0;i<g[tmp].size();i++)
    36         {
    37             int u=tmp;
    38             int v=g[tmp][i];
    39             if(d[v]>d[u]+cost[u][v] || d[v]==d[u]+cost[u][v]&&ans[v]<ans[u]+jd[v].time)
    40             {
    41                 d[v]=d[u]+cost[u][v];
    42                 ans[v]=ans[u]+jd[v].time;
    43                 jd[v].prior=u;
    44                 que.push(node{v,d[v]});
    45             }
    46         }
    47     }
    48 }
    49 
    50 int main()
    51 {
    52    while(~scanf("%d%d%d%d",&V,&E,&s,&e))
    53    {
    54     memset(ans,0,sizeof(ans));
    55     for(int i=0;i<V;i++)
    56         for(int j=0;j<V;j++)
    57     {
    58         cost[i][j]=INF;
    59         if(i==j)
    60             cost[i][j]=0;
    61     }
    62     for(int i=0;i<V;i++)
    63     {
    64         scanf("%d",&scr[i]);
    65         jd[i].num=i;
    66         jd[i].time=scr[i];
    67         jd[i].prior=-1;
    68     }
    69     for(int i=0;i<E;i++)
    70     {
    71         int x,y,z;
    72         scanf("%d%d%d",&x,&y,&z);
    73         g[x].push_back(y);
    74         g[y].push_back(x);
    75         cost[x][y]=cost[y][x]=z;
    76     }
    77     ans[s]=jd[s].time;
    78     dij(s);
    79     printf("%d %d
    ",d[e],ans[e]);
    80    }
    81    return 0;
    82 }
    #include <cstdio>
    #include <cstring>
    #include <iostream>
    #include <queue>
    #include <algorithm>
    #define INF 0x3f3f3f3f
    using namespace std;
    
    const int maxv=505;
    int ans[maxv];
    vector<int> g[maxv];
    struct node
    {
        int num,dis,time;
    };
    node jd[maxv];
    bool operator<(const node& n1,const node& n2)
    {
        if(n1.dis==n2.dis) return n1.time<n2.time;
        else return n1.dis<n2.dis;
    }
    int V,E,s,e,scr[maxv],cost[maxv][maxv],d[maxv];
    
    
    void dij(int x)
    {
        fill(d,d+V,INF);
        d[x]=0;
        priority_queue<node> que;
        que.push(node{s,0});
        while(!que.empty())
        {
            int tmp=que.top().num;
            que.pop();
            for(int i=0;i<g[tmp].size();i++)
            {
                int u=tmp;
                int v=g[tmp][i];
                if(d[v]>d[u]+cost[u][v] || d[v]==d[u]+cost[u][v]&&ans[v]<ans[u]+jd[v].time)
                {
                    d[v]=d[u]+cost[u][v];
                    ans[v]=ans[u]+jd[v].time;
                    jd[v].prior=u;
                    que.push(node{v,d[v]});
                }
            }
        }
    }
    
    int main()
    {
       while(~scanf("%d%d%d%d",&V,&E,&s,&e))
       {
        memset(ans,0,sizeof(ans));
        for(int i=0;i<V;i++)
            for(int j=0;j<V;j++)
        {
            cost[i][j]=INF;
            if(i==j)
                cost[i][j]=0;
        }
        for(int i=0;i<V;i++)
        {
            scanf("%d",&scr[i]);
            jd[i].num=i;
            jd[i].time=scr[i];
            jd[i].prior=-1;
        }
        for(int i=0;i<E;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            g[x].push_back(y);
            g[y].push_back(x);
            cost[x][y]=cost[y][x]=z;
        }
        ans[s]=jd[s].time;
        dij(s);
        printf("%d %d
    ",d[e],ans[e]);
       }
       return 0;
    }
  • 相关阅读:
    计算fibonacci数(多种方法)
    数组求和(两种方法)
    C语言二级指针(指向指针的指针)
    唯品会海量实时OLAP分析技术升级之路
    hive 调优(一)coding调优
    supsplk 服务器被植入木马 挖矿 cpu使用 700%
    OPTS参数设置
    Yarn 内存分配管理机制及相关参数配置
    hive on tez 任务失败
    hive 调优(三)tez优化
  • 原文地址:https://www.cnblogs.com/onlyli/p/6911356.html
Copyright © 2020-2023  润新知