[CF 609E] Minimum spanning tree for each edge

最新推荐文章于 2022-07-19 12:17:47 发布

Aaplloo

最新推荐文章于 2022-07-19 12:17:47 发布

阅读量189

点赞数

分类专栏：最小生成树 LCA 并查集

本文链接：https://blog.csdn.net/ICEEBBING/article/details/108084729

版权

最小生成树同时被 3 个专栏收录

2 篇文章 0 订阅

订阅专栏

LCA

2 篇文章 0 订阅

订阅专栏

并查集

2 篇文章 0 订阅

订阅专栏

题目

洛谷

题意

题意很简单。有 $n$ 个点 $m$ 条边的无向图，对于每次固定选第 $i$ 条边，求最小生成树。

思路

首先，暴力每次先选第 $i$ 条边，然后做最小生成树。显然是 $O (n m)$ 的。

那么我们的正解是怎样的呢？猜测是固定选某一条边，然后 $O (1)$ 或者 $O (l o g)$ 地进行另一条边的转移。

考虑先不固定边得到最小生成树。

如果一条边本身就在最小生成树上，那么最小生成树不变。

对于其他边呢？若这次强制练的边两端点为 $a$ 和 $b$ ，那么似乎可以贪心地找 $a$ 或 $b$ 为端点的最大的一条边删去。

那么似乎可以做了，而且还是 $O (m)$ 的？总感觉哪里不对啊，看眼题解——哦，原来自己画图时画的是个三角环，以为是 $u$ 或 $v$ 为端点的边，其实应该是 $u$ 到 $v$ 路径上的最大的边。

那么，我们如何维护 $u$ 到 $v$ 路径上最大的边呢？维护 $\tt ST$ 表， $f [i] [j] : i$ 点往上 $2^j$ 步的最大的权值。那么似乎就很简单了——若 $u$ 和 $v$ 是祖先和儿子关系，那么直接往上爬。若不是祖先和儿子关系，就往 $\tt LCA$ 爬。

Code：

代码略长，码着还是挺舒服的。

struct Edge
{
	LL u, v, w, Index;
	Edge(){}
	Edge(LL U,LL V,LL W)
	{
		u = U;
		v = V;
		w = W;
	}
	friend bool operator <(Edge A,Edge B)
	{
		return A.w < B.w;
	}
}Eg[MAXN], Ks[MAXN];
struct node
{
	LL v, w;
	node(){}
	node(LL V,LL W)
	{
		v = V;
		w = W;
	}
};
vector<node> G[MAXN];
LL n, m, f[MAXN][MAXK], Dep[MAXN], St[MAXN][MAXK], Root;
void Build(LL x,LL Pre,LL Qb)
{
	Dep[x] = Dep[Pre] + 1;
	f[x][0] = Pre; St[x][0] = Qb;
	for (Int i = 1; i < MAXK; ++ i)
		f[x][i] = f[f[x][i - 1]][i - 1], St[x][i] = Max(St[x][i - 1], St[f[x][i - 1]][i - 1]);
	int l = G[x].size();
	for (Int i = 0; i < l; ++ i)
	{
		LL to = G[x][i].v;
		if (to == Pre)
			continue;
		Build(to, x, G[x][i].w);
	}
}
inline void Adjust(LL &u,LL Tar)
{
	for (Int i = 19; i >= 0; -- i)
		if (Dep[f[u][i]] >= Tar)
			u = f[u][i];
}
inline LL LCA(LL u,LL v)
{
	if (Dep[u] > Dep[v])
		Adjust(u, Dep[v]);
	else if (Dep[u] < Dep[v])
		Adjust(v, Dep[u]);
	if (u == v)
		return (u + v) / 2;
	for (Int i = 19; i >= 0; -- i)
		if (f[u][i] != f[v][i])
			u = f[u][i], v = f[v][i];
	return f[u][0];
}
bool Used[MAXN];
LL Fa[MAXN];
inline void MakeSet(LL x)
{
	for (Int i = 1; i <= x; ++ i)
		Fa[i] = i;
}
LL FindSet(LL x)
{
	if (Fa[x] != x)
		Fa[x] = FindSet( Fa[x] );
	return Fa[x];
}
LL Begin;
void Kruscal()
{
	sort(Ks + 1, Ks + 1 + m);
	LL MST = 0;
	MakeSet( n );
	for (Int i = 1; i <= m && MST < n - 1; ++ i)
	{
		LL Fu = FindSet( Ks[i].u );
		LL Fv = FindSet( Ks[i].v );
		if (Fu == Fv)
			continue;
		G[Ks[i].u].push_back(node(Ks[i].v, Ks[i].w));
		G[Ks[i].v].push_back(node(Ks[i].u, Ks[i].w));
		Root = Ks[i].u;
		Used[Ks[i].Index] = 1;
		Fa[Fu] = Fv;
		MST ++;
		Begin += Ks[i].w;
	}
}
LL Ans[MAXN];
LL Query(LL x,LL to)
{
	LL Res = 0;
	while (x != to)
	{
		LL Len = log2(Dep[x] - Dep[to]);
		Res = Max(Res, St[x][Len]);
		x = f[x][Len];
	}
	return Res;
}
int main()
{
	read( n ); read( m );
	for (Int i = 1; i <= m; ++ i)
	{
		read( Eg[i].u );
		read( Eg[i].v );
		read( Eg[i].w );
		Eg[i].Index = i;
		Ks[i] = Eg[i];
	}
	Kruscal();
	Build(Root, Root, 0);
	for (Int i = 1; i <= m; ++ i)
	{
		if ( Used[i] )
		{
			Ans[i] = Begin;
			continue;
		}
		LL Mid = LCA(Eg[i].u, Eg[i].v);
		LL Ud = Query(Eg[i].u, Mid);
		LL Vd = Query(Eg[i].v, Mid);
		Ans[i] = Begin + Eg[i].w - Max(Ud, Vd);
	}
	for (Int i = 1; i <= m; ++ i)
		printf("%lld\n", Ans[i]);
	return 0;
}