题意：给你一张n个节点和m条边的无向连通图， 你可以执行很多次操作，对某一条边的权值+1（对于每条边，可以不加，可以无限次加），问至少进行多少次操作，可以使这张图的最小生成树变得唯一，并且最小生成树的边权总和和原图的最小生成树一样。
思路：容易发现， 我们没必要给一条边反复加权值，最多加一次就够了，因为加一次就已经可能改变最小生成树的总边权了。所以，这个题换一种说法，就是问这张图有多少条边，加入最小生成树之后删掉一条其它的边也是最小生成树。
法1：我们首先可以把这颗最小生成树构造出来，然后暴力枚举每一条边，判断可不可以加到最小生成树中。假设这条边的端点是u, v，那么在树中就形成了一个环，为u -> v -> LCA(u, v) -> u;我们只需要判断这条新加入的边是否比环中的其它边大就行了，不可能比环中的其它边的最大值小。因为如果这条边比环中边权最大的边小，那么删除边权最大的边就可以构成一颗更小的生成树，这不符合最小生成树的定义了，那么换句话说，我们构造出来的这棵树就不是最小生成树了。那么怎么找环上其它边的最大值呢？我们可以用倍增的思想，在倍增法求LCA的预处理时也可以把最值的预处理出来。查询最大值时套用LCA的框架更新最大值。
代码：
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 200010;
struct Edge{
int u, v, w;
bool operator < (const Edge& rhs) const {
return w < rhs.w;
}
};
Edge edge[maxn];
int mx[maxn][20], f[maxn][20];
int t;
int head[maxn], Next[maxn * 2], edge1[maxn * 2], ver[maxn * 2], tot;
int fa[maxn], d[maxn];
queue<int> q;
bool v[maxn];
void add(int x, int y, int z) {
ver[++tot] = y;
edge1[tot] = z;
Next[tot] = head[x];
head[x] = tot;
} int get(int x) {
if(x == fa[x]) return x;
return fa[x] = get(fa[x]);
} void bfs() {
q.push(1);
d[1] = 1;
while(q.size()) {
int x = q.front();
q.pop();
for(int i = head[x]; i; i = Next[i]) {
int y = ver[i], z = edge1[i];
if(d[y]) continue;
d[y] = d[x] + 1;
f[y][0] = x;
mx[y][0] = z;
for(int j = 1; j <= t; j++) {
f[y][j] = f[f[y][j - 1]][j - 1];
mx[y][j] = max(mx[y][j - 1], mx[f[y][j - 1]][j - 1]);
}
q.push(y);
}
}
} int query(int x, int y) {
if(d[x] > d[y]) swap(x, y);
int ans = -INF;
for(int i = t; i >= 0; i--) {
if(d[f[y][i]] >= d[x]) {
ans = max(ans, mx[y][i]);
y = f[y][i];
}
}
if(x == y) return ans;
for(int i = t; i >= 0; i--) {
if(f[x][i] != f[y][i]) {
ans = max(ans, mx[x][i]);
ans = max(ans, mx[y][i]);
x = f[x][i];
y = f[y][i];
}
}
return max(ans, max(mx[x][0], mx[y][0]));
}
int main() {
int n, m;
// freopen("in.txt", "r", stdin);
scanf("%d%d", &n, &m);
t = (int)(log(n) / log(2)) + 1;
for(int i = 1; i <= m; i++) {
scanf("%d%d%d",&edge[i].u, &edge[i].v, &edge[i].w);
}
sort(edge + 1, edge + 1 + m);
for(int i = 1; i <= n; i++) fa[i] = i;
for(int i = 1; i <= m; i++) {
int x = get(edge[i].u);
int y = get(edge[i].v);
if(x == y)continue;
fa[x] = y;
v[i] = 1;
add(edge[i].u, edge[i].v, edge[i].w);
add(edge[i].v, edge[i].u, edge[i].w);
}
bfs();
int ans = 0;
for(int i = 1; i <= m; i++) {
if(v[i])continue;
int tmp = query(edge[i].u, edge[i].v);
if(tmp == edge[i].w) ans++;
}
printf("%d\n", ans);
}
法2：对于边权相同的边，我们可以把它们分成2类，一类是不可能成为最小生成树的边的边（之前有更小的边已经形成了一条链了），一类是可能的边，只是有一些边运气比较好，成为了当前最小生成树的边。我们就可以统计这些“运气不好”的边，运气不好“的边数目总和就是最终答案。具体过程：对于边权相同的边，我们先找出本来就不可能的边，在找到那些能成为最小生成树的“幸运边”，剩下的就是“运气不好”的边了。
代码：
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
struct Edge{
int u,v,w;
bool operator < (const Edge& rhs) const {
return w < rhs.w;
}
};
Edge edge[maxn];
int fa[maxn];
int get(int x) {
if(x == fa[x]) return x;
return fa[x] = get(fa[x]);
} bool merge(int x, int y) {
int tmp1 = get(x);
int tmp2 = get(y);
if(tmp1 == tmp2) return 0;
fa[tmp1] = tmp2;
return 1;
} int main() {
int n, m;
scanf("%d%d", &n, &m);
for(int i = 1; i <= m; i++) {
scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
}
sort(edge + 1, edge + 1 + m);
for(int i = 1; i <= n; i++) fa[i] = i;
int ans = 0, sum = 0;
for(int i = 1; i <= m; i++) {
int j = i;
while(edge[j + 1].w == edge[j].w) j++;
sum = j - i + 1;
for(int k = i; k <= j; k++) {
if(get(edge[k].u) == get(edge[k].v))
sum--;
}
for(int k = i; k <= j; k++) {
sum -= merge(edge[k].u, edge[k].v);
}
ans += sum;
i = j;
}
printf("%d\n", ans);
}