POJ1679 The Unique MST

题意

给你一个无向图，让你判断该图的最小生成树(MST)是否唯一。

题解

要判断最小生成树是否唯一，只需判断次小生成树和最小生成树的大小关系即可。要求次小生成树，就得先求最小生成树，在最小生成树的基础上进行枚举非MST边，每加一条非MST边，就会形成一个环，然后求这个环内的最大边权，依次枚举求最小值即可，这个环就是从非MST边的端点到两端点的LCA，所以要求一下LCA，顺便维护一下树上ST表，进行快速的查询最大值。
我的思路是先用Kruskal算法求一遍MST，中途分别保存未加入的边和加入的边，根据加入的边建树并且维护树上ST表，然后依次枚举非MST边，用树上倍增求一下LCA，根据高度差算一下两个端点到分别LCA的最大值，在MST的边权和上减去此最大值，再加上该非MST边的权值，得到一个新的值ans，遍历一遍维护ans的最小值，最后得到的即是次小生成树的边权和。

AC代码

#pragma GCC optimize(2)
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
using namespace std;
typedef long long ll;
#define sc(z) scanf("%d", &(z))
#define _ff(i, a, b) for (int i = (a); i <= (b); ++i)
#define _f(i, a, b) for (int i = (a); i < (b); ++i)
#define _rr(i, a, b) for (int i = (a); i >= (b); --i)
#define _r(i, a, b) for (int i = (a); i > (b); --i)
const int inf = 0x3f3f3f3f;

const int maxn = 105;
int mp[maxn][maxn];
vector<int> G[maxn];
struct node{
    int from, to, id, w;
}e[maxn * maxn];
vector<node> C;
int dep[maxn], anc[maxn][25], v[maxn * maxn];
int mx[maxn][25];
int n, m, tot, fa[maxn], f[maxn];

void dfs(int u, int v) {
    _ff(i, 1, 20) {
        anc[u][i] = anc[anc[u][i - 1]][i - 1];
        mx[u][i] = max(mx[u][i - 1], mx[anc[u][i - 1]][i - 1]);
    }
    _f(i, 0, G[u].size()) {
	int k = G[u][i];
        if (k == v) continue;
	anc[k][0] = u;
	dep[k] = dep[u] + 1;
        mx[k][0] = mp[k][u];
	dfs(k, u);
    }
}

int lca(int u, int v) {
    if (dep[u] < dep[v]) swap(u, v);
    _rr(i, 20, 0) {
        if (dep[anc[u][i]] >= dep[v])
        	u = anc[u][i];
    }
    if (u == v) return v;
    _rr(i, 20, 0) {
        if (anc[u][i] != anc[v][i])
            u = anc[u][i], v = anc[v][i];
    }
    return anc[u][0];
}

bool cmp(node a, node b) {
    return a.w < b.w;
}

int find_fa(int x) {
    while (x != fa[x]) x = fa[x] = fa[fa[x]];
    return x;
}

int qmax(int u, int v) {
    if (u == v) return 0;
    int k = log(dep[u] - dep[v] + 1);
    int p = u, d = (1<<k);
    _rr(i, 20 , 0) if (dep[anc[p][i]] + d >= dep[v] + 1) p = anc[p][i];
    return max(mx[u][k], mx[p][k]);
}

void solve() {
    sort(e + 1, e + 1 + tot, cmp);
    _ff(i, 1, n) fa[i] = i;
    int cnt = 0, minn = 0, ans = inf;
    _ff(i, 1, n) fa[i] = i;
    _ff(i, 1, tot) {
        int x = find_fa(e[i].from), y = find_fa(e[i].to);
        if (x == y) {
            C.push_back(e[i]);
            continue;
        }
        fa[x] = y;
        G[e[i].from].push_back(e[i].to);
        G[e[i].to].push_back(e[i].from);
        minn += e[i].w;
        v[e[i].id>>1] = 1;
        if (++cnt == n - 1) break;
    }
    _ff(i, cnt + 1, tot) C.push_back(e[i]);
    dep[1] = 0, dep[0] = -1;
    dfs(1, 0);
    _f(i, 0, C.size()) {
        if (v[C[i].id>>1]) continue;
        int fr = C[i].from, to = C[i].to;
        int ca = lca(fr, to);
        int tmp = max(qmax(fr, ca), qmax(to, ca));
        ans = min(ans, minn - tmp + C[i].w);
        v[C[i].id>>1] = 1;
    }
    if (ans == minn) cout << "Not Unique!" << endl;
    else printf("%d\n", minn);
}

signed main() {
    int kase; scanf("%d", &kase);
    while (kase--) {
        tot = 0;
        int x, y, z; scanf("%d%d", &n, &m);
        _ff(i, 1, m) {
            scanf("%d%d%d", &x, &y, &z);
            ++tot;
            e[tot] = {x, y, tot + 1, z};
            ++tot;
            e[tot] = {y, x, tot + 1, z};
            mp[x][y] = mp[y][x] = z;
        }
        solve();
        C.clear();
        _ff(i, 1, n) G[i].clear();
        memset(v, 0, sizeof(v));
        memset(mx, 0, sizeof(mx));
    }
    return 0;
}