P2934 [USACO09JAN]安全出行Safe Travel

P2934 [USACO09JAN]安全出行Safe Travel

https://www.luogu.org/problemnew/show/P2934

分析：

　　建出最短路树，然后考虑一条非树边u,v,w，它可以让u->lca的路径上的点x的答案更新为dis[v]+dis[u]+w-dis[x]。为从1走到v（dis[v]），从v走到u（+w），从u走到x，（dis[u]-dis[x]）。

　　然后对于每条非树边，按照dis[v]+dis[u]+w排序，然后会发现每个点只会更新一次，然后用并查集维护。

代码：

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<cmath>
 #include<iostream>
 #include<cctype>
 #include<set>
 #include<vector>
 #include<queue>
 #include<map>
 using namespace std;
 typedef long long LL;

 inline int read() {
     int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;
     for(;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;
 }

 const int N = ;
 const int INF = 1e9;

 struct Edge{
     int u,v,w,lca;
     Edge() {}
     Edge(int a,int b,int c,int d) { u = a, v = b, w = c; lca = d;}
     bool operator < (const Edge &A) const {
         return w < A.w;
     }
 }e[N];
 int fa[N], far[N], ans[N], n;

 namespace ShortestPath{
     #define pa pair<int,int>
     #define mp(a,b) make_pair(a,b)
     priority_queue< pa, vector< pa >, greater< pa > >q;
     int head[N], nxt[N], to[N], len[N], dis[N], En;
     bool vis[N];
     void add_edge(int u,int v,int w) {
         ++En; to[En] = v; len[En] = w; nxt[En] = head[u]; head[u] = En;
         ++En; to[En] = u; len[En] = w; nxt[En] = head[v]; head[v] = En;
     }
     void dijkstra() {
         for (int i=; i<=n; ++i) dis[i] = INF, vis[i] = false;
         dis[] = ;
         q.push(mp(dis[],));
         while (!q.empty()) {
             pa now = q.top(); q.pop();
             int u = now.second;
             if (vis[u]) continue;
             vis[u] = true;
             for (int i=head[u]; i; i=nxt[i]) {
                 int v = to[i];
                 if (dis[v] > dis[u] + len[i]) {
                     fa[v] = u;
                     dis[v] = dis[u] + len[i];
                     q.push(mp(dis[v], v)); // 居然写成了mp(v,dis[v])！！！
                 }
             }
         }
     }
 }
 namespace Tree_Chain{
     int IIIII;
     int siz[N], son[N], bel[N], deth[N];
     vector<int> T[N];
     void dfs1(int u) {
         siz[u] = ;
         deth[u] = deth[fa[u]] + ;
         for (int sz=T[u].size(),i=; i<sz; ++i) {
             int v = T[u][i];
             if (v == fa[u]) continue;
             dfs1(v);
             siz[u] += siz[v];
             if (!son[u] || siz[v] > siz[son[u]]) son[u] = v;
         }
     }
     void dfs2(int u,int top) {
         bel[u] = top;
         if (!son[u]) return;
         dfs2(son[u], top);
         for (int sz=T[u].size(),i=; i<sz; ++i) {
             int v = T[u][i];
             if (v == fa[u] || v == son[u]) continue;
             dfs2(v, v);
         }
     }
     int LCA(int u,int v) {
         while (bel[u] != bel[v]) {
             if (deth[bel[u]] < deth[bel[v]]) swap(u, v);
             u = fa[bel[u]];
         }
         if (deth[u] < deth[v]) return u;
         return v;
     }
     void Main() {
         for (int i=; i<=n; ++i) T[fa[i]].push_back(i);
         dfs1();
         dfs2(, );
     }
 }
 using namespace ShortestPath;
 using namespace Tree_Chain;

 int find(int x) {
     return x == far[x] ? x : far[x] = find(far[x]);
 }
 void Merge(int u,int v) {
     u = find(u), v = find(v);
     if (u != v) far[u] = v;
 }
 void update(int u,int lca,int v) {
     u = find(u);
     int x = fa[u];
     while (deth[u] > deth[lca]) {
         ans[u] = v; Merge(u, x);
         u = find(u); x = fa[u];
     }
 }
 int main() {
     n = read(); int m = read();
     for (int i=; i<=m; ++i) {
         int u = read(), v = read(), w = read();
         add_edge(u, v, w);
     }

     ShortestPath::dijkstra();
     Tree_Chain::Main();

     int cnt = ;
     for (int u=; u<=n; ++u) {
         for (int i=head[u]; i; i=nxt[i]) {
             int v = to[i];
             if (v > u && u != fa[v] && v != fa[u])
                 e[++cnt] = Edge(u, v, dis[u] + dis[v] + len[i], LCA(u,v)); // e[i].w，zz的减了一个dis[lca]
         }
     }
     for (int i=; i<=n; ++i) far[i] = i, ans[i] = INF;
     sort(e + , e + cnt + );
     for (int i=; i<=cnt; ++i) {
         update(e[i].u, e[i].lca, e[i].w);
         update(e[i].v, e[i].lca, e[i].w);
     }
     for (int i=; i<=n; ++i)
         if (ans[i] == INF) puts("-1");
         else printf("%d\n",ans[i] - dis[i]);
     return ;
 }