【YBT2023寒假Day13 C】百里守约（Boruvka算法）（扫描线）（线段树）

百里守约

题目链接：YBT2023寒假Day13 C

题目大意

有一个 n*n 的矩阵，一开始里面都是 0，多次操作，每次把一个子矩阵里面的值都增加每次给出的 w。
然后全部操作完之后构造一个 n 个点的简单无向完全图，对于 i<j，有 i,j 之间的边边权是 Ai,j。
然后要你求这个图的最小生成树对于边权和。

思路

发现我们 Kruskal 算法和 Prim 算法对于这道题都不是很适配。
于是还有一个算法是 Boruvka 算法，流程大概是每次对于每个连通块，找到这个连通块和其他连通块中边权最小的点。
然后由于合并嘛，每次连通块数量减半，所以复杂度是 \(O(n\log n)\) 的。
那考虑怎么求每个连通块往外边权最小的边。

考虑扫描线，先把区间加拆成在 \(x_1\) 的时候给 \(y_1\sim y_2\) 加 \(w\)，在 \(x_2+1\) 的时候给 \(y_1\sim y_2\) 加 \(-w\)。
然后对于查询，你要找的就是不在自己连通块里面，我们维护的区间中最小的值。
那这个显然可以每个值有自己所在的连通块，你就每个位置记录距离前二小的连通块以及它们的距离就行了。
那每次从头扫过去都是 \(O(n\log n)\)，一共扫 \(\log n\) 次，所以是 \(O(n\log^2n)\) 的。

不过有一个要注意的点是因为给你的是无向图，边无向，所以你给一个矩阵 \([x_1,x_2]\times[y_1,y_2]\) 加值的同时还要给 \([y_1,y_2]\times[x_1,x_2]\) 加。

代码

#include<cstdio>
#include<vector>
#include<algorithm>
#define ll long long
#define INF 0x3f3f3f3f3f3f3f3f

using namespace std;

const ll N = 1e5 + 100;
struct node {
	ll y, yy, w;
};
ll n, m, g[N], fa[N], disp[N];
vector <node> f[N];
ll ans, dis[N];

ll find(ll now) {
	if (fa[now] == now) return now;
	return fa[now] = find(fa[now]);
}

struct XD_tree {
	ll minn[N << 2], minn2[N << 2], lzy[N << 2];
	ll minx[N << 2], minx2[N << 2];
	
	void up(ll now) {
		minn2[now] = INF; minx2[now] = 0;
		if (minn[now << 1] < minn[now << 1 | 1]) {
			minn[now] = minn[now << 1];
			minx[now] = minx[now << 1];
			if (find(minx[now << 1]) != find(minx[now << 1 | 1])) minn2[now] = minn[now << 1 | 1], minx2[now] = minx[now << 1 | 1];
		}
		else {
			minn[now] = minn[now << 1 | 1];
			minx[now] = minx[now << 1 | 1];
			if (find(minx[now << 1]) != find(minx[now << 1 | 1])) minn2[now] = minn[now << 1], minx2[now] = minx[now << 1];
		}
		if (find(minx[now]) != find(minx2[now << 1]) && minn2[now] > minn2[now << 1]) {
			minn2[now] = minn2[now << 1]; minx2[now] = minx2[now << 1];
		}
		if (find(minx[now]) != find(minx2[now << 1 | 1]) && minn2[now] > minn2[now << 1 | 1]) {
			minn2[now] = minn2[now << 1 | 1]; minx2[now] = minx2[now << 1 | 1];
		}
	}
	
	void downa(ll now, ll x) {
		lzy[now] += x; minn[now] += x; minn2[now] += x;
	}
	
	void down(ll now) {
		if (lzy[now]) {
			downa(now << 1, lzy[now]); downa(now << 1 | 1, lzy[now]);
			lzy[now] = 0;
		}
	}
	
	void build(ll now, ll l, ll r) {
		lzy[now] = 0;
		if (l == r) {
			minn[now] = 0; minx[now] = l;
			minn2[now] = INF; minx2[now] = 0;
			return ;
		}
		ll mid = (l + r) >> 1;
		build(now << 1, l, mid); build(now << 1 | 1, mid + 1, r);
		up(now);
	}
	
	void update(ll now, ll l, ll r, ll L, ll R, ll x) {
		if (L <= l && r <= R) {
			downa(now, x); return ;
		}
		ll mid = (l + r) >> 1; down(now);
		if (L <= mid) update(now << 1, l, mid, L, R, x);
		if (mid < R) update(now << 1 | 1, mid + 1, r, L, R, x);
		up(now);
	}
}T;

int main() {
	freopen("rect.in", "r", stdin);
	freopen("rect.out", "w", stdout);
//	freopen("ex_rect3.in", "r", stdin);
	
	scanf("%lld %lld", &n, &m);
	for (ll i = 1; i <= m; i++) {
		ll x, xx, y, yy, w; scanf("%lld %lld %lld %lld %lld", &x, &xx, &y, &yy, &w);
		f[x].push_back((node){y, yy, w}); f[xx + 1].push_back((node){y, yy, -w});
		f[y].push_back((node){x, xx, w}); f[yy + 1].push_back((node){x, xx, -w});
	}
	
	for (ll i = 1; i <= n; i++) fa[i] = i;
	while (1) {
		ll cnt = 0; for (ll i = 1; i <= n; i++) {if (fa[i] == i) cnt++; dis[i] = INF; disp[i] = 0;}
		if (cnt == 1) break;
		T.build(1, 1, n);
		for (ll i = 1; i <= n; i++) {
			for (ll j = 0; j < f[i].size(); j++) {
				T.update(1, 1, n, f[i][j].y, f[i][j].yy, f[i][j].w);
			}
			if (find(i) == find(T.minx[1])) {
				if (dis[find(i)] > T.minn2[1]) dis[find(i)] = T.minn2[1], disp[find(i)] = find(T.minx2[1]);
			}
			else {
				if (dis[find(i)] > T.minn[1]) dis[find(i)] = T.minn[1], disp[find(i)] = find(T.minx[1]);
			}
		}
		for (ll i = 1; i <= n; i++) {
			if (i == fa[i] && disp[i] && find(i) != find(disp[i])) {
				fa[find(i)] = find(disp[i]); ans += dis[i];
			}
		}
	}
	printf("%lld", ans);
	
	return 0;
}