51nod--1459 迷宫游戏 （dijkstra）

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

标准的最短路， dijkstra算法变一下， 多重判断就好了

实现代码：

#include<bits/stdc++.h>

using namespace std;

const int maxn = 1000 + 131;
const int INF = 0x7fffffff;

int Va[maxn];  /// 房间价值

struct Edge { /// 图的边结构
    int from, to, Cost, Value;
    Edge(int f, int t, int c, int v) :\
        from(f), to(t), Cost(c), Value(v) {}
};

struct Get {
    int time, value;
};

struct HeapNode { /// 优先队列的节点
    int t, d, u;
    HeapNode(int _t, int _d, int _u) :\
        t(_t), d(_d), u(_u) {}

    bool operator < (const HeapNode& rhs) const {
        if (t == rhs.t) return d < rhs.d;
        return t > rhs.t;
    }
};

struct Dijkstra {
    int n, m;                /// 点数和边数
    vector<Edge> edges;      /// 边列表
    vector<int>  G[maxn];    /// 每个节点出发的编号（从 0 开始）
    bool done[maxn];         /// 是否已永久标号
    Get d[maxn];             /// s 到各个节点的距离， 价值
    int p[maxn];             /// 最短路中的上一条边。

    void init(int n) {
        this -> n = n;
        for (int i = 0; i < n; ++i) G[i].clear();
        edges.clear();
    }

    void AddEdges(int from, int to, int dist) {
        edges.push_back(Edge(from, to, dist, Va[to]));
        m = edges.size();
        G[from].push_back(m-1);
    }

    void dijkstra(int s) {
        priority_queue<HeapNode> Q;
        for(int i = 0; i <n; ++i) d[i].time = INF, d[i].value = -1;
        d[s].time = 0, d[s].value = Va[s];
        memset(done, 0, sizeof(done));
        Q.push(HeapNode(0,Va[s],s));
        while(!Q.empty())  {
            HeapNode x = Q.top(); Q.pop();
            int u = x.u;
            if(done[u]) continue;
            done[u] = true;
            for(int i = 0; i < G[u].size(); ++i) {
                Edge& e = edges[G[u][i]];
                if(d[e.to].time > d[u].time + e.Cost) { ///时间多就更新
                    d[e.to].time = d[u].time + e.Cost;
                    d[e.to].value = d[u].value + e.Value;
                    p[e.to] = G[u][i];
                    Q.push(HeapNode(d[e.to].time, d[e.to].value, e.to));
                 } else if(d[e.to].time == d[u].time + e.Cost && d[e.to].value < d[u].value + e.Value) {
                     /// 时间相同， 价值大的更新。
                    d[e.to].value = d[u].value + e.Value;
                    p[e.to] = G[u][i];
                    Q.push(HeapNode(d[e.to].time, d[e.to].value, e.to));
                 }
            }
        }
    }
}Dj;

int main() {
   int m, n, st, ed, fr, to, co;
   while(cin >> n >> m >> st >> ed) {
        Dj.init(n);
        for(int i = 0; i < n; ++i) {
            cin >> Va[i];
        }

        for(int i = 0; i < m; ++i) {
            cin >> fr >> to >> co;
            Dj.AddEdges(fr, to, co);
            Dj.AddEdges(to, fr, co);
        }
        Dj.dijkstra(st);
        cout << Dj.d[ed].time << ' ' << Dj.d[ed].value << endl;
   }
}