[BJWC2010] 严格次小生成树

时隔多日，做完这题（花了两个半小时），心血来潮，来写一篇题解！！！

原题链接：P4180 [BJWC2010] 严格次小生成树 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

题目描述

小 C 最近学了很多最小生成树的算法，Prim 算法、Kruskal 算法、消圈算法等等。正当小 C 洋洋得意之时，小 P 又来泼小 C 冷水了。小 P 说，让小 C 求出一个无向图的次小生成树，而且这个次小生成树还得是严格次小的，也就是说：如果最小生成树选择的边集是 E_MEM，严格次小生成树选择的边集是 E_SES，那么需要满足：(value(e)表示边 e 的权值) ∑e∈EMvalue(e)<∑e∈ESvalue(e)

这下小 C 蒙了，他找到了你，希望你帮他解决这个问题。

输入格式

第一行包含两个整数 NN 和 MM，表示无向图的点数与边数。

接下来 MM 行，每行 33 个数 x,y,zx,y,z 表示，点 xx 和点 yy 之间有一条边，边的权值为 zz。

输出格式

包含一行，仅一个数，表示严格次小生成树的边权和。

输入输出样例

输入 #1

5 6
1 2 1 
1 3 2 
2 4 3 
3 5 4 
3 4 3 
4 5 6 

输出 #1

11

对于 100% 的数据， N≤105，M≤3×105，边权 ∈[0,109]，数据保证必定存在严格次小生成树。

避雷：看到这题，首先构建最小生成树，然后大部分人会想到倍增（因为数据范围较大，n^2就直接爆了），dfs初始化，然后用数组1存某节点向上跳能跳到的节点，和数组2跳过的路径中最大的边权，那么恭喜你，完美的跳入出题人的坑了，本题要求输出严格次小生成树的权值和。这个坑应该不难想出，思考一下就明白了。

正解：定义数组3，用来维护跳过的路径中边权次大值。

了解了，大致思路，废话不多说，直接上代码！！！

#include <bits/stdc++.h>
using namespace std;
struct edge {
    int x, y, z, flag;
    bool operator < (const edge &A) const {
        return z < A.z;
    }
} a[300001];
struct node {
    int y, z;
};

vector<node> e[100001];
int n, m, tz, temp, pre[100001], fa[100001], dep[100001], f[100001][21], v[100001][21], l[100001][21];
long long w = 0, ans = 1LL << 60;

int find(int x) {
    if (x == fa[x])
        return x;
    else
        return fa[x] = find(fa[x]);
}

inline void dfs(int x) {
    for (auto s : e[x]) {
        int y = s.y, z = s.z;
        if (y != pre[x]) {
            pre[y] = x;
            dep[y] = dep[x] + 1;
            f[y][0] = x;
            v[y][0] = z;
            dfs(y);
        }
    }
}

int UP(int x, int d) {
    int res = x;
    for (int i = 0; (1 << i) <= d; i++)
        if (((1 << i) & d)) {
            if (v[res][i] < tz)
                temp = max(temp, v[res][i]);
            temp = max(temp, l[res][i]);
            res = f[res][i];
        }
    return res;
}

int LCA(int x, int y) {
    if (dep[x] < dep[y])
        swap(x, y);
    int rot = UP(x, dep[x] - dep[y]);
    if (rot == y)
        return rot;
    for (int i = 20; i >= 0; i--)
        if (f[rot][i] != f[y][i]) {
            if (v[rot][i] < tz)
                temp = max(temp, v[rot][i]);
            else
                temp = max(temp, l[rot][i]);
            if (v[y][i] < tz)
                temp = max(temp, v[y][i]);
            else
                temp = max(temp, l[y][i]);
            rot = f[rot][i];
            y = f[y][i];
        }
    if (v[rot][0] < tz)
        temp = max(temp, v[rot][0]);
    if (v[y][0] < tz)
        temp = max(temp, v[y][0]);
    return f[rot][0];
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++) {
        int x, y, z;
        scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].z);
        a[i].flag = 0;
    }
    sort(a + 1, a + m + 1);
    int ops = 0;
    for (int i = 1; i <= n; i++)
        fa[i] = i;
    for (int i = 1; i <= m; i++) {
        int x = a[i].x, y = a[i].y, z = a[i].z;
        int xx = find(x), yy = find(y);
        if (xx != yy) {
            a[i].flag = 1;
            w += z;
            fa[yy] = xx;
            ++ops;
            e[x].push_back({y, z});
            e[y].push_back({x, z});
        }
        if (ops == n - 1)
            break;
    }
    dfs(1);
    for (int i = 1; i <= 20; i++)
        for (int j = 1; j <= n; j++) {
            f[j][i] = f[f[j][i - 1]][i - 1];
            v[j][i] = max(v[j][i - 1], v[f[j][i - 1]][i - 1]);
            l[j][i] = max(l[j][i - 1], l[f[j][i - 1]][i - 1]);
            if (v[j][i - 1] < v[j][i])
                l[j][i] = max(l[j][i], v[j][i - 1]);
            if (v[f[j][i - 1]][i - 1] < v[j][i])
                l[j][i] = max(l[j][i], v[f[j][i - 1]][i - 1]);
        }
    for (int i = 1; i <= m; i++) {
        if (a[i].flag)
            continue;
        temp = 0;
        int x = a[i].x, y = a[i].y;
        tz = a[i].z;
        int d = LCA(x, y);
        if (temp) {
//            printf("%d %d %d\n", x, y, temp);
            ans = min(ans, w - temp + tz);
//            printf("%lld\n----\n", ans);
        }
    }
    printf("%lld\n", ans);
    
    return 0;
}

恭喜AC100，本题难度：省选/NOI-！！！ 紫