AHU-744 你来擒孟获 【Dijkstra】

Description

三国时期，南蛮王孟获叛乱，诸葛亮起兵平乱。
当深入南蛮之地时，遇当地人绘得地图，发现各地分别由各个寨主据守，若诸葛亮想兵分多路进军，尽快占领各个山寨(必须占领所有山寨)，并且最终所有士兵都汇聚到孟获所在山寨，若给你一次穿越的机会，你用程序告诉诸葛亮最少需要多少天才能完成这个任务。假设军队足够多，各分队行军速度一样，且诸葛亮神机妙算，到达每个山寨即日可以攻克。

 

Input

首先是一个正整数T，接下来是T组测试数据，每组数据第一行是两个整数n,m 2<=n<=1000,1<=m<=10000 ，分别表示山寨数量和总边数，山寨编号0，1，2，3….n-1接下来m行，每行三个整数i,j,k 0<=i,j < n,k<=10^4 ，分别表示山寨i和山寨j之间有一条路，在这条路上需要行军k天，接下来一行两个整数s,t 0<=s,t<=n-1，分别表示诸葛亮所在部队的起点和孟获山寨所在终点的编号

 

Output

对每组数据输出一个整数，表示诸葛亮的士兵占领所有山寨并汇聚到孟获所在山寨所需要的最少天数，每个输出独占一行

 

Sample Input

2
5 6
0 1 2
1 2 2
3 1 2
4 0 3
3 2 3
3 4 1
4 3
5 5
1 0 1
1 2 3
1 3 3
4 2 2
3 4 1
4 2

 

Sample Output

7
9

---

思路：
简单的Dijkstra,先算出源点到各点的最短路，再算出终点（除源点和终点）到各点的最短路，两次Dijkstra，取和的最大值。

---

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<string>
 
using namespace std;
#define INF 0x3f3f3f3f
const int maxn = 2000 + 5;
int temp[maxn];
 
struct Edge {
    int from, to, dist;
};
 
struct Node {
    int d, u;
    bool operator < (const Node& rhs) const {
        return d > rhs.d;
    }
};
 
struct Dijkstra {
    int n, m;
    vector<Edge> edges;
    vector<int> G[maxn];
    int d[maxn];
    bool done[maxn];
 
    void init(int n) {
        this->n = n;
        for (int i = 0; i <= n; ++i)
            G[i].clear();
        edges.clear();
    }
 
    void AddEdge(int from, int to, int dist) {
        edges.push_back((Edge){from, to, dist});
        m = edges.size();
        G[from].push_back(m-1);
    }
 
    void dijkstra(int s) {
         priority_queue<Node> Q;
         memset(done, 0, sizeof(done));
         memset(d, INF, sizeof(d));
         d[s] = 0;
         Q.push((Node){d[s], s});
         while(!Q.empty()) {
             Node x = Q.top(); Q.pop();
             int u = x.u;
             if (done[u]) continue;
             done[u] = true;
             int len = G[u].size();
             for (int i = 0; i < len; ++i) {
                 Edge &e = edges[G[u][i]];
                 if (d[e.to] > d[u] + e.dist) {
                    d[e.to] = d[u] + e.dist;
                    Q.push((Node){d[e.to], e.to});
                 }
             }
         }
    }
 
};
 
Dijkstra di;
 
int main() {
    int n, m, a, b, c, T;
    cin>>T;
    while(T--) {
        cin>>n>>m;
        di.init(n);
        while(m--) {
            cin>>a>>b>>c;
            di.AddEdge(a, b, c);
            di.AddEdge(b, a, c);
        }
        int s, e, ans = 0;
        cin>>s>>e;
        di.dijkstra(s);
        ans = max(di.d[e], ans);
        for (int i = 0; i < n; ++i) 
            if (i != s && i != e) temp[i] = di.d[i];
        di.dijkstra(e);
        for (int i = 0; i < n; ++i)
            if (i != s && i != e) {
                ans = max(ans, temp[i] + di.d[i]);
            }
        cout<<ans<<endl;
    }
 
    return 0;
}