洛谷P4180 严格次小生成树 BZOJ1977 【Kruskal and LCA倍增】

传送门
// 问题很简单, 就是求次小生成树, 并且权值是严格小于, 不是之前的小于等于乐.

这道题写了我一下午….. 我好菜啊~ , 原先维护的树上任意两点之间的最大值, 然后依次去找这个环中的最大以及次大值, 老是要错…. 死活过不了第一个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);
}