BZOJ 1977 严格次小生成树(算竞进阶习题)

树上倍增+kruskal

要找严格次小生成树，肯定先要找到最小生成树。

我们先把最小生成树的边找出来建树，然后依次枚举非树边，容易想到一种方式：

• 对于每条非树边(u,v)，他会与树上的两个点构成环，我们在树上的两个点路径上找到最大值a和次大值b，如果非树边(u,v)的权值大于a，那么用mst-a+w(u,v)
• 如果非树边(u, v)的权值等于a，那么用mst-b+w(u,v)
  
  枚举完所有非树边之后，最小值就是严格次小生成树

对于每个点路径的最大值和次大值，我们可以和LCA一样，用树上倍增的方式

g[s][i][0]表示s到s的第2^{i次方个祖先的路径上的最大值，g[s][i][1]表示s到s的第2}i次方个祖先的路径上的次大值

在查询时只需要将两个点分别往上跳至LCA，最后合并最大值和次大值即可

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define inf 2333333333333333333
#define full(a, b) memset(a, b, sizeof a)
using namespace std;
typedef long long ll;
inline int lowbit(int x){ return x & (-x); }
inline int read(){
    int X = 0, w = 0; char ch = 0;
    while(!isdigit(ch)) { w |= ch == '-'; ch = getchar(); }
    while(isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
    return w ? -X : X;
}
inline int gcd(int a, int b){ return a % b ? gcd(b, a % b) : b; }
inline int lcm(int a, int b){ return a / gcd(a, b) * b; }
template<typename T>
inline T max(T x, T y, T z){ return max(max(x, y), z); }
template<typename T>
inline T min(T x, T y, T z){ return min(min(x, y), z); }
template<typename A, typename B, typename C>
inline A fpow(A x, B p, C lyd){
    A ans = 1;
    for(; p; p >>= 1, x = 1LL * x * x % lyd)if(p & 1)ans = 1LL * x * ans % lyd;
    return ans;
}
const int N = 100005;
const int M = 300005;
int n, m, cnt, head[N], parent[N], depth[N], t, val1, val2;
int p[N][20], g[N][20][2];
ll mst;
bool vis[M];
struct E {
    int u, v, w;
    bool operator < (const E &rhs) const {
        return w < rhs.w;
    }
}e[M];
struct Edge { int v, next, w; }edge[M<<1];

void addEdge(int a, int b, int w){
    edge[cnt].v = b, edge[cnt].w = w, edge[cnt].next = head[a], head[a] = cnt ++;
}

int find(int p){
    while(p != parent[p]) parent[p] = parent[parent[p]], p = parent[p];
    return p;
}

bool isConnect(int p, int q){ return find(p) == find(q); }

void unionElements(int p, int q){
    int pRoot = find(p), qRoot = find(q);
    if(pRoot == qRoot) return;
    parent[pRoot] = qRoot;
}

void kruskal(){
    full(head, -1);
    for(int i = 0; i <= n; i ++) parent[i] = i;
    sort(e, e + m);
    int tot = 0;
    for(int i = 0; i < m; i ++){
        int u = e[i].u, v = e[i].v;
        if(isConnect(u, v)) continue;
        unionElements(u, v), addEdge(u, v, e[i].w), addEdge(v, u, e[i].w);
        mst += e[i].w, vis[i] = true, tot ++;
        if(tot == n - 1) break;
    }
}

void dfs(int s, int fa){
    depth[s] = depth[fa] + 1;
    p[s][0] = fa;
    for(int i = 1; i <= t; i ++){
        p[s][i] = p[p[s][i - 1]][i - 1];
        g[s][i][0] = max(g[s][i - 1][0], g[p[s][i - 1]][i - 1][0]);
        if(g[s][i - 1][0] == g[p[s][i - 1]][i - 1][0])
            g[s][i][1] = max(g[s][i - 1][1], g[p[s][i - 1]][i - 1][1]);
        else if(g[s][i - 1][0] > g[p[s][i - 1]][i - 1][0])
            g[s][i][1] = max(g[s][i - 1][1], g[p[s][i - 1]][i - 1][0]);
        else g[s][i][1] = max(g[s][i - 1][0], g[p[s][i - 1]][i - 1][1]);
    }
    for(int i = head[s]; i != -1; i = edge[i].next){
        int u = edge[i].v;
        if(u == fa) continue;
        g[u][0][0] = edge[i].w, g[u][0][1] = -INF;
        dfs(u, s);
    }
}

int lca(int x, int y){
    if(depth[x] < depth[y]) swap(x, y);
    for(int i = t; i >= 0; i --){
        if(depth[p[x][i]] >= depth[y]) x = p[x][i];
    }
    if(x == y) return y;
    for(int i = t; i >= 0; i --){
        if(p[x][i] != p[y][i]) x = p[x][i], y = p[y][i];
    }
    return p[y][0];
}

void calc(int s, int v){
    for(int i = t; i >= 0; i --){
        if(depth[p[s][i]] >= depth[v]){
            if(g[s][i][0] == val1)
                val2 = max(val2, g[s][i][1]);
            else if(val1 < g[s][i][0])
                val2 = max(val1, g[s][i][1]);
            else val2 = max(g[s][i][0], g[s][i][1]);
            val1 = max(val1, g[s][i][0]);
            s = p[s][i];
        }
    }
}

int main(){

    n = read(), m = read();
    for(int i = 0; i < m; i ++){
        e[i].u = read(), e[i].v = read(), e[i].w = read();
    }
    kruskal();
    t = (int)(log(n) / log(2)) + 1;
    dfs(1, 0);
    ll ans = inf;
    val1 = 0, val2 = -INF;
    for(int i = 0; i < m; i ++){
        if(vis[i]) continue;
        int u = e[i].u, v = e[i].v, f = lca(u, v);
        calc(u, f), calc(v, f);
        if(e[i].w > val1) ans = min(ans, (ll)(mst - val1 + e[i].w));
        else ans = min(ans, (ll)(mst - val2 + e[i].w));
    }
    printf("%lld\n", ans);
    return 0;
}