『边双连通分量·树上差分』CF555E Case of Computer Network

$\mathrm{P}\mathrm{r}\mathrm{o}\mathrm{b}\mathrm{l}\mathrm{e}\mathrm{m}$

• 给定一张 $n$ 个点 $m$ 条边的无向图。

• 给定 $q$ 组有向点对 $(s,t)$。

• 询问是否存在使得所有 $s$ 都能到达 $t$ 的无向图中每条边的定向方案。

• $n,m,q\le 2\times 10^5$。

---

$\mathrm{S}\mathrm{o}\mathrm{l}\mathrm{u}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}$

如果形态是一棵树：我们可以对每一条路径进行两个属性的差分：

• 那么某一个边同时被两种不同的边经过则说明无解。

我们考虑如何将问题浓缩成一棵树。

• 若两个点之间存在至少两条边不同的路径，那么就一定有解。
• 边双内的任意两点显然满足上述条件。

因此，我们考虑使用边双缩点，直接用上面的方法进行树上差分即可。

注意要特判不连通的情况。

---

$\mathrm{C}\mathrm{o}\mathrm{d}\mathrm{e}$

#include <bits/stdc++.h>

using namespace std;
const int N = 6e5;

int n, m, cnt, tot(1), q, k;
int size[N], fa[N], f[N], dep[N], top[N], Fa[N];
int low[N], dfn[N], Link[N], b[N], son[N], g[N], fak[N];
struct node { int x, y, next; } e[N]; 
vector < int > a[N];

int read(void)
{
	int s = 0, w = 0; char c = getchar();
	while (!isdigit(c)) w |= c == '-', c = getchar();
	while (isdigit(c)) s = s*10+c-48, c = getchar();
	return w ? -s : s;
}

void add(int x, int y) {
	e[++ tot] = {x, y, Link[x]};
	Link[x] = tot;
}

void tarjan(int x, int last)
{
	low[x] = dfn[x] = ++ cnt;
	for (int i=Link[x];i;i=e[i].next)
	{
		int y = e[i].y;
		if (dfn[y] == 0) {
			tarjan(y, i);
			low[x] = min(low[x], low[y]);
			if (dfn[x] < low[y]) b[i] = b[i^1] = 1;
		}
		else if ((i ^ 1) != last)
			low[x] = min(low[x], dfn[y]);
	}
	return;
}


int find(int x) {
	if (fak[x] == x) return x;
	return fak[x] = find(fak[x]);
}

int get(int x) {
	if (fa[x] == x) return x;
	return fa[x] = get(fa[x]);
}

void add1(int x, int y) {
	x = get(x), y = get(y);
	a[x].push_back(y);
	a[y].push_back(x);
	fak[find(x)] = find(y);
}

void Dfs1(int x, int f)
{
	int Max = 0;
	Fa[x] = f, size[x] = 1;
	dep[x] = dep[Fa[x]] + 1;
	for (int i=0;i<a[x].size();++i)
	{
		int y = a[x][i];
		if (y == Fa[x]) continue;
		Dfs1(y, x), size[x] += size[y];
		if (size[y] > Max) Max = size[son[x] = y];
	}
	return;
}

void Dfs2(int x, int cur)
{
	top[x] = cur;
	if (son[x]) Dfs2(son[x], cur);
	for (int i=0;i<a[x].size();++i)
	{
		int y = a[x][i];
		if (y == son[x] || y == Fa[x]) continue;
		Dfs2(y, y);
	}
	return;
}

int LCA(int x, int y)
{
	while (top[x] != top[y])
	{
		if (dep[top[x]] < dep[top[y]]) swap(x, y);
		x = Fa[top[x]];
	}
	return dep[x] < dep[y] ? x : y;
}

void Dfs3(int x, int fa)
{
	for (int i=0;i<a[x].size();++i)
	{
		int y = a[x][i];
		if (y == fa) continue;
		Dfs3(y, x);
		f[x] += f[y];
		g[x] += g[y];
	}
	if (f[x] > 0 && g[x] > 0) {
		puts("No");
		exit(0); 
	}
	return;
}
 
void add(void)
{
	int x = read(), y = read();
	x = get(x), y = get(y);
	if (find(x) != find(y)) {
		puts("No");
		exit(0);
	}
	int root = LCA(x, y);
	f[x] ++, f[root] --;
	g[y] ++, g[root] --;
	return;
}

int main(void)
{
	n = read(), m = read(), k = read();
	for (int i=1;i<=m;++i)
	{
		int x = read(), y = read();
		add(x, y), add(y, x);
	}
	for (int i=1;i<=n;++i)
		if (!dfn[i]) tarjan(i, 0);
	for (int i=1;i<=n;++i) fa[i] = i;
	for (int i=2;i<=tot;i+=2)
		if (b[i] == 0) fa[get(e[i].x)] = get(e[i].y);
	for (int i=1;i<=n;++i) fak[i] = i;
	for (int i=2;i<=tot;i+=2)
		if (b[i] == 1) add1(e[i].x, e[i].y);
	Dfs1(get(1), 0);
	Dfs2(get(1), get(1));
	while (k --) add(); 
	Dfs3(get(1), 0);
	puts("Yes");
	return 0;
}