迷宫城堡 HDU - 1269

为了训练小希的方向感，Gardon建立了一座大城堡，里面有N个房间(N<=10000)和M条通道(M<=100000)，每个通道都是单向的，就是说若称某通道连通了A房间和B房间，只说明可以通过这个通道由A房间到达B房间，但并不说明通过它可以由B房间到达A房间。Gardon需要请你写个程序确认一下是否任意两个房间都是相互连通的，即：对于任意的i和j，至少存在一条路径可以从房间i到房间j，也存在一条路径可以从房间j到房间i。

Input输入包含多组数据，输入的第一行有两个数：N和M，接下来的M行每行有两个数a和b，表示了一条通道可以从A房间来到B房间。文件最后以两个0结束。
Output对于输入的每组数据，如果任意两个房间都是相互连接的，输出"Yes"，否则输出"No"。
Sample Input

3 3
1 2
2 3
3 1
3 3
1 2
2 3
3 2
0 0

Sample Output

Yes
No
有向图n个点，m条边，判断图是否强连通
基本知识：强连通图（Strongly Connected Graph）是指在有向图G中，如果对于每一对vi、vj，vi≠vj，从vi到vj和从vj到vi都存在路径，则称G是强连通图。有向图中的极大强连通子图称做有向图的强连通分量。
有向图强连通分量：在有向图G中，如果两个顶点vi,vj间（vi>vj）有一条从vi到vj的有向路径，同时还有一条从vj到vi的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。
有向图的极大强连通子图，称为强连通分量(strongly connected components)（SCC）。
求SCC有三种高效算法：Kosaraju，Tarjan，Garbow，复杂度为0(V+E),Kosaraju相对差一点;
Kosaraju算法：
利用“反图”的思想：
1）有向图G所有边反向得到rG，不会改变SCC数量；
2）对G和rG各做一次dfs可得SCC数量.

#include <cstdio>
#include <iostream>
#include <cmath>
#include <string.h>
#include <algorithm>
#include <vector>
#include <queue>
#define clr(a) memset(a, 0, sizeof(a))   
#define re(i,a,b) for(int i=(a),_=(b);i<_;i++)
using namespace std;
const int mx = 10005;
int n, m, i, j, k,t;
int a[mx], b[mx];
vector<int>G[mx],rG[mx];
vector<int>S;//存第一次dfs1()的结果：标记点的先后顺序
int vis[mx], scc[mx], cnt;//cnt:强连通分量的个数
void dfs1(int u) {
    if (vis[u])return;
    vis[u] = 1;
    re(i, 0, G[u].size())dfs1(G[u][i]);
    S.push_back(u);//记录点的先后顺序，标记大的放在S后面
}
void dfs2(int u) {
    if (scc[u])return;
    scc[u] = cnt;
    re(i, 0, rG[u].size())dfs2(rG[u][i]);
}
void Kosaraju(int n) {
    cnt = 0;
    S.clear();
    clr(scc);
    clr(vis);
    re(i, 1, n + 1)dfs1(i);//点的编号1~n.递归所有点
    for (int i=n-1;i>=0;i--)
    {
        if (!scc[S[i]]) {
            cnt++;
            dfs2(S[i]);
        }
    }
}
int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int u, v;
    while (scanf("%d%d",&n,&m),n!=0||m!=0)
    {
        re(i, 0, n) {
            G[i].clear();
            rG[i].clear();
        }
        re(i, 0, m) {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);//原图
            rG[v].push_back(u);//反图
        }
        Kosaraju(n);
        printf("%s\n", cnt == 1 ? "Yes" : "No");
    }
    return 0;
}

Tarjan算法：

下图中，子图{1,2,3,4}为一个强连通分量，因为顶点1,2,3,4两两可达。{5},{6}也分别是两个强连通分量。

Tarjan算法是用来求有向图的强连通分量的。求有向图的强连通分量的Tarjan算法是以其发明者Robert Tarjan命名的。Robert Tarjan还发明了求双连通分量的Tarjan算法。

Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。

定义DFN(u)为节点u搜索的次序编号(时间戳)，Low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号。

当DFN(u)=Low(u)时，以u为根的搜索子树上所有节点是一个强连通分量。

接下来是对算法流程的演示。

从节点1开始DFS，把遍历到的节点加入栈中。搜索到节点u=6时，DFN[6]=LOW[6]，找到了一个强连通分量。退栈到u=v为止，{6}为一个强连通分量。

返回节点5，发现DFN[5]=LOW[5]，退栈后{5}为一个强连通分量。

返回节点3，继续搜索到节点4，把4加入堆栈。发现节点4向节点1有后向边，节点1还在栈中，所以LOW[4]=1。节点6已经出栈，(4,6)是横叉边，返回3，(3,4)为树枝边，所以LOW[3]=LOW[4]=1。

继续回到节点1，最后访问节点2。访问边(2,4)，4还在栈中，所以LOW[2]=DFN[4]=5。返回1后，发现DFN[1]=LOW[1]，把栈中节点全部取出，组成一个连通分量{1,3,4,2}。

至此，算法结束。经过该算法，求出了图中全部的三个强连通分量{1,3,4,2},{5},{6}。

可以发现，运行Tarjan算法的过程中，每个顶点都被访问了一次，且只进出了一次堆栈，每条边也只被访问了一次，所以该算法的时间复杂度为O(V+E)，但只做了一次dfs，比Kosaraju快。

 

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 4e18+10;
const int mod = 1000000007;
const int mx = 10005; //check the limits, dummy
typedef pair<int, int> pa;
const double PI = acos(-1);
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
#define swa(a,b) a^=b^=a^=b
#define re(i,a,b) for(int i=(a),_=(b);i<_;i++)
#define rb(i,a,b) for(int i=(b),_=(a);i>=_;i--)
#define clr(a) memset(a, 0, sizeof(a))
#define lowbit(x) ((x)&(x-1))
#define mkp make_pair
void sc(int& x) { scanf("%d", &x); }void sc(int64_t& x) { scanf("%lld", &x); }void sc(double& x) { scanf("%lf", &x); }void sc(char& x) { scanf(" %c", &x); }void sc(char* x) { scanf("%s", x); }
int  m, n,k,sum=0,ans=0,t;
int cnt;//SCC 的个数
int low[mx], num[mx], dfn;
int sccno[mx], stack1[mx], top;//用stack处理栈，top栈顶
vector<int>G[mx];
void dfs(int u) {
    stack1[top++] = u;//u进栈
    low[u] = num[u] = ++dfn;
    re(i, 0, G[u].size()) {
        int v = G[u][i];
        if (!num[v]) {
            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 = stack1[--top];//v弹出栈
            sccno[v] = cnt;
            if (u == v)break;//栈底的点是SCC的祖先
        }
    }
}
void Tarjan(int n) {
    cnt = top = dfn = 0;
    clr(sccno);
    clr(num);
    clr(low);
    re(i, 1, n + 1) {
        if (!num[i])
            dfs(i);
    }
}
int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int u, v;
    while (cin>>n>>m,n!=0||m!=0)
    {
        re(i, 1, n + 1)G[i].clear();
        re(i, 0, m) {
            cin >> u >> v;
            G[u].push_back(v);
        }
        Tarjan(n);
        printf("%s\n", cnt == 1 ? "Yes" : "No");
    }    
    return 0;
}