“蔚来杯”2022牛客暑假多校训练营部分题解 1

原创

已于 2022-09-01 20:21:26 修改 · 692 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构

于 2022-07-24 10:13:52 首次发布

本文介绍了两种算法解决有向图中最大化黑点数量的问题，一种是利用并查集维护黑点集合的动态更新，另一种是通过随机排列结合树形结构分析期望时间复杂度。

1J. Serval and Essay

题目大意

有 $n$ 个点 $m$ 条边的无重边无自环的有向图。
初始时可以选择一个点染黑，其余点均为白点。
若某点所有入边起点均为黑点，则该点可被染黑。
最大化图中黑点数目。
多组数据， $\le \sum n \le 2 \times 10^5, 1 \le \sum m\le 5\times 10^5$ 。

算法 1

设 $S_u$ 表示 $u$ 为初始黑点迭代得到的最终黑点集合， $I_u$ 为 $u$ 所有入边起点构成的集合。
显然 $∀u,v\forall u,v$ ， $S_u, S_v$ 只能为包含或不交的关系。
初始时 $S_u = \{u\}$ ，迭代的过程即，若 $∃v,Iv⊆Su\exist v, I_v \subseteq S_u$ ，则 $Su←Su∪SvS_u \leftarrow S_u \cup S_v$ 。
不断重复上述过程，直到找不到符合条件的 $v$ ，答案为 $max\{|S_u|\}$ 。
用并查集维护 $S_u$ 。
初始时 $Iv⊆SuI_v \subseteq S_u$ 就等价于 $S_v$ 仅有一条来自 $S_u$ 的入边。
可以用 $set\text{set}$ 维护每个 $S_u$ 所有出边指向的点的集合（除去指向 $S_u$ 内部的点），合并 $S_u, S_v$ 时合并出边就能使上述等价条件在任意情况下成立，只要维护每个点的入度就能很容易找到点 $v$ 。
合并时采用启发式合并，时间复杂度 $O((n+m)log⁡2n)\mathcal O((n + m)\log^2n)$ 。

#include <bits/stdc++.h>

template <class T>
inline void read(T &res)
{
   
   
	char ch; bool flag = false; res = 0;
	while (ch = getchar(), !isdigit(ch) && ch != '-');
	ch == '-' ? flag = true : res = ch ^ 48;
	while (ch = getchar(), isdigit(ch))
		res = res * 10 + ch - 48;
	flag ? res = -res : 0;
}

template <class T>
inline void put(T x)
{
   
   
	if (x > 9)
		put(x / 10);
	putchar(x % 10 + 48);
}

template <class T>
inline void _put(T x)
{
   
   
	if (x < 0)
		x = -x, putchar('-');
	put(x);
}

template <class T>
inline void CkMin(T &x, T y) {
   
   x > y ? x = y : 0;}
template <class T>
inline void CkMax(T &x, T y) {
   
   x < y ? x = y : 0;}
template <class T>
inline T Min(T x, T y) {
   
   return x < y ? x : y;}
template <class T>
inline T Max(T x, T y) {
   
   return x > y ? x : y;}
template <class T>
inline T Abs(T x) {
   
   return x < 0 ? -x : x;}

using std::set;
using std::map;
using std::pair;
using std::string;
using std::vector;
using std::multiset;
using std::priority_queue;

typedef long long ll;
typedef long double ld;
typedef set<int>::iterator it;
const int Maxn = 1e9;
const int N = 2e5 + 5;
int n, top, T_data;
set<int> out[N];
int ind[N], pre[N], stk[N], sze[N], fa[N];

inline int ufs_find(int x)
{
   
   
	if (fa[x] != x)
		return fa[x] = ufs_find(fa[x]);
	return x;
}

inline void Merge(int x, int y)
{
   
   
	int tx = ufs_find(x), 
		ty = ufs_find(y);
	if (tx == ty)
		return ;
	if (out[tx].size() < out[ty].size())
		std::swap(tx, ty);
	fa[ty] = tx;
	sze[tx] += sze[ty];

	for (it e2 = out[ty].begin(); e2 != out[ty].end(); ++e2)
	{
   
   
		y = *e2;
		it e1 = out[tx].find(y);
		if (e1 == out[tx].end())
			out[tx].insert(y);
		else
		{
   
   
			--ind[y];
			if (ind[y] == 1)
				stk[++top] = y;
		}
	}
}

int main()
{
   
   
	read(T_data);
	for (int t = 1; t <= T_data; ++t)
	{
   
   
		read(n);
		top = 0;
		for (int i = 1; i <= n; ++i)
		{
   
   
			out[i].clear();
			fa[i] = i;
			sze[i] = 1;
		}
		for (int i = 1, x; i <= n; ++i)
		{
   
   
			read(ind[i]);
			for (int j = 1; j <= ind[i]; ++j)
			{
   
   
				read(x);
				out[x].insert(i);
			}
			pre[i] = x;
			if (ind[i] == 1)
				stk[++top] = i;
		}
		
		while (top)
		{
   
   
			int x = stk[top--];
			Merge(pre[x], x);
		}
		int ans = 0;
		for (int i = 1; i <= n; ++i)
			if (ufs_find(i) == i)
				CkMax(ans, sze[i]);
		printf("Case #%d: %d\n", t, ans);
	}
	return 0;
}

算法 2

注意到若 $\in S_u$ ，则 $S_v| < |S_u|$ 。
随机一个排列 $P$ ，若 $pi∉Sp1∪Sp2∪⋯∪Spi−1p_i \notin S_{p_1} \cup S_{p_2} \cup \dots \cup S_{p_{i -1}}$ ，直接暴力求 $S_{p_i}$ 。
$S_u$ 的包含关系可以构成树形结构，需要暴力求 $S_{p_i}$ 当且仅当它的所有祖先的 $S_u$ 均还未求出。
容易分析出这一做法的期望时间复杂度为 $O((n+m)log⁡n)\mathcal O((n+m)\log n)$ 。

#include <bits/stdc++.h>

template <class T>
inline void read(T &res)

最低0.47元/天解锁文章