次小生成树（最小生成树+树上倍增求LCA）

次小生成树

Description

小 C 最近学了很多最小生成树的算法，Prim 算法、Kurskal 算法、消圈算法等等。

正当小 C 洋洋得意之时，小 P 又来泼小 C 冷水了。小 P 说，让小 C 求出一个无向

图的次小生成树，而且这个次小生成树还得是严格次小的，也就是说： 如果最小生

成树选择的边集是 EM，严格次小生成树选择的边集是 ES，那么需要满足：

(value(e) 表示边 e的权值)。

这下小 C 蒙了，他找到了你，希望你帮他解决这个问题。

Format

Input

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

点 x 和点y之间有一条边，边的权值为z。

Output

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

Sample 1

Input

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

Copy

Output

11

Copy

Limitation

数据中无向图无自环； 
50% 的数据N≤2 000 M≤3 000； 
80% 的数据N≤50 000 M≤100 000；；

100% 的数据N≤100 000 M≤300 000 ，边权值非负且不超过 10^9 。

Source

bzoj1977

思路：

     先求出最小生成树，并建树图，之后遍历所有非树边，用树上倍增

求LCA的方法求出非树边两节点之间树边中的最大边和次大边，再将非

树边权值与最大值比较，如果最大边<非树边（或者不等于，不等于一

定<，要不然最小生成树就不是最小了）权值，用非树边替换最大边，否

则（等于关系）用非树边替换次大边，最后从所有候选答案中选择最小值

即次小生成树权值。

 

AC代码：

#include <cstdio>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include<algorithm>
#include <set>
#include <queue>
#include <stack>
#include<vector>
#include<map>
#include<ctime>
#define LL long long
using namespace std;
const int SIZE=200010;
int f[SIZE][20],d[SIZE],dist[SIZE];
int ver[2*SIZE],Next[2*SIZE],edge[2*SIZE],head[SIZE];
int T,tot,t;
queue <int> q;

int maxs[SIZE][20];
int mini[SIZE][20];
struct rec
{
    int l;
    int r;
    int value;
    bool istree;
    bool operator <(const rec & obj)const
    {
        return value<obj.value;
    }
} e[SIZE*2];

void add(int x,int y,int z)
{
    ver[++tot]=y;
    edge[tot]=z;
    Next[tot]=head[x];
    head[x]=tot;
}
void bfs()//预处理，求深度、最短路，f数组；就是SPFA，时间复杂度O（NlogN）
{
    memset(maxs,-0x3f,sizeof(maxs));
    memset(mini,-0x3f,sizeof(mini));
    memset(d,0,sizeof(d));
    q.push(1);
    d[1]=1;
    while(q.size())
    {
        int x=q.front();
        q.pop();
        for(int i=head[x]; i; i=Next[i])
        {
            int y=ver[i];
            if(d[y])continue;
            d[y]=d[x]+1;   //求节点的深度；
            dist[y]=dist[x]+edge[i];//距离根节点的距离；
            f[y][0]=x;
            maxs[y][0]=edge[i];
            for(int j=1; j<=t; ++j)
            {
                f[y][j]=f[f[y][j-1]][j-1];//动态规划，y点 跳（2^j）步 能到达哪个点。
                maxs[y][j]=max(maxs[y][j-1],maxs[f[y][j-1]][j-1]);
                if(maxs[y][j-1]==maxs[f[y][j-1]][j-1])
mini[y][j]=max(mini[y][j-1],mini[f[y][j-1]][j-1]);
                if(maxs[y][j-1]<maxs[f[y][j-1]][j-1])
mini[y][j]=max(maxs[y][j-1],mini[f[y][j-1]][j-1]);
                if(maxs[y][j-1]>maxs[f[y][j-1]][j-1])
mini[y][j]=max(mini[y][j-1],maxs[f[y][j-1]][j-1]);
                q.push((y));
            }
        }
    }
}
int LCA(int x,int y)//求LCA，时间复杂度：o（Log（N））
{
    if(d[x]>d[y])swap(x,y);
    for(int i=t; i>=0; --i) //倒着走******
        if(d[f[y][i]]>=d[x])y=f[y][i];
    if(x==y)return x;
    for(int i=t; i>=0; --i)
        if(f[x][i]!=f[y][i])x=f[x][i],y=f[y][i];//注意一下：x是不断变化的，而i整个一套下来；
    return f[x][0];//一直更新，直至x、y为目标点下面的那两个点；
}

int fat[SIZE];
int find(int x)
{
    if(x==fat[x])return x;
    return fat[x]=find(fat[x]);
}
LL cTree(LL sum,int m)
{
    LL ans=999999999999999;
    for(int i=1; i<=m; ++i)
    {
        if(e[i].istree==1)continue;
        int x=e[i].l,y=e[i].r;
        int lca=LCA(x,y);
        int tmp1=-1,tmp2=-1;

        for(int j=t; j>=0; --j)
        {
            if(d[x]-d[lca]-(1<<j)>=0)
            {
                tmp1=max(tmp1,maxs[x][j]);
                tmp2=max(tmp2,mini[x][j]);
                break;
            }
        }
        for(int j=t; j>=0; --j)
        {
            if(d[y]-d[lca]-(1<<j)>=0)
            {
                if(maxs[y][j]==tmp1)tmp2=max(tmp2,mini[y][j]);
                else if(maxs[y][j]>tmp1)
                {
                    tmp2=max(tmp1,mini[y][j]);
                    tmp1=maxs[y][j];
                }
                else
                    tmp2=max(tmp2,maxs[y][j]);
                break;
            }
        }

        if(e[i].value>tmp1)ans=min(ans,sum-tmp1+e[i].value);
        else ans=min(ans,sum-tmp2+e[i].value);


    }
    return ans;
}
int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        t=(int)log(n)/log(2)+2;
        memset(Next,0,sizeof(Next));
        memset(e,0,sizeof(e));
        memset(head,0,sizeof(head));
        memset(dist,0,sizeof(dist));
        tot=0;
        for(int i=1; i<=m; ++i)
            cin>>e[i].l>>e[i].r>>e[i].value;

        sort(e+1,e+1+m);
        for(int i=1; i<=n; ++i)fat[i]=i;
        LL sum=0;
        for(int i=1; i<=m; ++i)
        {
            int x=e[i].l,y=e[i].r;
            x=find(x),y=find(y);
            if(x==y)continue;
            fat[x]=y;
            add(e[i].l,e[i].r,e[i].value);
            add(e[i].r,e[i].l,e[i].value);
            e[i].istree=1;
            sum+=e[i].value;
        }

        bfs();
        LL ans=cTree(sum,m);
        cout<<ans<<endl;

    }
    return 0;
}

 

The end；