严格次小生成树（lca + 倍增）

题目描述

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

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

输入输出格式

输入格式：

第一行包含两个整数N 和M，表示无向图的点数与边数。接下来 M行，每行 3个数x y z 表示，点 x 和点y之间有一条边，边的权值为z。

输出格式：

包含一行，仅一个数，表示严格次小生成树的边权和。(数据保证必定存在严格次小生成树)

首先用kruskal做一下最小生成树，把这些边称为“树边”，其余的为”非树边“，将每一条边权为v的非树边加到生成树中，则形成一个环，设环上的最大边和次大边分别为val1，val2，则显然：

当 val1 < v 时 sum + v - val1 就是一个候选答案；

当 val1 = v 时 sum + v - val2 就是一个候选答案；

比较所有的候选答案，最小的即是该题的解。那么问题就转换成：如何求环上的最大边和次大边；

可以用lca来写，f[i][k]表示点i向上跳2的k次方所对应的点，dis1[i][k] 和 dis2[i][k] 分别表示点i向上跳2的k次方所对应的最大边和次大边,则显然：

f[i][k] = f[f[i][k - 1]][k - 1];

dis1[i][k] = max(dis1[i][k - 1],dis1[f[i][k - 1]][k - 1]);

if(dis1[i][k - 1] == dis1[f[i][k - 1]][k - 1])

    　　dis2[i][k] = max(dis2[i][k - 1],dis2[f[i][k - 1]][k - 1]);

if(dis1[i][k - 1] > dis1[f[i][k - 1]][k - 1])

    　　dis2[i][k] = max(dis2[i][k - 1],dis1[f[i][k - 1]][k - 1]);

if(dis1[i][k - 1] < dis1[f[i][k - 1]][k - 1])

    　　dis2[i][k] = max(dis1[i][k - 1],dis2[f[i][k - 1]][k - 1]);

初值为：

f[i][] = father(i);

dis1[i][] = edge.v;

dis2[i][] = -INF(不存在)

最后求一下，时间为（mlogn + mlogm）；

#include <bits/stdc++.h>

using namespace std;

#define ll long long

#define INF 0x3f3f3f3f

#define MAXN 1000010

#define MAXM 100010

inline int read() {

    int x = ,ff = ;

    char ch = getchar();

    while(!isdigit(ch)) {

        if(ch == '-') ff = -;

        ch = getchar();

    }

    while(isdigit(ch)) {

        x = (x << ) + (x << ) + (ch ^ );

        ch = getchar();

    }

    return x * ff;

}

ll sum = ;

int n,m,tem = INF,tot = ,cnt = ;

int vis[MAXN],fa[MAXN],lin[MAXN],deep[MAXN],f[MAXM][],dis1[MAXM][],dis2[MAXM][];

struct tree {

    int x,y,v;

} t[MAXN];

struct edge {

    int y,v,next;

} e[MAXN];

inline bool cmp(tree x,tree y) {

    return x.v < y.v;

}

inline int get(int x) {

    return fa[x] == x ? x : (fa[x] = get(fa[x]));

}

inline void add(int xx,int yy,int vv) {

    e[++tot].y = yy;

    e[tot].v = vv;

    e[tot].next = lin[xx];

    lin[xx] = tot;

}

void Kruskal() {

    sort(t + ,t + m + ,cmp);

    for(int i = ; i <= n; ++i)

        fa[i] = i;

    for(int i = ; i <= m && cnt < n - ; ++i) {

        int x = get(t[i].x),y = get(t[i].y);

        if(x != y) {

            vis[i] = true;

            sum += t[i].v;

            fa[x] = y;

            cnt++;

            add(t[i].x,t[i].y,t[i].v);

            add(t[i].y,t[i].x,t[i].v);

        }

    }

}

void BFS() {

    queue < int > q;

    q.push();

    deep[] = ;

    while(!q.empty()) {

        int x = q.front();

        q.pop();

        for(int i = lin[x],y; i ; i = e[i].next) {

            if(deep[y = e[i].y]) continue;

            deep[y] = deep[x] + ;

            f[y][] = x;

            dis1[y][] = e[i].v;

            dis2[y][] = -INF;

            q.push(y);

            for(int j = ; j <= ; ++j) {

                f[y][j] = f[f[y][j - ]][j - ];

                dis1[y][j] = max(dis1[y][j - ],dis1[f[y][j - ]][j - ]);

                if(dis1[y][j - ] == dis1[f[y][j - ]][j - ])

                    dis2[y][j] = max(dis2[y][j - ],dis2[f[y][j - ]][j - ]);

                if(dis1[y][j - ] > dis1[f[y][j - ]][j - ])

                    dis2[y][j] = max(dis2[y][j - ],dis1[f[y][j - ]][j - ]);

                if(dis1[y][j - ] < dis1[f[y][j - ]][j - ])

                    dis2[y][j] = max(dis1[y][j - ],dis2[f[y][j - ]][j - ]);

            }

        }

    }

}

int lca(int x,int y) {

    if(deep[x] > deep[y]) swap(x,y);

    for(int i = ; i >= ; --i)

        if(deep[f[y][i]] >= deep[x])

            y = f[y][i];

    if(x == y)    return x;

    for(int i = ; i >= ; --i)

        if(f[x][i] != f[y][i])

            x = f[x][i],y = f[y][i];

    return f[x][];

}

void cal(int x, int fa, int v) {

    int val1 = , val2 = ;

    for(int i = ; i >= ; --i) {

        if(deep[f[x][i]] >= deep[fa]) {

            if (dis1[x][i] > val1) {

                val2 = val1;

                val1 = dis1[x][i];

            }

            val2  = max(val2, dis2[x][i]);

            x = f[x][i];

        }

    }

    if (val1 != v) tem = min(tem, v - val1);

    else tem = min(tem, v - val2);

}

int main() {

    n = read();

    m = read();

    for(int i = ; i <= m; ++i) {

        t[i].x = read();

        t[i].y = read();

        t[i].v = read();

    }

    Kruskal();

    BFS();

    for(int i = ; i <= m; ++i)

        if(!vis[i]) {

            int x = t[k].x,y = t[k].y;

            int fat = lca(x,y);

            cal(x,fat,v);

            cal(y,fat,v);

        }

    printf("%lld\n",sum + tem);

    return ;

}