基准时间限制：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
     
      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
      
        edges;      /// 边列表    vector
       
          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
        
          Q;        for(int i = 0; i 
         
           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;   }}