算法随笔：强连通分量
概念和性质：
强连通：在有向图G中，如果两个点u和v是互相可达的，即从u出发可以到达v，从v出发也可以到达u，则成u和v是强连通的。
强连通分量：如果一个有向图G不是强连通图，那么可以把它分成躲个子图，其中每个子图的内部是强连通的，而且这些子图已经扩展到最大，不能与子图外的任一点强连通，成这样的一个“极大连通”子图是G的一个强连通分量（SCC）。
强连通分量的一些性质：
（1）一个点必须有出度和入度，才会与其他点强连通。
（2）把一个SCC从图中挖掉，不影响其他点的强连通性。
求强连通分量的方法：
Kosaraju算法：
算法原理及步骤：
（1）将有向图G的所有边反向，建立返图rG，反图rG不会改变原图G的强连通性（也就不会改变SCC的数量）。
（2）对原图G做一次DFS，确定各点的先后顺序（可以用vector数组来记录顺序）。
（3）确定了顺序之后，在反图上做DFS，按顺序从优先级最高的点开始，到最低的点。
为什么要在反图上做DFS？这样做可以求得被隔离的岛。我们以下图为例，图a为原图G，图b为反图rG，我们将每个SCC都打上阴影，将其想象成一个个岛屿（也可以理解为一个个缩点），那么我们可以发现{a,b,e}这个SCC与其他SCC之间只有出边没有入边，所以这个SCC在第二次DFS中是要首先被遍历的，
那么我们在反图上遍历它的好处就是，可以发现在反图中，{a,b,e}这个SCC变成了只有入边没有出边，所以我们的遍历一定只会被限制在当前的SCC中，确定了第一个SCC。当我们遍历完这个SCC，我们将其删除（在代码中可以体现为将其标记为已经遍历），然后继续从剩下的优先级最高的点开始搜索，这一次从c开始搜索，因为反边，这次搜索也被限制在{c,d}内，确定了第二个SCC，删除这个SCC，然后按照这个步骤确定剩下的SCC。
参考代码：
题目来自hdu 1269，标准的模板题，判断整个图是否强连通，求出SCC数量是否为1即可。
在进行第一次dfs确定先后顺序时，我们有在递归进入时和递归返回时标记两种方法。分别给出代码：
#include
using namespace std;
#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e4 + 10;
const int INF = 0x3fffffff;
const int mod = 1000000007;
vector G[maxn], rG[maxn]; // 原图G和它的反图
vector S; // 存储第一次dfs的结果：标记点的先后顺序
int vis[maxn]; // 访问标记
int sccno[maxn]; // sccno[i]表示第i个点所属的强连通分量
int cnt; // 强连通分量的个数
int n, m;
void dfs1(int u) { // 在原图G上做一次dfs，标记点的先后顺序
S.push_back(u); // 记录点的先后顺序
vis[u] = true;
for (int i = 0; i < G[u].size(); i++) {
if (!vis[G[u][i]]) {
dfs1(G[u][i]);
}
}
}
void dfs2(int u) { // 在反图rG上做一次dfs，顺序从标记最大的点开始，到标记最小的点。
sccno[u] = cnt;
for (int i = 0; i < rG[u].size(); i++) {
if (!sccno[rG[u][i]]) {
dfs2(rG[u][i]);
}
}
}
void Kosaraju() {
cnt = 0;
S.clear();
memset(sccno, 0, sizeof sccno);
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs1(i);
}
}
for (int i = 0; i < n; i++) {
if (!sccno[S[i]]) {
cnt++;
dfs2(S[i]);
}
}
}
void solve() {
int u, v;
while (cin >> n >> m, n != 0 || m != 0) {
for (int i = 1; i <= n; i++) {
G[i].clear();
rG[i].clear();
}
for (int i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v); // 原图
rG[v].push_back(u); // 反图
}
Kosaraju();
cout << (cnt == 1 ? "Yes\n" : "No\n");
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout.precision(18);
solve();
return 0;
} #include
using namespace std;
#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e4 + 10;
const int INF = 0x3fffffff;
const int mod = 1000000007;
vector G[maxn], rG[maxn]; // 原图G和它的反图
vector S; // 存储第一次dfs的结果：标记点的先后顺序
int vis[maxn]; // 访问标记
int sccno[maxn]; // sccno[i]表示第i个点所属的强连通分量
int cnt; // 强连通分量的个数
int n, m;
void dfs1(int u) { // 在原图G上做一次dfs，标记点的先后顺序
vis[u] = true;
for (int i = 0; i < G[u].size(); i++) {
if (!vis[G[u][i]]) {
dfs1(G[u][i]);
}
}
S.push_back(u); // 记录点的先后顺序，标记大的放在S的后面
}
void dfs2(int u) { // 在反图rG上做一次dfs，顺序从标记最大的点开始，到标记最小的点。
sccno[u] = cnt;
for (int i = 0; i < rG[u].size(); i++) {
if (!sccno[rG[u][i]]) {
dfs2(rG[u][i]);
}
}
}
void Kosaraju() {
cnt = 0;
S.clear();
memset(sccno, 0, sizeof sccno);
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs1(i);
}
}
for (int i = n - 1; i >= 0; i--) {
if (!sccno[S[i]]) {
cnt++;
dfs2(S[i]);
}
}
}
void solve() {
int u, v;
while (cin >> n >> m, n != 0 || m != 0) {
for (int i = 1; i <= n; i++) {
G[i].clear();
rG[i].clear();
}
for (int i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v); // 原图
rG[v].push_back(u); // 反图
}
Kosaraju();
cout << (cnt == 1 ? "Yes\n" : "No\n");
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout.precision(18);
solve();
return 0;
} Tarjan算法：
算法原理及步骤：
在讲Tarjan算法之前，我们需要给出一个定理：一个SCC，从其中任意一点出发，都至少有一条路径可以回到自己。那么其实从任意一点开始DFS，这个点都会成为这个SCC的祖先。
我们可以在DFS求low值的同时把点按SCC（有相同的low值）分开，用栈分离不同的SCC。关于low值的定义可以看看我之前关于割点割边的随笔。
大体步骤：
dfn[u]表示dfs时达到顶点u的次序号（时间戳），low[u]表示以u为根节点的dfs树中次序号最小的顶点的次序号，所以当dfn[u]=low[u]时，以u为根的搜索子树上所有节点是一个强连通分量。 先将顶点u入栈，dfn[u]=low[u]=++idx,扫描u能到达的顶点v，如果v没有被访问过，则dfs(v)，low[u]=min(low[u],low[v])，如果v在栈里，low[u]=min(low[u],dfn[v])，扫描完v以后，如果dfn[u]=low[u]，则将u及其以上顶点出栈。
考虑最先入栈的点，每进入一个新的SCC，访问并入栈的第1个点都是这个SCC的祖先，它的num值和low值相等，这个SCC中所有的点的low值都与它相等。
参考代码：
例题仍然是hdu1269
#include
using namespace std;
#define endl '\n'
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e4 + 10;
const int INF = 0x3fffffff;
const int mod = 1000000007;
int num[maxn]; // 记录每个节点的dfs次序，时间戳
int low[maxn]; // low[v]表示v以及v的后代能退回到的节点的num值最小是多少
int sccno[maxn]; // sccno[u]表示u点属于哪个强连通分量
int st[maxn], top; // 模拟栈
vector G[maxn]; // 图
int dfn; // dfs次序，时间戳
int cnt; // 强连通分量的个数
int n, m;
void dfs(int u) {
st[top++] = u; // u入栈
low[u] = num[u] = ++dfn;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (!num[v]) { // 未访问过的点，继续dfs
dfs(v); // dfs的最底层，是最后一个SCC
low[u] = min(low[u], low[v]);
} else if (!sccno[v]) { // 处理回退边
low[u] = min(low[u], num[v]);
}
}
if (low[u] == num[u]) { // 栈底的点是SCC的祖先，它的low == num
cnt++;
while (1) {
int v = st[--top]; // v弹出栈
sccno[v] = cnt;
if (u == v) { // 栈底的点是SCC的祖先
break;
}
}
}
}
void tarjan() {
cnt = top = dfn = 0;
memset(sccno, 0, sizeof sccno);
memset(num, 0, sizeof num);
memset(low, 0, sizeof low);
for (int i = 1; i <= n; i++) {
if (!num[i]) {
dfs(i);
}
}
}
void solve() {
int u, v;
while (cin >> n >> m, n != 0 || m != 0) {
for (int i = 1; i <= n; i++) {
G[i].clear();
}
for (int i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v);
}
tarjan();
cout << (cnt == 1 ? "Yes\n" : "No\n");
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout.precision(18);
solve();
return 0;
}