Educational Codeforces Round 51 (Rated for Div. 2) The Shortest Statement

题目链接：The Shortest Statement

今天又在群里看到一个同学问$n$个$n$条边，怎么查询两点直接最短路。看来这种题还挺常见的。

为什么最终答案要从42个点的最短路(到$x,y$)之和，还有$x,y$到$LCA(x,y)$的距离里面取呢？

就是如果走非树边，那么一定要走42个点中的一个，不走树边，就是LCA求了。

我写的太蠢了，还写生成树，看大家都是LCA中的dfs直接标记下就行了。

验证了算法的正确，我又试了试把每条非树边只加一个点，也是AC的，其实想了想，确实正确。

 #include <bits/stdc++.h>
 using namespace std;

 typedef long long ll;
 const int maxn = 1e5 + ;
 const ll INF = 0x3f3f3f3f3f3f3f3f;
 struct edge{
     int to;
     ll cost;
     friend bool operator < (edge A,edge B){
         return A.cost > B.cost;
     }
 };
 int u[maxn], v[maxn], w[maxn], vis[maxn];
 vector<int> flag;
 ll d[][maxn];
 vector<edge> g[maxn];
 bool done[maxn];
 void dijkstra(ll d[], vector<edge> g[], bool done[], int s){
     fill(d,d + maxn, INF);
     fill(done, done + maxn, false);
     d[s] = ;
     priority_queue<edge> q;
     q.push((edge){s,});
     while(!q.empty()){
         edge cur = q.top(); q.pop();
         int v = cur.to;
         if(done[v]) continue;
         done[v] = true;
         for(int i = ; i<g[v].size(); i++){
             edge e = g[v][i];
             if(d[e.to]>d[v]+e.cost){
                 d[e.to] = d[v]+e.cost;
                 q.push((edge){e.to,d[e.to]});
             }
         }
     }
 }
 ///加边
 int cnt, h[maxn];
 struct node
 {
     int to, pre, v;
 } e[maxn << ];
 void init()
 {
     cnt = ;
     memset(h, , sizeof(h));
 }
 void add(int from, int to, int v)
 {
     cnt++;
     e[cnt].pre = h[from]; ///5-->3-->1-->0
     e[cnt].to = to;
     e[cnt].v = v;
     h[from] = cnt;
 }
 ///LCA
 ll dist[maxn];
 int dep[maxn];
 int anc[maxn][]; ///2分的父亲节点
 void dfs(int u, int fa)
 {
     for(int i = h[u]; i; i = e[i].pre)
     {
         int v = e[i].to;
         if(v == fa) continue;
         dist[v] = dist[u] + e[i].v;
         dep[v] = dep[u] + ;
         anc[v][] = u;
         dfs(v, u);
     }
 }
 void LCA_init(int n)
 {
     for(int j = ; ( << j) < n; j++)
         for(int i = ; i <= n; i++) if(anc[i][j-])
         anc[i][j] = anc[anc[i][j-]][j-];
 }
 int LCA(int u, int v)
 {
     int log;
     if(dep[u] < dep[v]) swap(u, v);
     for(log = ; ( << log) < dep[u]; log++);
     for(int i = log; i >= ; i--)
         if(dep[u] - ( << i) >= dep[v]) u = anc[u][i];
     if(u == v) return u;
     for(int i = log; i >= ; i--)
         if(anc[u][i] && anc[u][i] != anc[v][i])
             u = anc[u][i], v = anc[v][i];
     return anc[u][];
 }

 int pre[maxn];
 int Find(int x)
 {
     if(x == pre[x]) return x;
     else return pre[x] = Find(pre[x]);
 }
 int main()
 {
     int n, m; scanf("%d %d", &n, &m);
     for(int i = ; i <= m; i++)
     {
         scanf("%d %d %d", &u[i], &v[i], &w[i]);
         g[u[i]].push_back({v[i], w[i]});
         g[v[i]].push_back({u[i], w[i]});
     }
     ///先找生成树
     for(int i = ; i <= n; i++) pre[i] = i;
     for(int i = ; i <= m; i++)
     {
         int x = Find(u[i]);
         int y = Find(v[i]);
         if(x != y)
         {
             pre[x] = y;
         }
         else flag.push_back(u[i]), flag.push_back(v[i]), vis[i] = ;
     }
     ///对至多42个点跑最短路
     sort(flag.begin(), flag.end());
     flag.erase(unique(flag.begin(), flag.end()), flag.end());
     for(int i = ; i < flag.size(); i++)
     {
         dijkstra(d[i], g, done, flag[i]);
     }
     ///跑LCA
     init();
     for(int i = ; i <= m; i++)
     {
         if(!vis[i]) add(u[i], v[i], w[i]), add(v[i], u[i], w[i]);
     }
     dist[] = ;
     dfs(, );
     LCA_init(n);
     int Q; scanf("%d", &Q);
     ///查询
     while(Q--)
     {
         int x, y; scanf("%d %d", &x, &y);
         ll ans = dist[x] + dist[y] - 2LL * dist[LCA(x, y)];
         for(int i = ; i < flag.size(); i++)
         {
             ans = min(ans, d[i][x] + d[i][y]);
         }
         printf("%lld\n", ans);
     }
     return ;
 }