Gym

http://codeforces.com/gym/100625/attachments/download/3213/2013-benelux-algorithm-programming-contest-bapc-13-en.pdf

题意：给你一张无向图，t个可能的目的地，问在这t个点中哪些点的最短路中经过了g和h

思路：这是傻逼题，我直接dijstra用vector< set<int> > 保存路径， 最后再去判断下。。好像这并不是出题者想要的解法，不过时间还可以，300+ms

#pragma comment(linker, "/STACK:1000000000")
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#define LL long long
#define MAXN 100005
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;
struct Edge
{
    int from, to, dist;
    Edge(int from, int to, int dist):from(from), to(to), dist(dist){};
};
struct HeapNode
{
    int d, u;
    HeapNode(int d, int u):d(d), u(u){};
    bool operator <(const HeapNode& rhs) const{
        return d > rhs.d;
    }
};
vector< set<int> > road[MAXN];
struct Dijstra
{
    int n, m;
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool done[MAXN];
    int d[MAXN];
    int p[MAXN];

    void init(int n){
        this->n = n;
        for(int i = 0; i <= n; i++){
            G[i].clear();
            road[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 dijstra(int s){
        priority_queue<HeapNode> Q;
        for(int i = 0; i <= n; i++){
            d[i] = INF;
        }
        d[s] = 0;
        memset(done, 0, sizeof(done));
        Q.push(HeapNode(0, 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] > d[u] + e.dist){
                    d[e.to] = d[u] + e.dist;
                    road[e.to].clear();
                    if(road[u].empty()){
                        set<int> tmp;
                        tmp.clear();
                        tmp.insert(u);
                        road[e.to].push_back(tmp);
                    }
                    else{
                        for(int j = 0; j < road[u].size(); j++){
                            road[e.to].push_back(road[u][j]);
                            road[e.to][j].insert(u);
                        }
                    }
                    p[e.to] = G[u][i];
                    Q.push(HeapNode(d[e.to], e.to));
                }
                else if(d[e.to] == d[u] + e.dist){
                    int w = road[e.to].size();
                    for(int j = 0; j < road[u].size(); j++){
                        road[e.to].push_back(road[u][j]);
                        road[e.to][w + j].insert(u);
                    }
                }
            }
        }
    }
};
int n, m, t, g, h, s;
Dijstra p;
vector<int> res;
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
#endif // OPEN_FILE
    int T;
    scanf("%d", &T);
    while(T--){
        scanf("%d%d%d", &n, &m, &t);
        scanf("%d%d%d", &s, &g, &h);
        int x, y, z;
        p.init(n);
        for(int i = 1; i <= m; i++){
            scanf("%d%d%d", &x, &y, &z);
            p.AddEdge(x, y, z);
            p.AddEdge(y, x, z);
        }
        p.dijstra(s);
        res.clear();
        for(int i = 1; i <= t; i++){
            scanf("%d", &x);
            for(int j = 0; j < road[x].size(); j++){
                road[x][j].insert(x);
                if(road[x][j].find(g) != road[x][j].end() && road[x][j].find(h) != road[x][j].end()){
                    res.push_back(x);
                    break;
                }
            }
        }
        sort(res.begin(), res.end());
        int w = res.size();
        for(int i = 0; i < w; i++){
            printf("%d ", res[i]);
        }
        printf("
");
    }
}