[BZOJ1977][BeiJing2010组队]次小生成树 Tree（kruskal+链剖）

题目描述

传送门

题解

严格的次小生成树。做法是这样的：
先用kruskal求出最小生成树；
对于不在最小生成树里的每一条边，求两个端点所在树链权值的最大值和次大值；
用当前边的权值减去最大值（如果当前边的权值等于最大值的话就用次大值），每次更新最小增量；
用最小生成树的权值和加上最小增量即为答案。
最大值和次大值可以用线段树维护，链剖查询，当然也可以写倍增。

那么为什么是这样呢？
感受一下。。。
求出最小生成树之后我们实际上得到了一棵树（这不废话。。。），然后枚举每一条不在树里的边，如果加上这条边树里就出现了环（这不又废话。。。），那么我们为了不出现环就要在这个环里删去一条边，除去枚举的边，剩下的边其实就组成了枚举的边的两个顶点之间的一条树链。
为什么要维护最大值和次大值呢？因为这道题是严格的次小生成树，所以不能使删去的边和枚举的边权值相等。
至于为什么树链中的边都小于等于枚举的边呢？很显然如果大于的话你求的还是最小生成树吗？。。。

代码

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
#define LL long long

const int max_n=2e5+5;
const int max_m=3e5+5;
const int max_e=max_n*2;
const int max_tree=max_n*5;
const int INF=2e9;

int n,m,cnt,cnt1,N,u,t;
int f[max_n];
int tot,point[max_n],next[max_e],v[max_e],c[max_e];
int size[max_n],h[max_n],father[max_n],son[max_n],faedge[max_n],sonedge[max_n];
int top[max_n],num[max_e],val[max_n];
int maxn[max_tree],_maxn[max_tree];
int a[10];

struct hp{
    int maxn,_maxn;
};
struct hq{
    int u,t,w,pd;
};
hq edge[max_m];

LL Min,Minadd,add;

inline int cmp(hq a,hq b){
    return a.w<b.w;
}

inline int find(int x){
    if (f[x]==x) return x;
    f[x]=find(f[x]);
    return f[x];
}
inline void merge(int x,int y){
    int f1=find(x); int f2=find(y);
    f[f1]=f2;
}

inline void addedge(int x,int y,int z){
    ++tot; next[tot]=point[x]; point[x]=tot; v[tot]=y; c[tot]=z;
    ++tot; next[tot]=point[y]; point[y]=tot; v[tot]=x; c[tot]=z;
}
inline void dfs_1(int x,int fa,int dep){
    size[x]=1; h[x]=dep; father[x]=fa;
    int maxson=0;
    for (int i=point[x];i;i=next[i])
      if (v[i]!=fa){
        faedge[v[i]]=i;
        dfs_1(v[i],x,dep+1);
        size[x]+=size[v[i]];
        if (size[v[i]]>maxson){
            maxson=size[v[i]];
            son[x]=v[i];
            sonedge[x]=i;
        }
      }
}
inline void dfs_2(int x,int fa){
    if (son[fa]!=x) top[x]=x;
    else top[x]=top[fa];
    if (son[x]){
        num[sonedge[x]]=++N;
        val[N]=c[sonedge[x]];
        dfs_2(son[x],x);
    }
    for (int i=point[x];i;i=next[i])
      if (v[i]!=fa&&v[i]!=son[x]){
        num[i]=++N;
        val[N]=c[i];
        dfs_2(v[i],x);
      }
}

inline void update(int now){
    maxn[now]=_maxn[now]=-1;
    a[1]=maxn[now<<1]; a[2]=maxn[now<<1|1];
    a[3]=_maxn[now<<1]; a[4]=_maxn[now<<1|1];
    if (a[1]==a[2]&&a[2]==a[3]&&a[3]==a[4])
        maxn[now]=_maxn[now]=a[4];
    else{
        sort(a+1,a+5);
        maxn[now]=a[4];
        for (int i=3;i>=1;--i)
          if (a[i]!=a[i+1]){
            _maxn[now]=a[i];
            break;
          }
    }
}
inline void build(int now,int l,int r){
    int mid=(l+r)>>1;
    if (l==r){
        maxn[now]=val[l];
        _maxn[now]=val[l];
        return;
    }
    build(now<<1,l,mid);
    build(now<<1|1,mid+1,r);
    update(now);
}
inline hp query(int now,int l,int r,int lrange,int rrange){
    int mid=(l+r)>>1;
    hp ans;
    hp ans1,ans2;
    if (lrange<=l&&r<=rrange)
      return ans=(hp){maxn[now],_maxn[now]};

    bool pd1=false,pd2=false;
    if (lrange<=mid)
      ans1=query(now<<1,l,mid,lrange,rrange),pd1=true;
    if (mid+1<=rrange)
      ans2=query(now<<1|1,mid+1,r,lrange,rrange),pd2=true;

    if (!pd1&&!pd2) return ans=(hp){0,0};
    if (!pd1) return ans=(hp){ans2.maxn,ans2._maxn};
    if (!pd2) return ans=(hp){ans1.maxn,ans1._maxn};

    int MAXN=-1,_MAXN=-1;
    a[1]=ans1.maxn,a[2]=ans1._maxn,a[3]=ans2.maxn,a[4]=ans2._maxn;
    if (a[1]==a[2]&&a[2]==a[3]&&a[3]==a[4])
        MAXN=_MAXN=a[4];
    else{
        sort(a+1,a+5);
        MAXN=a[4];
        for (int i=3;i>=1;--i)
          if (a[i]!=a[i+1]){
            _MAXN=a[i];
            break;
          }
    }

    return ans=(hp){MAXN,_MAXN};
}

