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

由于要求严格次小生成树，原有的prim求次小生成树就不能用了。

由于严格次小生成树肯定是将最小生成树中的一条边去掉，再加上一条比较大的边。

我们可以先生成最小生成树再在不是最小生成树的边的两端对图进行更新。

而如果加入这一条边的话，就应该在这个变的两端点在最小生成树的路径上删去一条最大边。

由于有可能有重边，所以还要记录第二大的边。

d1数组记录最小生成树中的最大边的权值。

d2数组记录一条路径中第二大的边的权值。

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
#include <map>
using namespace std;
#define sint long long
#define maxn 510000
#define deg 20
int fa[maxn][deg],fa2[maxn],delt=0x3f3f3f3f,n,num,m,q,ceng[maxn];
int vis[maxn],first[maxn],next[maxn],to[maxn],val[maxn];
sint ans;
int d1[maxn][deg],d2[maxn][deg];
struct edge
{
    int u,v,val;
}g[maxn];
void build(int a,int b,int c)
{
    num++;
    to[num]=b;
    next[num]=first[a];
    first[a]=num;
    val[num]=c;
}
void dfs(int root)
{
    val[root]=1;
    for(int i = 1;i < deg;i++)
    {
        if(ceng[root]<(1<<i))break;
        fa[root][i] = fa[fa[root][i-1]][i-1];
        d1[root][i] = max(d1[root][i-1],d1[fa[root][i-1]][i-1]);
        if(d1[root][i-1]==d1[fa[root][i-1]][i-1])
            d2[root][i]=max(d2[root][i-1],d2[fa[root][i-1]][i-1]);
        else
        {
            d2[root][i]=min(d1[root][i-1],d1[fa[root][i-1]][i-1]);
            d2[root][i]=max(d2[root][i-1],d2[root][i]);
            d2[root][i]=max(d2[root][i],d2[fa[root][i-1]][i-1]);
        }
    }
    for(int i = first[root];i;i =next[i])
    { 
        int v = to[i];
        if(ceng[v])continue;
        ceng[v] = ceng[root] + 1;
        fa[v][0] = root;
        d1[v][0] = val[i];
        dfs(v);
    }
}
int LCA(int u,int v)
{
    if(ceng[u]<ceng[v])
        swap(u,v);
    int du,dv,ans;
    du=ceng[u];
    dv=ceng[v];
    int tu=u,tv=v;
    for(int i=19;i>=0;i--)
    {
        if(ceng[fa[tu][i]]>=ceng[tv])
        {
            tu=fa[tu][i];
        }
    }
    if(tu==tv)
    {
        return tu;
    }
    for(int i=deg-1;i>=0;i--)
    {
        if(fa[tu][i]==fa[tv][i])
            continue;
        tv=fa[tv][i];
        tu=fa[tu][i];
    }
    return fa[tu][0];
}
bool cmp(edge aa,edge bb)
{
    return aa.val<bb.val;
}
int getfa2(int x)
{
    return x==fa2[x] ? x:fa2[x]=getfa2(fa2[x]);
}
void update(int x,int f,int len)
{
    int m1=0,m2=0;
    int deltc=ceng[x]-ceng[f];
    for(int i=0;i<deg;i++)
    {
        if(deltc&(1<<i))
        {
            if(d1[x][i]>m1)
            {
                m2=m1;
                m1=d1[x][i];
            }
            m2=max(m2,d2[x][i]);
            x=fa[x][i];
        }
    }
    if(m1!=len) delt=min(delt,len-m1);
    else delt=min(delt,len-m2);
}
void solve(int now)
{
    int f=LCA(g[now].u,g[now].v);
    update(g[now].u,f,g[now].val);
    update(g[now].v,f,g[now].val);
}
int main()
{
    num=0;
    int a,b,c;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        fa2[i]=i;
    memset(ceng,0,sizeof(ceng));
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&g[i].u,&g[i].v,&g[i].val);
    }
    sort(g+1,g+1+m,cmp);
    int nump=0,r1,r2;
    for(int i=1;i<=m;i++)
    {
        r1=getfa2(g[i].u);
        r2=getfa2(g[i].v);
        if(r1!=r2)
        {
            vis[i]=1;
            ans+=g[i].val;
            fa2[r2]=r1;
            nump++;
            build(g[i].u,g[i].v,g[i].val);
            build(g[i].v,g[i].u,g[i].val);
            if(nump==n-1)
            {
                break;
            }
        }
    }
    ceng[1] = 1;
    fa[1][0] = 1;
    dfs(1);
    for(int i=1;i<=m;i++)
    {
        if(vis[i]) continue;
        solve(i);
    }
    printf("%lld\n",ans+delt);
    return 0;
}
/*
4 3
1 2
2 3
3 4
1 4
2 3
1 3
*/