dsu + lca

贴一下使用dsu和lca的代码，dsu的代码很简单，可以马上写出来，但是lca的代码就不熟练了。这里lca的计算还是用了dfs的访问时间标记，我想起来割边， 割点的判断， dfu[u], low[u],的的使用，还有lca的离线算法，tarjan算法，然后又查到了求强连通分量的算法，也是使用访问时间标记，这些算法，有时间好好整理一下。dfs判断回路。等等。想起来再补充。

#include<bits/stdc++.h>
#define pb push_back
#define FOR(i, n) for (int i = 0; i < (int)n; ++i)
#define dbg(x) cout << #x << " at line " << __LINE__ << " is: " << x << endl
typedef long long ll;
using namespace std;
typedef pair<int, int> pii;
const int maxn = 2e5 + 10;
const int inf = 1e9 + 7;
int n, m;
int w[maxn], c[maxn], a[maxn], b[maxn];
// dsu disjoint set union //find and union
int sz[maxn], p[maxn];
void init() {
    for (int i = 1; i <= n; i++) {
        sz[i] = 1; p[i] = i;
    }
}
int get(int x) {
    if(x == p[x]) return x;
    return p[x] = get(p[x]);
}
bool unite(int x, int y) {
    x = get(x); y = get(y);
    if(x == y) return 0;
    if(sz[x] > sz[y]) swap(x, y);
    sz[y] += sz[x];
    p[x] = y;
    return 1;
}

struct node {
    int to, idx, w;
    node(int to, int idx, int w) : to(to), idx(idx), w(w) {}
};

vector<node> g[maxn];
int depth[maxn];
bool used[maxn];
pii fmaxi[maxn][20];
int tin[maxn], tout[maxn], timer;
int fup[maxn][20];
void dfs(int v, int p, int wup, int eidx, int dep) {
    tin[v] = ++timer;
    fup[v][0] = p;
    fmaxi[v][0] = {wup, eidx};
    depth[v] = dep;
    for (int i = 1; i < 20; i++) {
        fup[v][i] = fup[fup[v][i - 1] ][i - 1];
        fmaxi[v][i] = max(fmaxi[v][i - 1], fmaxi[fup[v][i - 1] ][i - 1]);
    }
    for (auto it : g[v]) {
        int to = it.to;
        int idx = it.idx;
        int w = it.w;
        if(to == p) continue;
        dfs(to, v, w, idx, dep + 1);
    }
    tout[v] = ++timer;
}

bool isAncestor(int x, int y) {
    return tin[x] <= tin[y] && tout[x] >= tout[y];
}
int lca(int x, int y) {
    if(isAncestor(x, y)) return x;
    if(isAncestor(y, x)) return y;
    for (int i = 20 - 1; i >= 0; i--) {
        if(!isAncestor(fup[x][i], y)) x = fup[x][i];
    }
    return fup[x][0];
}
pii getfmax1(int x, int p) {
    int len = depth[x] - depth[p];
    pii res = {-inf, -inf};
    for (int i = 20 - 1; i >= 0; i--) {
        if((len >> i) & 1) {
            len ^= (1 << i);
            res = max(res, fmaxi[x][i]);
            x = fup[x][i];
        }
    }
    return res;
}
pii getfmax(int x, int y) {
    int z = lca(x, y);
    return max(getfmax1(x, z), getfmax1(y, z));
}
int S;
ll sum;
int perm[maxn];
void solve() {
    cin >> n >> m;
    init();
    for (int i = 1; i <= m; i++) cin >> w[i];
    for (int i = 1; i <= m; i++) cin >> c[i];
    for (int i = 1; i <= m; i++) cin >> a[i] >> b[i];
    cin >> S;
    for (int i = 1; i <= m; i++)
        perm[i] = i;
    sort(perm + 1, perm + m + 1, [](int i, int j) {return w[i] < w[j];});
    vector<int> e;
    for (int j = 1; j <= m; j++) {
        int i = perm[j];
        if(unite(a[i], b[i])) {
            e.pb(i);
            sum += w[i];
        }
    }
    //cout << sum << endl;
    assert((int)e.size() == n - 1);
    for (int idx : e) {
        g[a[idx] ].pb({b[idx], idx, w[idx] });
        g[b[idx] ].pb({a[idx], idx, w[idx] });
    }
    dfs(1, 1, -inf, -inf, 0);
    pair<ll, pii> best = {(ll)1e18, {-1, -1}};
    for (int idx = 1; idx <= m; idx++) {
        pii z = getfmax(a[idx], b[idx]);
        ll nsum = sum - z.first + w[idx] - (S / c[idx]);
        pair<ll, pii> cur = {nsum, {z.second, idx} };
        best = min(best, cur);
    }
    assert(best.second.first != -1);
    cout << best.first << endl;
    for (int idx : e) {
        used[idx] = 1;
    }
    used[best.second.first] = 0;
    used[best.second.second] = 1;
    for (int i = 1; i <= m; i++) {
        if(used[i]) {
            cout << i << " ";
            int ww = w[i];
            if(i == best.second.second)
                ww -= S / c[i];
            cout << ww << endl;
        }
    }

}

int main() {
    //freopen("test.in", "r", stdin);
    //freopen("test.out", "w", stdout);
    solve();
    return 0;
}

void dfs2(int x, int lt) {
    fup[x][0] = lt;
    for (auto it : g[x]) {
        int to = it.to;
        int idx = it.idx;
        if(to == lt) continue;
        fmaxi[to][0] = {w[idx],  idx};
        depth[to] = depth[x] + 1;
        dfs2(to, x);
    }
}
void build(int root) {
    dfs2(1, 1);
    for (int i = 1; i <= 18; i++) {
        for (int x = 1; x <= n; x++) {
            fup[x][i] = fup[fup[x][i - 1] ][i - 1];
            fmaxi[x][i] = max(fmaxi[fup[x][i - 1] ][i - 1], fmaxi[x][i - 1] );

        }
    }
}
int adv(int x, int v, pii & ret) {
    for (int i = 0; (1 << i) <= v; i++) {
        if((v >> i) & 1) {
            ret = max(ret, fmaxi[x][i]);
            x = fup[x][i];
        }
    }
    return x;
}
pii lca2(int x, int y) {
    pii ret = {-1, -1};
    if(depth[x] > depth[y]) x = adv(x, depth[x] - depth[y], ret);
    else y = adv(y, depth[y] - depth[x], ret);
    if(x == y) return ret;
    for (int i = 17; i >= 0; i--) {
        if(fup[x][i] != fup[y][i]) {
            ret = max(ret, fmaxi[x][i]);
            ret = max(ret, fmaxi[y][i]);
            x = fup[x][i];
            y = fup[y][i];
        }
    }
    ret = max(ret, fmaxi[x][0]);
    ret = max(ret, fmaxi[y][0]);
    return ret;
}