[BZOJ]1977 次小生成树 树上倍增

1977: [BeiJing2010组队]次小生成树 Tree

Time Limit: 10 Sec   Memory Limit: 512 MB
Submit: 3293   Solved: 853
[ Submit][ Status][ Discuss]

Description

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

Input

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

Output

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

Sample Input

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

Sample Output

11

HINT

数据中无向图无自环； 50% 的数据N≤2 000 M≤3 000； 80% 的数据N≤50 000 M≤100 000； 100% 的数据N≤100 000 M≤300 000 ，边权值非负且不超过 10^9 。

Source

[ Submit][ Status][ Discuss] 

HOME Back

     st表用惯了就不想去用log的倍增了...后面才发现树上倍增对于链上很多基础问题还是有很多用处的(总不能动不动就写个树链剖分啥的吧)， 于是就找来这道练练手...wa了一页证明我确实不太熟练...

次小生成树的话， 说明就是Kruskal之后求得最小生成树， 加入一条非树边形成环， 来割掉非树边两端点在树上的链的某条边来形成的树...因为是严格次小， 所以你要割掉的肯定是端点形成的树链上最大的那条边， 但是如果那条最大的边等于你这个非树边的权值， 那么你割了等于没割对吧， 这个时候就要去割次大值... 所以我们还要保存次大值作为备用. 枚举每条非树边保存 非树边权值 - 所割边权值的value， 然后取min(因为严格次小， 一定要只比最小生成树的权值和小). 最后输出 最小生成树和 + 保存的最小差值即可.

代码里面注释感叹号的都是容易写错的地方， 注意...

10.18 更新: 同机房的kgv007 daolao发现hzwer的代码有错， 及时指了出来. 所以我等类似hzwer的代码都被hack掉了， 但是BZOJ还没有更新数据. 实际上样例就能把hzwer卡掉， 只需要把加边顺序一换即可， 就会出现12的错误. 错就错在代码50 ~55行的代码，hzwer大神没有将m2最大化 (没有与mx1[x][i]取max). hack数据在代码尾部.

#include<stdio.h>  
#include<algorithm>  
#define Mercer register int  
using namespace std;  
const int P = 16;  
const int maxn = 100005;  
bool vis[maxn * 2];  
long long ans; //ans可能是longlong   
int tot, num, n, m, delta;  
int h[maxn], dep[maxn], fa[maxn], anc[maxn][P + 1], mx1[maxn][P + 1], mx2[maxn][P + 1];  
inline const int read(){  
    Mercer x = 0;  
    char ch = getchar();  
    while(ch < '0' || ch > '9') ch = getchar();  
    while(ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + ch - '0', ch = getchar();  
    return x;  
}  
struct test{int x, y, z;}c[maxn * 3]; //!注意范围 ， 边有300000   
struct edge{int v, nxt, w;}e[maxn * 2]; //!树边200000   
int find(int x) { return (fa[x] == x) ? x : fa[x] = find(fa[x]);}  
inline bool cmp(test a, test b) { return a.z < b.z;}  
inline void add(int u, int v, int w){  
    e[++num].v = v, e[num].w = w, e[num].nxt = h[u], h[u] = num;  
    e[++num].v = u, e[num].w = w, e[num].nxt = h[v], h[v] = num;  
}  
inline void Kruskal(){
    sort(c + 1, c + m + 1, cmp);
    for(Mercer i = 1; i <= m; ++i){
        int p = find(c[i].x), q = find(c[i].y);
        if(p != q){
            ans += c[i].z, ++tot, vis[i] = true;
            fa[p] = q, add(c[i].x, c[i].y, c[i].z);
            if(tot == n - 1) break;
        }
    }
}
inline int query(int x, int y){  
    if(dep[x] < dep[y]) swap(x, y);  
    int t = dep[x] - dep[y];  
    for(int i = 0; i <= P; ++i)  
        if((1 << i) & t) x = anc[x][i];  
    for(int i = P; i >= 0; --i)  
        if(anc[x][i] != anc[y][i]) x = anc[x][i], y = anc[y][i];  
    return (x == y) ? x : anc[x][0];  
}  
inline void update(int x, int lca, int w){  
    int m1 = 0, m2 = 0, t = dep[x] - dep[lca]; //!注意谁深， 不要做出lca - x的蠢事...   
    for(int i = 0; i <= P; ++i)  
        if((1 << i) & t){
            if(mx1[x][i] > m1){  
                m2 = max(m1, mx2[x][i]);
                m1 = mx1[x][i];
        	}
            else m2 = max(m2, mx1[x][i]);
            x = anc[x][i];  
        }
    if(m1 != w) delta = min(delta, w - m1);  
    else delta = min(delta, w - m2);   
}  
inline void update(int i, int w){  
    int x = c[i].x, y = c[i].y, lca = query(x, y);  
    update(x, lca, w), update(y, lca, w);  
}  
void dfs(int u, int fa){  
    for(int i = 1; i <= P; ++i){  
        if(dep[u] < (1 << i)) break;  
        anc[u][i] = anc[anc[u][i - 1]][i - 1];  
        mx1[u][i] = max(mx1[u][i - 1], mx1[anc[u][i - 1]][i - 1]);  
        if(mx1[u][i - 1] == mx1[anc[u][i - 1]][i - 1]) //!是权值第二大， 所以相等要特判   
            mx2[u][i] = max(mx2[u][i - 1], mx2[anc[u][i - 1]][i - 1]);  
        else{  
            mx2[u][i] = min(mx1[u][i - 1], mx1[anc[u][i - 1]][i - 1]);  
            mx2[u][i] = max(mx2[u][i], max(mx2[u][i - 1], mx2[anc[u][i - 1]][i - 1]));  
        }  
    }  
    for(int i = h[u]; i; i = e[i].nxt){  
        int v = e[i].v;  
        if(v == fa) continue;  
        dep[v] = dep[u] + 1;  
        mx1[v][0] = e[i].w;  
        anc[v][0] = u;   
        dfs(v, u);  
    }  
}  
int main(){  
    n = read(), m = read(), delta = 0x7fffffff;  
    for(Mercer i = 1; i <= n; ++i) fa[i] = i;  
    for(Mercer i = 1; i <= m; ++i) c[i].x = read(), c[i].y = read(), c[i].z = read();  
    Kruskal();  
    dfs(1, 0);  
    for(Mercer i = 1; i <= m; ++i)  
        if(!vis[i]) update(i, c[i].z);  
    printf("%lld\n", ans + delta);  
}
/*
5 6
1 2 2
1 5 4
2 3 1
3 4 3
1 4 3
5 4 6
*/