11.04T3 次小生成树

3232 -- 【BJOI2010】次小生成树

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≤2000 M≤3000；
　　80%的数据 N≤50000 M≤100000；
　　100%的数据 N≤100000 M≤300000，边权值非负且不超过 10^9。

Source

xinyue

 

 

 

 

分析：最小生成树，倍增法

首先考虑不严格的次小生成树

我们先求出最小生成树,然后对每条不在最小生成树的边(x,y)，求出x->y路径上的最大的边，把它替换这条边之后的树就可能是次小生成树

用倍增思想记录max[x][i]表示x的第2^i的祖先到ｘ的边上的最大值就可以做到Ｏ（nlogn）

严格次小稍微有些区别，如果路径最大边和边(x,y)权值相同，就不能替换，而要换严格次大的边,所以多记一个secmax[x][i]表示x的第2^i的祖先到ｘ的边上的严格最大值即可

code：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#define N 300005
using namespace std;
struct node {
    int u,v,w,tag;
} t[N],e[N];
int first[N],nxt[N],cnt;
void add(int u,int v,int w) {
    e[++cnt].u=u;
    e[cnt].v=v;
    e[cnt].w=w;
    nxt[cnt]=first[u];
    first[u]=cnt;
}
int fa[N];
int find(int x) {
    if(x!=fa[x])return fa[x]=find(fa[x]);
    return fa[x];
}
void merge(int x,int y) {
    int f1=find(x),f2=find(y);
    if(f1!=f2)fa[f1]=f2;
}
long long sum=0;
int n,m;
void kruskal() {
    int cnt_=0;
    for(int i=1; i<=m; i++) {
        int u=t[i].u,v=t[i].v;
        if(find(u)!=find(v)) {
            merge(u,v);
            add(u,v,t[i].w);
            add(v,u,t[i].w);
            t[i].tag=1;
            sum+=t[i].w;
            cnt_++;
            if(cnt_==n-1)return;
        }
    }
}
int f[N][30],dep[N],mx[N][30],smx[N][30];
void dfs(int x) {
    for(int i=first[x]; i; i=nxt[i]) {
        int v=e[i].v;
        if(v==f[x][0])continue;
        mx[v][0]=e[i].w;
        smx[v][0]=-1;
        dep[v]=dep[x]+1;
        f[v][0]=x;
        dfs(v);
    }
}
pair<int,int> lca(int x,int y) {
    int max0=-1;
    int smax0=-1;
    if(dep[x]<dep[y])swap(x,y);
    for(int i=19; i>=0; i--) {
        if(dep[f[x][i]]>=dep[y]) {
            if(max0<mx[x][i]) {
                smax0=max0;
                max0=mx[x][i];
            }
            smax0=max(smax0,smx[x][i]);
            max0=max(max0,mx[x][i]);
            x=f[x][i];
        }
        if(x==y)return make_pair(max0,smax0);
    }
    for(int i=19; i>=0; i--) {
        if(f[x][i]==f[y][i]) continue;
        if(mx[x][i]>max0) {
            smax0=max0;
            max0=mx[x][i];
        } else if(mx[x][i]<max0) {
            smax0=max(smax0,mx[x][i]);
        }
        if(mx[y][i]>max0) {
            smax0=max0;
            max0=mx[y][i];
        } else if(mx[y][i]<max0) {
            smax0=max(smax0,mx[y][i]);
        }
        smax0=max(smax0,max(smx[x][i],smx[y][i]));
        max0=max(max0,max(mx[x][i],mx[y][i]));
        x=f[x][i];
        y=f[y][i];
    }
    max0=max(mx[x][0],max(max0,mx[y][0]));
    if(mx[x][0]<max0) {
        smax0=max(smax0,mx[x][0]);
    }
    if(mx[y][0]<max0) {
        smax0=max(smax0,mx[y][0]);
    }
    return make_pair(max0,smax0);
}
bool cmp(const node&a,const node&b) {
    return a.w<b.w;
}
int main() {
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1; i<=n; i++)fa[i]=i;
    for(int i=1; i<=m; i++) {
        int u,v,w;
        cin>>t[i].u>>t[i].v>>t[i].w;
    }
    sort(t+1,t+m+1,cmp);
    kruskal();
    memset(smx,-1,sizeof f);
    memset(mx,-1,sizeof mx);
    f[1][0]=1;
    dfs(1);
    for(int i=1; i<=19; i++) {
        for(int j=1; j<=n; j++) {
            f[j][i]=f[f[j][i-1]][i-1];
            mx[j][i]=max(mx[j][i-1],mx[f[j][i-1]][i-1]);
            if(mx[j][i-1]!=mx[f[j][i-1]][i-1]) {
                smx[j][i]=max(smx[j][i],min(mx[j][i-1],mx[f[j][i-1]][i-1]));
                smx[j][i]=max(smx[j][i],max(smx[j][i-1],smx[f[j][i-1]][i-1]));
            } else {
                smx[j][i]=max(smx[j][i-1],smx[f[j][i-1]][i-1]);
            }
        }
    }
    int delta=999999;
    for(int i=1; i<=m; i++) {
        if(t[i].tag)continue;
        pair<int,int> now=lca(t[i].u,t[i].v);
        if(t[i].w==now.first) {
            delta=min(delta,t[i].w-now.second);
            continue;
        }
        delta=min(delta,t[i].w-now.first);
    }
    cout<<sum+delta;
    return 0;
}

over