【 bzoj 3955 】[WF2013]Surely You Congest - 网络流 SPFA

　　显然地可以看出两个乘客有可能撞车当且仅当他们的最短路相同。
　　于是对乘客按最短路分组，每组在图的最短路DAG上跑类似最大路径覆盖的东西即可。
　　每次稍微要重新构图，复杂度可能比较高，不过跑起来还是可以的。
　　
　　

#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for (int i = a , _ = b ; i <= _ ; i ++)
#define per(i,a,b) for (int i = a , _ = b ; i >= _ ; i --)
#define For(i,a,b) for (int i = a , _ = b ; i <  _ ; i ++)
#define fore(i,u)  for (int i = head[u] ; i ; i = nxt[i])
#define pb push_back

inline int rd() {
    char c = getchar();
    while (!isdigit(c) && c != '-') c = getchar() ; int x = 0 , f = 1;
    if (c == '-') f = -1; else x = c - '0';
    while (isdigit(c = getchar())) x = x * 10 + c - '0';
    return x * f;
}

const int maxn = 42007;
const int maxm = 130007;
const int inf = 0x7fffffff;

typedef int arr[maxn];
typedef int adj[maxm];

arr head , dis , vis , st;
adj to , nxt , val;

vector<int> pre[maxn];
queue<int> Q;

int n , m , c , ett , S , ans;

inline void ins(int u , int v , int w) {
    to[++ ett] = v , nxt[ett] = head[u] , val[ett] = w , head[u] = ett;
    to[++ ett] = u , nxt[ett] = head[v] , val[ett] = w , head[v] = ett;
}

void input() {
    n = rd() , m = rd() , c = rd();
    rep (i , 1 , m) {
        int u = rd() , v = rd() , w = rd();
        ins(u , v , w);
    }
    rep (i , 1 , c) st[i] = rd();
}

inline bool cmp(const int a , const int b) {
    return dis[a] < dis[b];
}

namespace dinic {
    arr head , dis , cur , tmp;
    adj to , nxt , flow , cap;

    int ett , ptt;

    inline void backup() {
        ptt = ett;
        rep (i , 1 , S) tmp[i] = head[i];
    }

    inline void restore() {
        rep (i , 1 , ett) flow[i] = 0;
        ett = ptt;
        rep (i , 1 , S) head[i] = tmp[i];
    }

    inline void ins(int u , int v , int c) {
//      printf("%d %d\n" , u , v);
        to[++ ett] = v , nxt[ett] = head[u] , cap[ett] = c , flow[ett] = 0 , head[u] = ett;
        to[++ ett] = u , nxt[ett] = head[v] , cap[ett] = 0 , flow[ett] = 0 , head[v] = ett;
    }

    bool bfs() {
        rep (i , 1 , S) dis[i] = 0;
        dis[S] = 1 , Q.push(S);
        while (!Q.empty()) {
            int u = Q.front() ; Q.pop();
            fore (i , u) if (cap[i] > flow[i]) {
                int v = to[i];
                if (!dis[v]) {
//                  printf("%d %d\n" , u , v);
                    dis[v] = dis[u] + 1;
                    Q.push(v);
                }
            }
        }
//      rep (i , 1 , S) printf("%d%c" , dis[i] , i == S ? '\n' : ' ');
        return dis[1] > 0;
    }

    int dfs(int u , int a) {
        if (u == 1 || !a) return a;
        int ret = 0 , f;
        for (int&i = cur[u] ; i ; i = nxt[i]) {
            int v = to[i];
            if (dis[v] == dis[u] + 1 && (f = dfs(v , min(a , cap[i] - flow[i]))) > 0) {
                flow[i] += f , flow[i ^ 1] -= f , a -= f , ret += f;
                if (!a) break;
            }
        }
        return ret;
    }

    int MaxFlow() {
        int ret = 0;
        while (bfs()) {
            rep (i , 1 , S) cur[i] = head[i];
            ret += dfs(S , inf);
//          printf("%d\n" , ret);
        }
        return ret;
    }
}

void spfa() {
    rep (i , 1 , n) dis[i] = inf;
    dis[1] = 0 , Q.push(1);
    while (!Q.empty()) {
        int u = Q.front() ; Q.pop();
        vis[u] = 0;
        fore (i , u) {
            int v = to[i];
            if (dis[v] > dis[u] + val[i]) {
                dis[v] = dis[u] + val[i];
                pre[v].clear() , pre[v].pb(u);
                if (!vis[v]) Q.push(v) , vis[v] = 1;
            } else if (dis[v] == dis[u] + val[i])
                pre[v].pb(u);
        }
    }
    rep (u , 1 , n) {
        For (i , 0 , pre[u].size())
            dinic::ins(u , pre[u][i] , 1);
    }
}

void solve() {
    dinic::ett = 1;
    spfa();
    sort(st + 1 , st + c + 1 , cmp);
    S = n + 1;
    dinic::backup();
    for (int i = 1 , j ; i <= c ; i = j + 1) {
        j = i;
        while (j < c && dis[st[j + 1]] == dis[st[i]]) j ++;
        if (i == j) { ans ++ ; continue ; }
        dinic::restore();
        rep (k , i , j) dinic::ins(S , st[k] , 1);
        ans += dinic::MaxFlow();
    }
    printf("%d\n" , ans);
}

int main() {
    #ifndef ONLINE_JUDGE
        freopen("data.txt" , "r" , stdin);
    #endif
    input();
    solve();
    return 0;
}