题解:P14164 [ICPC 2022 Nanjing R] 命题作文

原图由一条长度为 \(n - 1\) 的链和若干条额外边构成。将点 \(i\) 与 \(i + 1\) 之间的原始边称为树边,编号为 \(i\)(\(1 \le i < n\)),新加入的边称为非树边。每条非树边 \((u, v)\)(设 \(u < v\))覆盖了树边区间 \([u, v - 1]\)。由于树边构成原图的一棵生成树,删除任意两条非树边都无法破坏生成树的连通性,因此使得图不连通的边对 \((e, f)\) 中,必然至少包含一条树边。

我们考虑删除两条边后图不连通的方案数,可按边对的构成划分为三种互斥的情况。

其一,恰好选择一条树边与一条非树边。树边断开后,图被划分为两个连通块,若要使图不连通,所选的非树边必须是唯一跨越这两个连通块的边,即该树边被非树边覆盖的次数恰好为 \(1\),且所选非树边即为覆盖它的那条非树边。设覆盖次数恰好为 \(1\) 的树边数量为 \(cnt_1\),则此类方案数为 \(cnt_1\)。

其二,至少包含一条割边(被覆盖次数为 \(0\) 的树边)。若树边被覆盖次数为 \(0\),则仅删除该树边即可使图不连通,另一条边可以任意选取。设覆盖次数为 \(0\) 的树边数量为 \(cnt_0\)。若一条边选为被覆盖 \(0\) 次的树边,另一条边选为非树边或被覆盖至少 \(1\) 次的树边,方案数为 \(cnt_0 \times (n - 1 + m_{cur} - cnt_0)\),其中 \(m_{cur}\) 表示当前已加入的额外边总数。两条边均为被覆盖 \(0\) 次的树边的情况,可以归入下一类统一统计。

其三,选择两条树边。若选择两条树边 \(e_1, e_2\) 能使图不连通,当且仅当覆盖 \(e_1\) 的非树边集合与覆盖 \(e_2\) 的非树边集合完全相同。由此可以将所有树边按照其被覆盖的非树边集合划分为若干等价类。若某个等价类的大小为 \(s\),则从中任选两条树边均构成合法方案,贡献为 \(\binom{s}{2}\)。特别地,被覆盖 \(0\) 次的所有树边覆盖集合均为空集,天然属于同一个等价类,其相互配对的方案数已被包含在此项中。

综上,加入第 \(i\) 条额外边后的答案为 \(cnt_0 \times (n - 1 + i - cnt_0) + cnt_1 + \sum \binom{s}{2}\)。

对于 \(cnt_0\) 与 \(cnt_1\) 的动态维护,我们可以使用一棵支持区间加、区间查询覆盖次数为 \(0\) 和 \(1\) 的节点个数的线段树。由于区间覆盖次数单调不降,区间打上加法标记时,原先为 \(0\) 的计数直接转移给 \(1\) 并清空 \(0\),原先大于等于 \(1\) 的计数直接置零即可。

对于树边等价类的维护,我们注意到同一等价类中的树边在数轴上的相对顺序始终保持单调递增,可以用双向链表将同一等价类内的树边按编号升序连接。当新加入一条覆盖树边区间 \([l, r]\) 的额外边时,一个等价类链表只有在 \([l, r]\) 的边界处,其覆盖状态才会产生差异。具体而言,只有满足链表相邻两点中一个在 \([l, r]\) 内、另一个在 \([l, r]\) 外的边需要被切断:即链表节点满足其前驱小于 \(l\) 且自身落在 \([l, r]\) 内,或者自身落在 \([l, r]\) 内且其后继大于 \(r\)。

我们可以在线段树的每个节点上同时维护区间内链表前驱的最小值和后继的最大值。查询时利用最值剪枝,若区间前驱最小值大于等于 \(l\) 或后继最大值小于等于 \(r\) 则直接返回,从而在均摊对数时间内精准定位到所有发生断裂的位置。由于整张链表在所有操作中至多发生 \(O(n)\) 次断开,线段树定位断点的总时间复杂度为 \(O(n \log n)\)。

定位到所有断点后,考虑对等价类进行分裂。对于某个等价类链表,若其在 \([l, r]\) 内部存在部分节点,有两种情况:若该链表在 \([l, r]\) 左侧(小于 \(l\))与右侧(大于 \(r\))同时存在节点,则中间落在 \([l, r]\) 内部的这一段节点覆盖次数增加了 \(1\),而左侧段与右侧段均未被覆盖,它们的覆盖集合在加边后依然完全相同。因此,必须将中间段剥离出来形成新的等价类,同时将左侧段的末尾与右侧段的开头重新连接在一起,使其依然保留在原等价类中;若该链表仅在单侧存在越界节点,则直接将其切分为两段独立的链表即可。