inline hp ask(int u,int t){
    int f1=top[u],f2=top[t];
    int MAXN=-1,_MAXN=-1;
    hp ans;
    while (f1!=f2){
        if (h[f1]<h[f2]){
            swap(f1,f2);
            swap(u,t);
        }

        hp k=query(1,1,N,num[faedge[f1]],num[faedge[u]]);
        if (MAXN==-1&&_MAXN==-1){
            MAXN=k.maxn; _MAXN=k._maxn;
        }
        else{
            a[1]=k.maxn,a[2]=k._maxn,a[3]=MAXN,a[4]=_MAXN;
            if (a[1]==a[2]&&a[2]==a[3]&&a[3]==a[4]){
                MAXN=_MAXN=a[4];
            } 
            else{
                sort(a+1,a+5);
                MAXN=a[4];
                for (int i=3;i>=1;--i)
                  if (a[i]!=a[i+1]){
                    _MAXN=a[i];
                    break;
                  }

            }
        }
        u=father[f1];
        f1=top[u];      
    }
    if (u==t) return ans=(hp){MAXN,_MAXN};
    if (h[u]>h[t]) swap(u,t);

    hp k=query(1,1,N,num[sonedge[u]],num[faedge[t]]);
    if (MAXN==-1&&_MAXN==-1){
        MAXN=k.maxn; _MAXN=k._maxn;
    }
    else{
        a[1]=k.maxn,a[2]=k._maxn,a[3]=MAXN,a[4]=_MAXN;
        if (a[1]==a[2]&&a[2]==a[3]&&a[3]==a[4]){
            MAXN=_MAXN=a[4];
        } 
        else{
            sort(a+1,a+5);
            MAXN=a[4];
            for (int i=3;i>=1;--i)
              if (a[i]!=a[i+1]){
                _MAXN=a[i];
                break;
              }
        }
    }   

    return ans=(hp){MAXN,_MAXN};
}

int main(){
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;++i)
      scanf("%d%d%d",&edge[i].u,&edge[i].t,&edge[i].w);
    sort(edge+1,edge+m+1,cmp);
    for (int i=1;i<=n;++i)
      f[i]=i;
    for (int i=1;i<=m;++i){
        if (find(edge[i].u)!=find(edge[i].t)){
            merge(edge[i].u,edge[i].t);
            Min+=edge[i].w;
            edge[i].pd=true;
            ++cnt;
            if (cnt==n-1) break;
        }
    }

    for (int i=1;i<=m;++i)
      if (edge[i].pd)
        addedge(edge[i].u,edge[i].t,edge[i].w);
    dfs_1(1,0,1);
    dfs_2(1,0);
    build(1,1,N);

    cnt1=0;
    Minadd=INF;
    for (int i=m;i>=1;--i)
      if (!edge[i].pd){
        u=edge[i].u; t=edge[i].t;
        hp ans=ask(u,t);
        add=ans.maxn;
        if (add==edge[i].w) add=ans._maxn;
        if (add!=edge[i].w) Minadd=min(Minadd,edge[i].w-add);
        ++cnt1;
        if (cnt1==m-cnt) break;
      }
    Min+=Minadd;
    printf("%lld\n",Min);
}

总结

错误记录：
1、谁告诉你n个点都有边连着啦？它自己呆着不行啊？这种情况下最小生成树的边也不一定是n-1（写数据生成器的时候发现的）
2、如果最大值和次大值都和当前边的边权相等，那就别理它啦。（只有一条边或者所有的边权都相等，而且题目中很良心的保证有解）