题目链接 https://www.luogu.org/problemnew/show/P4180
【题意】
小C最近学了很多最小生成树的算法,Prim算法、Kurskal算法、消圈算法等等。正当小C洋洋得意之时,小P又来泼小C冷水了。小P说,让小C求出一个无向图的次小生成树,而且这个次小生成树还得是严格次小的,也就是说:如果最小生成树选择的边集是
E
M
E_M
EM,严格次小生成树选择的边集是
E
S
E_S
ES,那么需要满足:(
v
a
l
u
e
(
e
)
value(e)
value(e)表示边
e
e
e的权值)
∑
e
∈
E
M
v
a
l
u
e
(
e
)
<
∑
e
∈
E
S
v
a
l
u
e
(
e
)
\sum_{e \in E_M}value(e) < \sum_{e \in E_S} value(e)
e∈EM∑value(e)<e∈ES∑value(e) 这下小 C 蒙了,他找到了你,希望你帮他解决这个问题。
【输入格式】
第一行包含两个整数
N
N
N 和
M
M
M,表示无向图的点数与边数。 接下来
M
M
M行,每行 3个数
x
,
y
,
z
x ,y, z
x,y,z 表示,点
x
x
x 和点
y
y
y之间有一条边,边的权值为
z
z
z。数据中无向图无自环; 50% 的数据
N
≤
2000
,
M
≤
3000
N≤2 000 ,M≤3 000
N≤2000,M≤3000; 80% 的数据
N
≤
50000
,
M
≤
100000
N≤50 000 ,M≤100 000
N≤50000,M≤100000; 100% 的数据
N
≤
100000
,
M
≤
300000
N≤100 000 ,M≤300 000
N≤100000,M≤300000 ,边权值非负且不超过
1
0
9
10^9
109 。
【输出格式】
包含一行,仅一个数,表示严格次小生成树的边权和。(数据保证必定存在严格次小生成树)
【输入样例】
5 6
1 2 1
1 3 2
2 4 3
3 5 4
3 4 3
4 5 6
【输出样例】
11
【思路】
一般求次小生成树的方法是枚举所有不在最小生成树中的边,用它们将最小生成树上的一条边换掉(换掉原来的最小瓶颈路)以后形成一个新的生成树,然后取最小值. 但是这道题要求严格次小,还按照刚才的办法,如果枚举某条不在最小生成树种的边时,这条边的权值和最小生成树上对应最小瓶颈路相等,那么这就不是一组解了. 假设这条边的端点为
u
,
v
u,v
u,v,这时我们就不能换掉最小生成树上
u
,
v
u,v
u,v的最小瓶颈路了,而是要换掉从
u
u
u 到
v
v
v 的路径上次大的那一条边,才能保证换完之后新的生成树严格大于最小生成树. 具体实现还要借助于LCA的倍增思想,假设
d
e
p
t
h
[
u
]
depth[u]
depth[u] 表示节点
u
u
u 的深度
p
a
r
e
n
t
[
u
]
[
k
]
parent[u][k]
parent[u][k] 表示节点
u
u
u 向上走
2
k
2^k
2k步到达的节点,不存在则为-1
z
u
i
d
a
[
u
]
[
k
]
zuida[u][k]
zuida[u][k] 表示节点
u
u
u 向上走
2
k
2^k
2k 步途径的最大边权值,不存在则为-1
c
i
d
a
[
u
]
[
k
]
cida[u][k]
cida[u][k] 表示节点
u
u
u 向上走
2
k
2^k
2k 步途径的次大边权值,不存在则为-1
下面两个状态转移不难想到
p
a
r
e
n
t
[
u
]
[
k
]
=
p
a
r
e
n
t
[
p
a
r
e
n
t
[
u
]
[
k
−
1
]
]
[
k
−
1
]
parent[u][k]=parent[parent[u][k-1]][k-1]
parent[u][k]=parent[parent[u][k−1]][k−1]
z
u
i
d
a
[
u
]
[
k
]
=
m
a
x
{
z
u
i
d
a
[
u
]
[
k
−
1
]
,
z
u
i
d
a
[
p
a
r
e
n
t
[
u
]
[
k
−
1
]
]
[
k
−
1
]
}
zuida[u][k]=max\{ zuida[u][k-1],zuida[parent[u][k-1]][k-1] \}
zuida[u][k]=max{zuida[u][k−1],zuida[parent[u][k−1]][k−1]}
次大边权值的状态转移不太好想
c
i
d
a
[
u
]
[
k
]
=
m
a
x
{
m
i
n
{
z
u
i
d
a
[
u
]
[
k
−
1
]
,
z
u
i
d
a
[
p
a
r
e
n
t
[
u
]
[
k
−
1
]
]
[
k
−
1
]
}
(zuida[u][k-1]!=zuida[parent[parent[u][k-1]][k-1])
c
i
d
a
[
u
]
[
k
−
1
]
c
i
d
a
[
p
a
r
e
n
t
[
u
]
[
k
−
1
]
[
k
−
1
]
cida[u][k]=max \begin{cases} min\{zuida[u][k-1],zuida[parent[u][k-1]][k-1]\} & \text {(zuida[u][k-1]!=zuida[parent[parent[u][k-1]][k-1])} \\ cida[u][k-1] \\ cida[parent[u][k-1][k-1] \end{cases}
cida[u][k]=max⎩⎪⎨⎪⎧min{zuida[u][k−1],zuida[parent[u][k−1]][k−1]}cida[u][k−1]cida[parent[u][k−1][k−1](zuida[u][k-1]!=zuida[parent[parent[u][k-1]][k-1])
递推边界就是
k
=
1
k=1
k=1,用一次dfs就可以求出边界时的解,在查询某两个点
u
,
v
u,v
u,v的时候采用倍增思想,先让更深的
u
u
u向上走到和
v
v
v同样的高度,然后
u
,
v
u,v
u,v同时向上走到
L
C
A
(
u
,
v
)
LCA(u,v)
LCA(u,v),用两个变量记录这一过程中经过的最大边权和次大边权
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf=1e15;
const int maxn=100005;
const int maxm=300005;
struct Edge{
int from,to;
ll dist;
Edge(int f,int t,ll d):from(f),to(t),dist(d){}
bool operator<(const Edge& e)const{
return dist<e.dist;
}
};
int n,m;
int par[maxn];
bool ok[maxm];
vector<Edge> edges0,edges;
vector<int> g[maxn];
int depth[maxn];
int parent[maxn][20];
ll zuida[maxn][20],cida[maxn][20];
int findrt(int x){return par[x]==x?x:par[x]=findrt(par[x]);}
void add(int from,int to,ll dist){
edges.push_back(Edge(from,to,dist));
int x=edges.size();
g[from].push_back(x-1);
}
ll kruscal(){
memset(ok,0,sizeof(ok));
sort(edges0.begin(),edges0.end());
for(int i=0;i<n;++i){
par[i]=i;
g[i].clear();
}
int cnt=0;
ll ans=0;
for(int i=0;i<m;++i){
Edge& e=edges0[i];
int x=findrt(e.from);
int y=findrt(e.to);
if(x!=y){
ok[i]=true;
par[x]=y;
int u=e.from;
int v=e.to;
ll d=e.dist;
ans+=d;
add(u,v,d);
add(v,u,d);
if(++cnt==n-1) break;
}
}
return ans;
}
void dfs(int u,int fa,int dep,ll dist){
depth[u]=dep;
parent[u][0]=fa;
zuida[u][0]=dist;
cida[u][0]=-1;
for(int i=0;i<g[u].size();++i){
Edge& e=edges[g[u][i]];
int v=e.to;
if(v!=fa) dfs(v,u,dep+1,e.dist);
}
}
void init(){
int log=0;
while((1<<(log+1))<=n) ++log;
for(int j=1;j<=log;++j){
for(int i=0;i<n;++i){
int a=parent[i][j-1];
if(a==-1){
parent[i][j]=-1;
zuida[i][j]=-1;
cida[i][j]=-1;
}
else{
parent[i][j]=parent[a][j-1];
zuida[i][j]=max(zuida[i][j-1],zuida[a][j-1]);
cida[i][j]=-1;
if(zuida[i][j-1]!=zuida[a][j-1])
cida[i][j]=min(zuida[i][j-1],zuida[a][j-1]);
cida[i][j]=max(cida[i][j],cida[i][j-1]);
cida[i][j]=max(cida[i][j],cida[a][j-1]);
}
}
}
}
ll query(int u,int v,ll d){
if(depth[u]<depth[v]) swap(u,v);
int log=0;
while((1<<(log+1))<=depth[u]) ++log;
ll Max=-1,ciMax=-1;
for(int k=log;k>=0;--k){
if((depth[u]-depth[v])>>k&1){
if(Max!=zuida[u][k])
ciMax=max(ciMax,min(Max,zuida[u][k]));
ciMax=max(ciMax,cida[u][k]);
Max=max(Max,zuida[u][k]);
u=parent[u][k];
}
}
if(u==v){
if(Max!=d) return Max;
if(ciMax!=-1) return ciMax;
else return -inf;
}
for(int k=log;k>=0;--k){
if(parent[u][k]!=-1 && parent[u][k]!=parent[v][k]){
if(Max!=zuida[u][k])
ciMax=max(ciMax,min(Max,zuida[u][k]));
ciMax=max(ciMax,cida[u][k]);
if(Max!=zuida[v][k])
ciMax=max(ciMax,min(Max,zuida[v][k]));
ciMax=max(ciMax,cida[v][k]);
Max=max(Max,zuida[u][k]);
Max=max(Max,zuida[v][k]);
u=parent[u][k];
v=parent[v][k];
}
}
if(Max!=zuida[u][0])
ciMax=max(ciMax,min(Max,zuida[u][0]));
ciMax=max(ciMax,cida[u][0]);
if(Max!=zuida[v][0])
ciMax=max(ciMax,min(Max,zuida[v][0]));
ciMax=max(ciMax,cida[v][0]);
Max=max(Max,zuida[u][0]);
Max=max(Max,zuida[v][0]);
if(Max!=d) return Max;
if(ciMax!=-1) return ciMax;
else return -inf;
}
int main(){
while(scanf("%d%d",&n,&m)==2){
edges0.clear();
edges.clear();
for(int i=0;i<m;++i){
int u,v;
ll w;
scanf("%d%d%lld",&u,&v,&w);
edges0.push_back(Edge(u-1,v-1,w));
}
ll mst=kruscal();
dfs(0,-1,0,0);
init();
ll ans=inf;
for(int i=0;i<m;++i){
if(!ok[i]){
Edge& e=edges0[i];
ans=min(ans,mst-query(e.from,e.to,e.dist)+e.dist);
}
}
printf("%lld\n",ans);
}
return 0;
}