【最小生成树+LCA】Imperial roads

http://codeforces.com/gym/101889
I

先跑一遍最小生成树，把经过的边和答案记录下来
对于每个询问的边，显然如果处于MST中，答案不变
如果不在MST中，假设这条边连上了，那么就会和原本的MST形成环，删除这个环中权值最大的边就是答案
处理的时候，可以用LCA维护MST：给出边的两个节点u、v，那么u和v的LCA路径上的最大值边就是环中权值最大的边

代码：

#include <iostream>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
typedef long long ll;
const int MAX_V = 100005;
const int MAX_E = 200005;
const int MAX_N = 100005;
struct LCA_Online {
    int N, M, E, root, in[MAX_N], head[MAX_N];
    int f[MAX_N][30], c[MAX_N][30], depth[MAX_N];
    struct Edge {
        int to, next, cost;
    } es[MAX_N << 2];
    void addEdge(int u, int v, int w) {
        es[E].to = v;
        es[E].next = head[u];
        es[E].cost = w;
        head[u] = E++;
        in[v]++;
    }
    void init(int N) {
        this->N = N;
        this->M = floor(log2(double(N)));
        this->E = 0;
        this->root = 0;
        memset(head, -1, sizeof head);
        memset(f, 0, sizeof f);
        memset(c, 0, sizeof c);
        memset(in, 0, sizeof in);
    }
    void dfs(int u) {
        for (int j = 1; j <= M; j++) {
            f[u][j] = f[f[u][j - 1]][j - 1];
            c[u][j] = max(c[u][j - 1], c[f[u][j - 1]][j - 1]);
        }
        for (int i = head[u]; ~i; i = es[i].next) {
            int v = es[i].to;
            int w = es[i].cost;
            if (v != f[u][0]) {
                depth[v] = depth[u] + 1;
                f[v][0] = u;
                c[v][0] = w;
                dfs(v);
            }
        }
    }
    void run() {
        dfs(1);
    }
    int LCA(int u, int v) {
        if (depth[u] < depth[v]) {
            swap(u, v);
        }
        int res = 0;
        int d = depth[u] - depth[v];
        for (int i = 0; i <= M; i++) {
            if ((1 << i) & d) {
                res = max(res, c[u][i]);
                u = f[u][i];
            }
        }
        if (u == v) {
            return res;
        }
        for (int i = M; i >= 0; i--) {
            if (f[u][i] != f[v][i]) {
                res = max(res, max(c[u][i], c[v][i]));
                u = f[u][i];
                v = f[v][i];
            }
        }
        return max(res, max(c[u][0], c[v][0]));
    }
} lca;
struct Kruskal {
    struct Edge {
        int from, to, cost;
        bool operator< (const Edge& e) const {
            return cost < e.cost;
        }
    } es[MAX_E];
    int V, E, p[MAX_V];
    void init(int V) {
        this->V = V;
        this->E = 0;
        for (int i = 0; i < V; i++) {
            p[i] = i;
        }
    }
    void addEdge(int u, int v, int w) {
        es[E].from = u;
        es[E].to = v;
        es[E].cost = w;
        E++;
    }
    int find(int x) {
        return x == p[x] ? x : p[x] = find(p[x]);
    }
    void unite(int x, int y) {
        p[find(y)] = find(x);
    }
    ll kruskal() {
        ll sum = 0;
        sort(es, es + E);
        for (int i = 0; i < E; i++) {
            Edge &e = es[i];
            if (find(e.from) != find(e.to)) {
                sum += e.cost;
                unite(e.from, e.to);
                lca.addEdge(e.from, e.to, e.cost);
                lca.addEdge(e.to, e.from, e.cost);
            }
        }
        return sum;
    }
} kru;
map<pair<int, int>, int> cost;
int main() {
    int N, R, Q;
    scanf("%d%d", &N, &R);
    kru.init(N);
    lca.init(N);
    for (int i = 0, u, v, w; i < R; i++) {
        scanf("%d%d%d", &u, &v, &w);
        if (u > v) {
            swap(u, v);
        }
        cost[make_pair(u, v)] = w;
        //cost[make_pair(v, u)] = w;
        kru.addEdge(u, v, w);
        //kru.addEdge(v, u, w);
    }
    ll ans = kru.kruskal();
    lca.run();
    scanf("%d", &Q);
    while (Q--) {
        int u, v;
        scanf("%d%d", &u, &v);
        if (u > v) {
            swap(u, v);
        }
        printf("%I64d\n", ans + cost[make_pair(u, v)] - lca.LCA(u, v));
    }
}