版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_41661919/article/details/86565228
次小生成树
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
Output
11
Limitation
1s, 512MiB for each test case.
数据中无向图无自环;
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;