在分裂过程中,采用双向同步遍历的启发式分裂:两个指针分别从两侧端点同时向外逐步前进,先到达端点的一侧规模必然不超过原集合的一半。遍历较小的一侧为其赋予新的等价类编号,并将原集合大小减去该部分大小,动态更新 \(\sum \binom{s}{2}\)。

每个元素被重新染色的次数 \(O(\log n)\),启发式分裂时间复杂度 \(O(n \log n)\)。

对于边界情况,当 \(n = 1\) 时图无任何树边,删去两条边后连通块数量不可能大于等于 \(2\),答案恒为 \(0\);当额外边为自环时,覆盖区间为空,不对树边区间进行修改,直接计入总边数并输出答案即可。

时间复杂度 \(O((n + m) \log n)\),空间复杂度 \(O(n)\)。

#include <bits/stdc++.h>
#define int long long
using namespace std;
int t, n, m, id, pre[250005], nxt[250005], bl[250005], root[500005], sz[500005], num, tag[1000005], cnt0[1000005], cnt1[1000005], tree[1000005], tree1[1000005];
void pushdown(int p) {
	if (tag[p]) {
		if (tag[p] == 1) { 
			cnt1[p * 2] = cnt0[p * 2]; 
			cnt0[p * 2] = 0; 
			cnt1[p * 2 + 1] = cnt0[p * 2 + 1]; 
			cnt0[p * 2 + 1] = 0; 
		} else if (tag[p] >= 2) { 
			cnt0[p * 2] = 0;
			cnt1[p * 2] = 0; 
			cnt0[p * 2 + 1] = 0;
			cnt1[p * 2 + 1] = 0; 
		}
		tag[p * 2] += tag[p];
		tag[p * 2 + 1] += tag[p];
		tag[p] = 0;
	}
}
void build(int p, int l, int r) {
	tag[p] = 0;
	if (l == r) {
		cnt0[p] = 1; cnt1[p] = 0;
		tree[p] = pre[l];
		tree1[p] = nxt[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(p * 2, l, mid);
	build(p * 2 + 1, mid + 1, r);
	cnt0[p] = cnt0[p * 2] + cnt0[p * 2 + 1];
	cnt1[p] = cnt1[p * 2] + cnt1[p * 2 + 1];
	tree[p] = min(tree[p * 2], tree[p * 2 + 1]);
	tree1[p] = max(tree1[p * 2], tree1[p * 2 + 1]);
}
void change(int p, int l, int r, int x, int d) {
	if (l == r) { 
		tree[p] = d; 
		return; 
	}
	pushdown(p);
	int mid = (l + r) >> 1;
	if (x <= mid) {
		change(p * 2, l, mid, x, d);
	} else {
		change(p * 2 + 1, mid + 1, r, x, d);
	}
	cnt0[p] = cnt0[p * 2] + cnt0[p * 2 + 1];
	cnt1[p] = cnt1[p * 2] + cnt1[p * 2 + 1];
	tree[p] = min(tree[p * 2], tree[p * 2 + 1]);
	tree1[p] = max(tree1[p * 2], tree1[p * 2 + 1]);
}
void change1(int p, int l, int r, int x, int d) {
	if (l == r) { 
		tree1[p] = d; 
		return; 
	}
	pushdown(p);
	int mid = (l + r) >> 1;
	if (x <= mid) {
		change1(p * 2, l, mid, x, d);
	} else {
		change1(p * 2 + 1, mid + 1, r, x, d);
	}
	cnt0[p] = cnt0[p * 2] + cnt0[p * 2 + 1];
	cnt1[p] = cnt1[p * 2] + cnt1[p * 2 + 1];
	tree[p] = min(tree[p * 2], tree[p * 2 + 1]);
	tree1[p] = max(tree1[p * 2], tree1[p * 2 + 1]);
}
void add(int p, int l, int r, int ll, int rr) {
	if (ll <= l && r <= rr) { 
		cnt1[p] = cnt0[p]; 
		cnt0[p] = 0; 
		tag[p] += 1;
		return; 
	}
	pushdown(p);
	int mid = (l + r) >> 1;
	if (ll <= mid) {
		add(p * 2, l, mid, ll, rr);
	}
	if (rr > mid) {
		add(p * 2 + 1, mid + 1, r, ll, rr);
	}
	cnt0[p] = cnt0[p * 2] + cnt0[p * 2 + 1];
	cnt1[p] = cnt1[p * 2] + cnt1[p * 2 + 1];
	tree[p] = min(tree[p * 2], tree[p * 2 + 1]);
	tree1[p] = max(tree1[p * 2], tree1[p * 2 + 1]);
}
void getp(int p, int l, int r, int ll, int rr, int lim, vector<pair<int, int>>& res) {
	if (tree[p] >= lim) {
		return;
	}
	if (l == r) { 
		res.push_back({bl[l], l}); 
		return; 
	}
	pushdown(p);
	int mid = (l + r) >> 1;
	if (ll <= mid) {
		getp(p * 2, l, mid, ll, rr, lim, res);
	}
	if (rr > mid) {
		getp(p * 2 + 1, mid + 1, r, ll, rr, lim, res);
	}
}
void get(int p, int l, int r, int ll, int rr, int lim, vector<pair<int, int>>& res) {
	if (tree1[p] <= lim) {
		return;
	}
	if (l == r) { 
		res.push_back({bl[nxt[l]], nxt[l]}); 
		return; 
	}
	pushdown(p);
	int mid = (l + r) >> 1;
	if (ll <= mid) {
		get(p * 2, l, mid, ll, rr, lim, res);
	}
	if (rr > mid) {
		get(p * 2 + 1, mid + 1, r, ll, rr, lim, res);
	}
}
void connect(int x, int y) {
	pre[y] = x; nxt[x] = y;
	change(1, 1, n - 1, y, x);
	change1(1, 1, n - 1, x, y);
}
void disconnect(int x) {
	int y = pre[x];
	pre[x] = x; nxt[y] = y;
	change(1, 1, n - 1, x, x);
	change1(1, 1, n - 1, y, y);
}
void cut(int p, int l, int r = 0) {
	num -= sz[p] * (sz[p] - 1) / 2;
	vector<int> v1, v2;
	int p1 = root[p], p2 = l;
	while (true) {
		v1.push_back(p1);
		v2.push_back(p2);
		int np1 = (nxt[p1] == l ? (r ? r : p1) : nxt[p1]), np2 = (r && nxt[p2] == r ? p2 : nxt[p2]);
		if (np1 == p1) {
			int now = ++id;
			root[now] = v1[0];
			for (int u : v1) bl[u] = now;
			sz[now] = v1.size();
			root[p] = l;
			sz[p] -= v1.size();
			break;
		} else if (np2 == p2) {
			int now = ++id;
			root[now] = v2[0];
			for (int u : v2) bl[u] = now;
			sz[now] = v2.size();
			sz[p] -= v2.size();
			break;
		} else {
			p1 = np1;
			p2 = np2;
		}
	}
	if (!r) {
		disconnect(l);
	} else {
		int tmp = pre[l];
		disconnect(l);
		disconnect(r);
		connect(tmp, r);
	}
	num += sz[p] * (sz[p] - 1) / 2 + sz[id] * (sz[id] - 1) / 2;
}
signed main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> t;
	while (t --) {
		cin >> n >> m;
		if (n == 1) {
			while (m --) { 
				int u, v; 
				cin >> u >> v; 
				cout << "0\n";
			}
			continue;
		}
		for (int i = 1; i < n; i++) {
			pre[i] = (i == 1 ? 1 : i - 1);
			nxt[i] = (i == n - 1 ? n - 1 : i + 1);
			bl[i] = 1;
		}
		root[1] = 1;
		sz[1] = n - 1;
		id = 1;
		num = 1LL * (n - 1) * (n - 2) / 2;
		build(1, 1, n - 1);
		for (int i = 1; i <= m; i++) {
			int u, v;
			cin >> u >> v;
			if (u > v) {
				swap(u, v);
			}
			int l = u, r = v - 1;
			if (l <= r) {
				add(1, 1, n - 1, l, r);
				vector<pair<int, int>> pt;
				getp(1, 1, n - 1, l, r, l, pt);
				get(1, 1, n - 1, l, r, r, pt);
				sort(pt.begin(), pt.end());
				for (int j = 0; j < (int)pt.size(); j++) {
					if (j + 1 < (int)pt.size() && pt[j].first == pt[j + 1].first) {
						cut(pt[j].first, pt[j].second, pt[j + 1].second);
						j++;
					} else {
						cut(pt[j].first, pt[j].second);
					}
				}
			}
			int ans = cnt0[1] * ((n - 1) + i - cnt0[1]) + cnt1[1] + num;
			cout << ans << "\n";
		}
	}
	cerr << "Time elapsed:" << 1.0 * clock() / CLOCKS_PER_SEC << "s.\n";
	return 0;
}
posted @ 2026-11-11 15:09  xuyifei0302  阅读(5)  评论(0)    收藏  举报