消息扩散（C++，缩点）

题目背景

本场比赛第一题，给个简单的吧，这 100 分先拿着。

题目描述

有 $n$ 个城市，中间有单向道路连接，消息会沿着道路扩散，现在给出 $n$ 个城市及其之间的道路，问至少需要在几个城市发布消息才能让这所有 $n$ 个城市都得到消息。

输入格式

第一行两个整数 $n,m$，表示 $n$ 个城市，$m$ 条单向道路。

以下 $m$ 行，每行两个整数 $b,e$ 表示有一条从 $b$ 到 $e$ 的道路，道路可以重复或存在自环。

输出格式

一行一个整数，表示至少要在几个城市中发布消息。

样例 #1

样例输入 #1

5 4
1 2
2 1
2 3
5 1

样例输出 #1

2

提示

【样例解释 #1】

样例中在 $4,5$ 号城市中发布消息。

【数据范围】

对于 $20\%$ 的数据，$n\le 200$；
对于 $40\%$ 的数据，$n\le 2000$；
对于 $100\%$ 的数据，$1\le n\le {10}^5$，$1\le m\le 5\times {10}^5$。

解题思路：

题意很好理解：给出存在重边和自环的图，求最少选取几个出发点能够遍历整张图

题中只关心最少选取出发点的数量，并不关心在遍历的过程中是否重复经过同一节点

那么对于形成环的节点，我们可以将其缩为一点，采用tarjan实现

如果没有学习过tarjan算法，这里推荐一篇洛谷博主Danny_boodman的博文

void tarjan(int s) {
	dfn[s] = low[s] = ++timeclock;
	stack[++rsp] = s;
	in_stack[s] = 1;

	for (int i = head[s]; i != -1; i = edges[i].next) {
		int v = edges[i].v;
		if (!dfn[v]) {
			tarjan(v);
			low[s] = min(low[s], low[v]);
		}
		else if (in_stack[v]) {
			low[s] = min(low[s], low[v]);
		}
	}

	if (dfn[s] == low[s]) {
		while (stack[rsp + 1] != s) {
			belong[stack[rsp]] = s;
			in_stack[stack[rsp]] = 0;
			rsp--;
		}
	}
}

压缩后的点具有环中所有节点的入边和出边

然后我们遍历每一条边，更新节点的入度

void re_init() {
	for (int i = 1; i <= n; i++) {
		for (int j = head[i]; j != -1; j = edges[j].next) {
			int v = edges[j].v;
			if (belong[i] != belong[v]) {//如果两点不在同一个环中
				in[belong[v]]++;//环v的入度++
			}
		}
	}
}

因为入度不为$0$的节点都可以通过入度为$0$的节点到达，最后输出入度为$0$的节点数量即可

for (int i = 1; i <= n; i++) {
	if (belong[i] == i && !in[belong[i]]) ans++;//注意判断是否为代表元素 belong[i] == i
}
cout << ans << endl;

完整的AC代码如下

//tarjan
#include <iostream>
#include <string.h>
using namespace std;
const int max_n = 1e5;
const int max_m = 5e5;

int dfn[max_n + 1], low[max_n + 1], timeclock = 0;
int stack[max_n + 1], in_stack[max_n + 1], rsp = -1;
int belong[max_n + 1];
int in[max_n + 1];
struct edge { int v, next; }edges[max_m];
int tot = -1;
int head[max_n + 1];
int n, m, u, v, ans = 0;

void add_edge(int u, int v) {
	edges[++tot] = { v,head[u] }; head[u] = tot;
}

void tarjan(int s) {
	dfn[s] = low[s] = ++timeclock;
	stack[++rsp] = s;
	in_stack[s] = 1;

	for (int i = head[s]; i != -1; i = edges[i].next) {
		int v = edges[i].v;
		if (!dfn[v]) {
			tarjan(v);
			low[s] = min(low[s], low[v]);
		}
		else if (in_stack[v]) {
			low[s] = min(low[s], low[v]);
		}
	}

	if (dfn[s] == low[s]) {
		while (stack[rsp + 1] != s) {
			belong[stack[rsp]] = s;
			in_stack[stack[rsp]] = 0;
			rsp--;
		}
	}
}

void re_init() {
	for (int i = 1; i <= n; i++) {
		for (int j = head[i]; j != -1; j = edges[j].next) {
			int v = edges[j].v;
			if (belong[i] != belong[v]) {
				in[belong[v]]++;
			}
		}
	}
}

int main() {
	memset(head + 1, -1, sizeof(int) * max_n);
	cin >> n >> m;
	for (int i = 0; i < m; i++) {
		cin >> u >> v;
		add_edge(u, v);
	}
	for (int i = 1; i <= n; i++) {
		if (!dfn[i]) {
			tarjan(i);
		}
	}
	re_init();
	for (int i = 1; i <= n; i++) {
		if (belong[i] == i && !in[belong[i]]) ans++;
	}
	cout << ans << endl;
	return 0;
}