[POJ 3268 Silver Cow Party ]Dijkstra

[POJ 3268 Silver Cow Party ]Dijkstra

知识点：Dijkstra

1. 题目链接

[POJ 3268 Silver Cow Party ]

2. 题意描述

有$n$个顶点，$m$条边的有向图。求图中所有，从该节点出发到点$x$，然后从$x$回到该节点的最短路最长有多长。
$(1 ≤ N ≤ 1000,1 ≤ M ≤ 100,000)$

3. 解题思路

原图从x开始用dijkstra求一次最短路。然后将原图反向，再从x开始dijkstra求一次最短路。两次最短路累加求和，取最大值就是答案。

4. 实现代码

// C
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif

// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif

using namespace std;

typedef long long LL;
typedef long double LB;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;

const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
const LB eps = 1e-8;
const int MAXN = 1000 + 5;
const int MAXM = 100000 + 5;

template <typename T>
inline bool scan_d (T &ret) {
    char c;
    int sgn;
    if (c = getchar(), c == EOF) return 0; //EOF
    while (c != '-' && (c < '0' || c > '9') ) c = getchar();
    sgn = (c == '-') ? -1 : 1;
    ret = (c == '-') ? 0 : (c - '0');
    while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
    ret *= sgn;
    return 1;
}
template<typename T>
void print(T x) {
    static char s[33], *s1; s1 = s;
    if (!x) *s1++ = '0';
    if (x < 0) putchar('-'), x = -x;
    while(x) *s1++ = (x % 10 + '0'), x /= 10;
    while(s1-- != s) putchar(*s1);
}
template<typename T> void println(T x) { print(x); putchar('\n');}

int n, m, x;

struct Dijkstra {
    struct Edge {
        int v, w, next;
        Edge() {}
        Edge (int v, int w, int next) : v (v), w (w), next (next) {}
    } edges[MAXM];
    struct QNode {
        int u, w;
        QNode() {}
        QNode (int u, int w) : u (u), w (w) {}
        bool operator > (const QNode& e) const {
            return w > e.w;
        }
    } cur;
    int head[MAXN], tot;
    int dist[MAXN];
    bool vis[MAXN];
    priority_queue<QNode, vector<QNode>, greater<QNode> > Q;
    void init() {
        tot = 0;
        memset(head, -1, sizeof (head) );
        memset(dist, 0x3f, sizeof (dist) );
        memset(vis, false, sizeof (vis) );
    }
    void add_edge(int u, int v, int w) {
        edges[tot] = Edge (v, w, head[u]);
        head[u] = tot ++;
    }
    void run(int src) {
        int u, v, w;
        Q.push(QNode (src, dist[src] = 0) );
        while(!Q.empty() ) {
            cur = Q.top();
            Q.pop();
            u = cur.u;
            if(vis[u]) continue;
            vis[u] = true;
            for(int i = head[u]; ~i; i = edges[i].next) {
                v = edges[i].v, w = edges[i].w;
                if(!vis[v] && dist[v] > dist[u] + w) {
                    dist[v] = dist[u] + w;
                    Q.push(QNode(v, dist[v]));
                }
            }
        }
    }
} dij[2];

int main() {
#ifdef ___LOCAL_WONZY___
    freopen("input.txt", "r", stdin);
#endif // ___LOCAL_WONZY___
    int u, v, w;
    while(scan_d(n) && scan_d(m) && scan_d(x)) {
        dij[0].init();
        dij[1].init();
        for(int i = 1; i <= m; ++i) {
            scan_d(u), scan_d(v), scan_d(w);
            dij[0].add_edge(u, v, w);
            dij[1].add_edge(v, u, w);
        }
        dij[0].run(x);
        dij[1].run(x);
        int ans = 0;
        for(int i = 1; i <= n; ++i) {
            if(i == x) continue;
            if(dij[0].dist[i] == INF || dij[1].dist[i] == INF) continue;
            ans = max(ans, dij[0].dist[i] + dij[1].dist[i]);
        }
        println(ans);
    }
    return 0;
}