bzoj1977 [BeiJing2010组队]次小生成树 Tree

Posted 2020-11-19 llppdd

[BeiJing2010组队]次小生成树 Tree

Time Limit: 10 Sec Memory Limit: 512 MB

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 。

实际上你要先求出最小生成树，然后再在这个基础上改一点点就变成了次小生成树。
具体来说就是找一条以前没有用的边，然后把这两点原来路径上的一条最大的边给砍了。。。
然后题目很变态的要求严格小于。。。你还要记第二小的边。。。。
最开始偷懒用set。。。被卡常了。。。
然后最后4分钟卡常大师重出江湖。。。。一手sort直接*过。。。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct lpl{
    int from, to, dis;
    bool flag;
}lin;
struct ld{
    int to, dis;
}qwe;
struct lpd{
    int fa, dis, deep, tree[18][3];
}node[maxn];
int n, m, root, pw[25], fa[maxn];
int tot, aaa[maxn];
long long sum = 0, ans = 1e14 + 5;
set<int> s;
set<int>::iterator iter;
vector<lpl> edge;
vector<ld> point[maxn];

inline int read()
{  
   int s = 0, w = 1;  char ch = getchar();  
   while(ch <= '0' || ch > '9'){if(ch == '-') w = -1; ch = getchar();}  
   while(ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();  
   return s * w;  
}  

inline bool cmp(lpl A, lpl B){return A.dis < B.dis;}

int find(int t){return t == fa[t] ? t : fa[t] = find(fa[t]);}

inline void putit()
{
    n = read(); m = read(); root = 1; pw[0] = 1;
    for(int a, b, i = 1; i <= m; ++i){
        scanf("%d%d%d", &lin.from, &lin.to, &lin.dis); edge.push_back(lin);
    }
    for(int i = 1; i <= 17; ++i) pw[i] = pw[i - 1] * 2;
}

inline void kruskal()
{
    for(int i = 1; i <= n; ++i) fa[i] = i;
    sort(edge.begin(), edge.end(), cmp); int N = edge.size() - 1;
    for(int A, B, i = 0; i <= N; ++i){
        A = find(edge[i].from); B = find(edge[i].to);
        if(A == B) continue;
        fa[A] = B; qwe.to = edge[i].to; qwe.dis = edge[i].dis; 
        sum += (long long)qwe.dis; edge[i].flag = true;
        point[edge[i].from].push_back(qwe); qwe.to = edge[i].from;
        point[edge[i].to].push_back(qwe);
    }
}

void build(int t)
{
    for(int i = point[t].size() - 1; i >= 0; --i){
        int now = point[t][i].to;
        if(now == node[t].fa) continue;
        node[now].fa = t; node[now].dis = point[t][i].dis; node[now].deep = node[t].deep + 1;
        build(now);
    }
}

void prepare(int t)
{
    node[t].tree[0][0] = node[t].fa; node[t].tree[0][1] = node[t].dis;
    for(int i = 1; i <= 17; ++i){
        if(pw[i] > node[t].deep) break;
        node[t].tree[i][0] = node[node[t].tree[i - 1][0]].tree[i - 1][0];
//      s.insert(node[node[t].tree[i - 1][0]].tree[i - 1][1]);
//      s.insert(node[node[t].tree[i - 1][0]].tree[i - 1][2]);
//      s.insert(node[t].tree[i - 1][1]);
//      s.insert(node[t].tree[i - 1][2]);
//      for(iter = s.begin(); iter != s.end(); ++iter){
//          node[t].tree[i][2] = node[t].tree[i][1]; node[t].tree[i][1] = *iter;
//      }
//      s.clear();
        tot = 0;
        aaa[++tot] = node[node[t].tree[i - 1][0]].tree[i - 1][1];
        aaa[++tot] = node[node[t].tree[i - 1][0]].tree[i - 1][2];
        aaa[++tot] = node[t].tree[i - 1][1];
        aaa[++tot] = node[t].tree[i - 1][2];
        sort(aaa + 1, aaa + tot + 1); node[t].tree[i][1] = aaa[tot];
        for(int k = tot - 1; k >= 1; --k){
            if(aaa[k] != node[t].tree[i][1]){
                node[t].tree[i][2] = aaa[k]; break;
            }
        }
    }
    for(int now, i = point[t].size() - 1; i >= 0; --i){
        now = point[t][i].to;
        if(now == node[t].fa) continue;
        prepare(now);
    }
}

inline void workk()
{
    for(int A, B, lca, mx, i = edge.size() - 1; i >= 0; --i){
        lin = edge[i]; A = lin.from; B = lin.to; mx = 0; tot = 0;
        if(edge[i].flag) continue;
        if(node[A].deep < node[B].deep) swap(A, B);
        for(int k = 17; k >= 0; --k){
            if(node[A].deep == node[B].deep) break;
            if(node[node[A].tree[k][0]].deep >= node[B].deep && node[A].tree[k][0]){
                //s.insert(node[A].tree[k][1]); s.insert(node[A].tree[k][2]);
                aaa[++tot] = node[A].tree[k][1]; aaa[++tot] = node[A].tree[k][2];
                A = node[A].tree[k][0]; 
            }
        }
        if(A != B){
            for(int k = 17; k >= 0; --k){
                if(node[A].tree[k][0] != node[B].tree[k][0]){
//                  s.insert(node[A].tree[k][1]); s.insert(node[A].tree[k][2]);
//                  s.insert(node[B].tree[k][1]); s.insert(node[B].tree[k][2]);
                    aaa[++tot] = node[A].tree[k][1]; aaa[++tot] = node[A].tree[k][2];   
                    aaa[++tot] = node[B].tree[k][1]; aaa[++tot] = node[B].tree[k][2];
                    A = node[A].tree[k][0]; B = node[B].tree[k][0];
                }
            }   
            aaa[++tot] = node[A].dis; aaa[++tot] = node[B].dis;
            //s.insert(node[A].dis); s.insert(node[B].dis); 
            lca = node[A].fa;       
        }
        if(A == B) lca = A;
//      for(iter = s.begin(); iter != s.end(); ++iter){
//          if(*iter != lin.dis) mx = max(mx, *iter);
//      }
//      s.clear();
        sort(aaa + 1, aaa + 1 + tot);
        for(int i = tot; i >= 1; --i){
            if(aaa[i] != lin.dis){
                mx = aaa[i]; break;
            }
        }
        ans = min(ans, sum + lin.dis - mx);
    }
}

int main()
{
    putit();
    kruskal();
    build(root);
    prepare(root);
    workk();
    cout << ans;
    return 0;
}