传送门
// 问题很简单, 就是求次小生成树, 并且权值是严格小于, 不是之前的小于等于乐.
这道题写了我一下午….. 我好菜啊~ , 原先维护的树上任意两点之间的最大值, 然后依次去找这个环中的最大以及次大值, 老是要错…. 死活过不了第一个case, 想死的心都有了…… 然后就改成了同时维护树上的严格次小值. 直接算所有的最小增量, 才过的… 之前找bug找了我三个小时, 还是放弃了……
做法很简单, 依旧是先找最小生成树, 然后枚举加边, 加了边后图中肯定有环, 此时我们就求删去环中 那条边使答案更优, 因为是严格, 所以直接删环中的最大边是错误的, 因为新加入的边的权值有可能等于这条最大边, 所以我们同时还要考虑下次大边, 记住这个次大是严格的…. 所以我们在树上维护的是严格次大边…. 维护树上的这些信息, 当然用倍增呀…
注意坑点: 那就是在倍增的过程中, 有可能这个点到祖先的次大值比另一个点到祖先的最大值还要大, 此时我们要那个点的次大值, 所以我们在程序中直接计算每个点的最大以及次大的增量值即可, 然后取全局最小.
复杂度(mlogn + mlogm + n) 应该是求次小生成树中最优秀的做法了…
AC Code
// LCA
const int maxn = 2e5 + 5;
int up[maxn][23], maxx[maxn][23], d2[maxn][23];
int deep[maxn], dis[maxn];
int cnt, head[maxn];
int n, m, q;
struct node {
int to, next, w;
}e[maxn<<1];
void init() {
Fill(head,-1); Fill(dis,0);
Fill(up,0); Fill(deep,0);
cnt = 0; Fill(maxx, -1); Fill(d2, 0);
}
void add(int u, int v, int w) {
e[cnt] = node{v, head[u], w};
head[u] = cnt++;
}
void dfs(int u,int fa,int d) {
deep[u] = d + 1;
for(int i = 1 ; i < 20 ; i ++) {
up[u][i] = up[up[u][i-1]][i-1];
maxx[u][i] = max(maxx[up[u][i-1]][i-1], maxx[u][i-1]);
if (maxx[u][i - 1] == maxx[up[u][i - 1]][i - 1]) // 维护的是严格小于
d2[u][i] = max(d2[u][i - 1], d2[up[u][i - 1]][i - 1]);
else {
d2[u][i] = min(maxx[u][i - 1], maxx[up[u][i - 1]][i - 1]);
d2[u][i] = max(d2[u][i], d2[u][i - 1]);
d2[u][i] = max(d2[u][i], d2[up[u][i - 1]][i - 1]);
}
}
for(int i = head[u] ; ~i ; i = e[i].next) {
int to = e[i].to;
if(to == fa) continue;
dis[to] = dis[u] + e[i].w;
up[to][0] = u;
maxx[to][0] = e[i].w;
dfs(to, u, d+1);
}
}
int LCA_BZ(int u,int v) {
if(deep[u] < deep[v]) swap(u,v);
int k = deep[u] - deep[v];
for(int i = 0 ; i < 20 ; i ++) {
if((1<<i) & k) {
u = up[u][i];
}
}
if(u != v) {
for(int i = 19 ; i >= 0 ; i --) {
if(up[u][i] != up[v][i]) {
u = up[u][i];
v = up[v][i];
}
}
u = up[u][0];
}
return u;
}
int cal(int u, int f, int w) {
int mx1 = 0, mx2 = 0;
int k = deep[u] - deep[f];
for(int i = 0 ; i < 20 ; i ++) {
if((1<<i) & k) {
if (maxx[u][i] > mx1) {
mx2 = mx1;
mx1 = maxx[u][i];
}
mx2 = max(mx2, d2[u][i]);
u = up[u][i];
}
}
if (mx1 != w) return w - mx1;
return w - mx2;
}
int work(int u, int v, int w) {
int f = LCA_BZ(u, v);
return min(cal(u, f, w) , cal(v, f, w));
}
// MST
struct edge {
int u, v, w;
bool operator < (const edge &_ ) const {
return w < _.w;
}
}s[maxn*3];
int fa[maxn], r[maxn];
bool vis[maxn*3];
void init2() {
for (int i = 1 ; i <= n ; i ++) {
fa[i] = i;
r[i] = 1;
}
Fill(vis, 0);
}
int Find(int x) {
return fa[x] == x ? x : fa[x] = Find(fa[x]);
}
bool Un(int x, int y) {
int fx = Find(x);
int fy = Find(y);
if (fx == fy) return false;
if (r[fx] > r[fy]) swap(fx, fy);
fa[fx] = fy;
r[fy] += r[fx];
return true;
}
ll kru() {
ll tot = 0, cnt = 0;
for (int i = 1 ; i <= m ; i ++) {
if (Un(s[i].u, s[i].v)) {
++ cnt;
tot += s[i].w;
add(s[i].u, s[i].v, s[i].w);
add(s[i].v, s[i].u, s[i].w);
vis[i] = 1;
}
if (cnt >= n - 1) break;
}
return tot;
}
void solve()
{
scanf("%d%d",&n,&m);
init(); init2();
for (int i = 1 ; i <= m ; i ++) {
scanf("%d%d%d",&s[i].u, &s[i].v, &s[i].w);
}
sort(s+1, s+1+m);
ll tot = kru();
up[1][0] = 1; //那根节点的父亲设为他自己.
maxx[1][0] = 0; dfs(1,-1,0);
ll ans = INF;
for (int i = 1 ; i <= m ; i ++) {
if (vis[i]) continue;
ll tmp = work(s[i].u, s[i].v, s[i].w);
ans = min(ans, tmp);
}
printf("%lld\n", tot + ans);
}