间谍网络（C++，强连通分量，缩点）

题目描述

由于外国间谍的大量渗入，国家安全正处于高度的危机之中。如果 A 间谍手中掌握着关于 B 间谍的犯罪证据，则称 A 可以揭发 B。有些间谍收受贿赂，只要给他们一定数量的美元，他们就愿意交出手中掌握的全部情报。所以，如果我们能够收买一些间谍的话，我们就可能控制间谍网中的每一分子。因为一旦我们逮捕了一个间谍，他手中掌握的情报都将归我们所有，这样就有可能逮捕新的间谍，掌握新的情报。

我们的反间谍机关提供了一份资料，包括所有已知的受贿的间谍，以及他们愿意收受的具体数额。同时我们还知道哪些间谍手中具体掌握了哪些间谍的资料。假设总共有 $n$ 个间谍（$n$ 不超过 $3000$），每个间谍分别用 $1$ 到 $3000$ 的整数来标识。

请根据这份资料，判断我们是否有可能控制全部的间谍，如果可以，求出我们所需要支付的最少资金。否则，输出不能被控制的一个间谍。

输入格式

第一行只有一个整数 $n$。

第二行是整数 $p$。表示愿意被收买的人数，$1\le p\le n$。

接下来的 $p$ 行，每行有两个整数，第一个数是一个愿意被收买的间谍的编号，第二个数表示他将会被收买的数额。这个数额不超过 $20000$。

紧跟着一行只有一个整数 $r$，$1\le r\le 8000$。然后 $r$ 行，每行两个正整数，表示数对 $(A,B)$，$A$ 间谍掌握 $B$ 间谍的证据。

输出格式

如果可以控制所有间谍，第一行输出 YES，并在第二行输出所需要支付的贿金最小值。否则输出 NO，并在第二行输出不能控制的间谍中，编号最小的间谍编号。

样例 #1

样例输入 #1

3
2
1 10
2 100
2
1 3
2 3

样例输出 #1

YES
110

样例 #2

样例输入 #2

4
2
1 100
4 200
2
1 2
3 4

样例输出 #2

NO
3

解题思路：

先来分析一下题意：

间谍分为两类：可收买的，不可收买的

可收买的间谍可以用钱来控制，或者通过其他间谍的情报来控制

不可收买的间谍只能通过其他间谍的情报来控制

题意说明完毕，接下来讲解解题思路：

因为可收买的间谍有两种控制方式，所以贿金存在最小值

先给出两个易于理解的事实：

如果把间谍网络抽象为一张图，以揭发关系为有向边

1）假设这张图无环，那么对于每条链，我们一定会选择链头

2）假设这张图是一个环，那么我们一定会选择收买贿金最少的间谍

基于这两个简单的事实，我们可以一个环中的所有间谍合并为一个间谍，取其中贿金最小值作为新间谍的贿金，同时记录环中索引最小值，新节点与是原环等价的

处理之后形成一张无环图，遍历所有入度为$0$的节点

如果可以贿赂则累加贿金，反之将其加入一个队列中（用于维护不可控间谍）

若队列为空，即所有间谍都可控，那么输出YES和累加和

反之，进行拓扑排序：取出队首，删除队首节点，减少相临节点入度

如果入度为0 && 不可贿赂（可以证明，这就是不可控间谍的充分必要条件），将其加入队列

循环执行至队列为空

最后输出NO和所有被删除节点记录的索引中的最小值

AC代码如下

#include <iostream>
#include <string.h>
#include <queue>
using namespace std;
const int max_n = 3000;
const int max_m = 8e3;
const int NaN = 0x3F3F3F3F;

int n;
//链式前向星
int able[max_n + 1];
struct edge { int v, next; }edges[max_m];
int tot = -1;
int head[max_n + 1];
//tarjan
int dfn[max_n + 1], low[max_n + 1], timeclock = 0;
int belong[max_n + 1], cnt = 0;
int stack[max_n], in_stack[max_n], rsp = -1;
//new链式前向星
int in[max_n + 1];
int new_able[max_n + 1];
int new_index[max_n + 1];
edge new_edges[max_m];
int new_tot = -1;
int new_head[max_n + 1];
//topo
queue<int>q;
long long sum = 0;
int min_index = NaN;

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

void new_add_edge(int u, int v) {
	new_edges[++new_tot] = { v,new_head[u] }; new_head[u] = new_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 (low[s] == dfn[s]) {
		cnt++;
		while (stack[rsp + 1] != s) {
			belong[stack[rsp]] = cnt;
			new_able[cnt] = min(new_able[cnt], able[stack[rsp]]);
			new_index[cnt] = min(new_index[cnt], stack[rsp]);
			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]]++;
				new_add_edge(belong[i], belong[v]);
			}
		}
	}
}

void topo() {
	for (int i = 1; i <= cnt; i++) {
		if (!in[i]) {
			if (new_able[i] == NaN) q.push(i);
			else sum += new_able[i];
		}
	}

	if (q.empty()) {
		cout << "YES" << endl;
		cout << sum << endl;
		return;
	}

	while (!q.empty()) {
		int node = q.front();
		q.pop();
		min_index = min(min_index, new_index[node]);
		for (int i = new_head[node]; i != -1; i = new_edges[i].next) {
			int v = new_edges[i].v;
			if (--in[v] == 0 && new_able[v] == NaN) {
				q.push(v);
			}
		}
	}
	cout << "NO" << endl;
	cout << min_index << endl;
	return;
}

int main() {
	memset(head + 1, -1, sizeof(int) * max_n);
	memset(new_head + 1, -1, sizeof(int) * max_n);
	memset(able + 1, 0x3F, sizeof(int) * max_n);
	memset(new_able + 1, 0x3F, sizeof(int) * max_n);
	memset(new_index + 1, 0x3F, sizeof(int) * max_n);
	int p, r, index, a, u, v;
	cin >> n >> p;
	for (int i = 0; i < p; i++) {
		cin >> index >> a;
		able[index] = a;
	}
	cin >> r;
	for (int i = 0; i < r; i++) {
		cin >> u >> v;
		add_edge(u, v);
	}
	for (int i = 1; i <= n; i++) {
		if (!dfn[i]) {
			tarjan(i);
		}
	}
	re_init();
	topo();
	return 0;
}