HDU 1269迷宫城堡（强连通图的判定）模板

最近在做专题看见强连通图，就做了做，写一些博客巩固一下自己的知识，写了一些自己看着还可以的模板。
强连通图一般认为有两个模板，一个是kosaraju算法，一个是tarjan 解法，这两种模板都并不是太难，相比于tarjan，第一个更容易理解一些所以，先写第一个。
迷宫城堡
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 8196 Accepted Submission(s): 3664

Problem Description
为了训练小希的方向感，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
一般认为一个点可以到达图的任意一个点，最简易的方式就是dfs,通过遍历，寻找每一种可能，而想要判断每个点都是这样那么每个店都需要这样处理，复杂度为n*N，有一种方式是通过一个点dfs然后将图的出发点和终止点反置，然后再dfs,还是成立的，我们就说这个图的任意两点能够相互到达，就是强连通图。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
typedef long long ll;
const int maxn = 10005;
typedef vector<int> vec;
vec front_vector[maxn];
vec end_vector[maxn];

int n,m;
int visit[maxn];

bool dfs(int u,vec *temp_vector){
    memset(visit,0,sizeof(visit));
    queue <int> que;
    visit[u] = 1;
    int num =0;
    num++;
    que.push(u);
    while(!que.empty()){
        int tmp = que.front();
        que.pop();
        for(int i=0;i<temp_vector[tmp].size();i++){
            if(!visit[temp_vector[tmp][i]]){
                que.push(temp_vector[tmp][i]);
                visit[temp_vector[tmp][i]] = 1;
                num++;
            }
            if(num==n){
                return true;
            }
        }
    }
    if(num==n)
        return true;
    return false;
}

void front_end(){
    for(int i=1;i<=n;i++){
        for(int j=0;j<front_vector[i].size();j++){
            end_vector[front_vector[i][j]].push_back(i);
        }
    }
}

bool kosaraju(){
    bool result = dfs(1,front_vector);
    if(!result)
        return false;
    front_end();
    result = dfs(1,end_vector);
    if(!result)
        return false;
    return true;
}
int main()
{
    while(~scanf("%d%d",&n,&m)&&n+m){
        int tmp1,tmp2;
        for(int i=0;i<m;i++){
            scanf("%d%d",&tmp1,&tmp2);
            front_vector[tmp1].push_back(tmp2);
        }
        if(kosaraju())
            printf("Yes\n");
        else
            printf("No\n");
        for(int i=0;i<=n;i++){
            front_vector[i].clear();
            end_vector[i].clear();
        }
    }
    return 0;
}

这个题目运用tarjan并不是很通用的那种tarjan而是简化了的，所以不必当成模板，我会在博客中另写出模板，可以自行搜素，网上多的是。
tarjan是通过判断连通分支的数量完成题目。

#include <cstdio>
#include <vector>
#include <stack>


using namespace std;

const int N = 10005;

int n, m, timer;
vector<int> adj[N];
bool visit[N], mark;
int number[N], low[N];
stack<int> st;


int minx(int a, int b)
{
    if (a > b)return b;
    return a;
}


void tarjan(int rt)
{
    if (!mark)return; 
    number[rt] = low[rt] = ++timer;
    visit[rt] = true;
    for (unsigned i = 0; i < adj[rt].size(); ++i)
    {
        int t = adj[rt][i];
        if (!visit[t])
        {
            tarjan(t);
            low[rt] = minx(low[rt], low[t]);
        }
        low[rt] = minx(low[rt], number[adj[rt][i]]);
    }

    if (low[rt] == number[rt] && rt != 1)
    {
        mark = false;
    }
}

int main()
{
    int a, b;
    while (scanf("%d %d", &n, &m) != EOF && (m + n))
    {
        for (int i = 0; i < m; ++i)
        {
            scanf("%d %d", &a, &b);
            adj[a].push_back(b);
        } 
        memset(visit, 0, sizeof(visit));
        timer = 0;
        mark = true;
        tarjan(1);      
        if (mark && timer == n)
        {
            printf("Yes\n");
        }
        else
        {
            printf("No\n");
        }
        for (int i = 1; i <= n; ++i)
        {
            adj[i].clear();
        }       
    }
    return 0;
}