题目:http://poj.org/problem?id=2186
题意:有N(N<=10000)头牛,每头牛都想成为most poluler的牛,给出M(M<=50000)个关系,如(1,2)代表1欢迎2,关系可以传递,但是不可以相互,即1欢迎2不代表2欢迎1,但是如果2也欢迎3那么1也欢迎3.给出N,M和M个欢迎关系,求被所有牛都欢迎的牛的数量。
思路:用强连通分量分解,分解后判断图是不是连通图,不是连通图,答案为0,若是连通图,定有一个强连通分量内所有的点是满足要求的。关于连通图的判断,用tarjan算法时,统计出度0的强连通分量个数,为1时有解,即出度为0的强连通分量,大于1无解。用kosaraju算法时,若有解,则定是拓扑序最后的强连通分量,直接从拓扑序最后的强连通分量内任意一点用rdfs函数搜索一遍图,若图连通,则所有点都能被访问到。这道题我用tarjan和kosaraju各做了一遍,下面是tarjan算法和kosaraju算法代码
tarjan算法
Tarjan算法是基于对图深度优先搜索的算法,每个强连通分量为搜索树中的一棵子树。搜索时,把当前搜索树中未处理的节点加入一个堆栈,回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。
DFN(u)为节点u搜索的次序编号(时间戳),Low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号
当DFN(u)=Low(u)时,以u为根的搜索子树上所有节点是一个强连通分量
运行Tarjan算法的过程中,每个顶点都被访问了一次,且只进出了一次堆栈,每条边也只被访问了一次,所以该算法的时间复杂度为O(N+M)
#include <iostream>
#include <cstdio>
#include <stack>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 10010;
vector<int> G[N];
stack<int> st;
bool vis[N];
int dfn[N], low[N], scc[N]; /*scc数组记录每个点所属的强连通分量*/
int outdegree[N], ans[N];/*outdegree数组记录强连通分量的出度,ans数组记录每个强连通分量内的点数*/
int index, cnt; /*cnt是当前强连通分量的编号*/
int n, m;
void tarjan(int v)
{
int u;
dfn[v] = low[v] = index++; /*开始时dfn[v] == low[v]*/
vis[v] = true;
st.push(v);
for(int i = 0; i < G[v].size(); i++)
{
u = G[v][i];
if(dfn[u] == -1) /*如果v点还未遍历,向下遍历,同时确保low[v]最小*/
{
tarjan(u);
low[v] = min(low[v], low[u]);
}
else if(vis[u]) /*v在栈中,修改low[v]*/
low[v] = min(low[v], dfn[u]);
}
if(dfn[v] == low[v]) /*v为该强连通分量中遍历所成树的根*/
{
cnt++;
do
{ /*栈中所有到v的点都属于该强连通分量,退栈*/
u = st.top(); st.pop();
vis[u] = false;
scc[u] = cnt;
ans[cnt]++;
}while(u != v);
}
}
void slove()
{
memset(dfn, -1, sizeof dfn);
memset(vis, 0, sizeof vis);
memset(ans, 0, sizeof ans);
for(int i = 1; i <= n; i++)
if(dfn[i] == -1) /*可能不是连通图,所以要逐个扫描*/
tarjan(i);
}
int main()
{
int a, b;
while(~ scanf("%d%d", &n, &m))
{
index = 0;
cnt = 0;
for(int i = 0; i < m; i++)
{
scanf("%d%d", &a, &b);
G[a].push_back(b);
}
slove();
memset(outdegree, 0, sizeof outdegree);
for(int i = 1; i <= n; i++)
for(int j = 0; j < G[i].size(); j++)
if(scc[i] != scc[G[i][j]])
outdegree[scc[i]] = 1;
int tmp = 0, f;
for(int i = 1; i <= cnt; i++)
{
if(outdegree[i] == 0)
{
tmp++;
f = i;
}
}
if(tmp == 1) printf("%d\n", ans[f]);
else printf("0\n");
}
return 0;
}
kosaraju算法
复杂度也是O(N+M)
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <cmath>
#include <queue>
#include <functional>
#include <map>
#include <string>
using namespace std;
const int N = 10100;
int n, m;
vector <int> G[N];
vector <int> RG[N];
vector <int> vs;
bool used[N];
int cmp[N];
void add_edge(int from, int to)
{
G[from].push_back(to);
RG[to].push_back(from); /*反向图*/
}
void dfs(int v)
{
used[v] = true;
for(int i = 0; i < G[v].size(); i++)
if(! used[G[v][i]])
dfs(G[v][i]);
vs.push_back(v);/*vs数组从后往前是拓扑序*/
}
void rdfs(int v, int k)
{
used[v] = true;
cmp[v] = k;
for(int i = 0; i < RG[v].size(); i++)
if(! used[RG[v][i]])
rdfs(RG[v][i], k);
}
int kosaraju()
{
memset(used, 0, sizeof used);
vs.clear();
for(int i = 1; i <= n; i++)
if(! used[i])
dfs(i);
memset(used, 0, sizeof used);
int k = 0;
for(int i = vs.size() - 1; i >= 0; i--)
if(! used[vs[i]])
rdfs(vs[i], k++);
return k;
}
int main()
{
int a, b;
while(~ scanf("%d%d", &n, &m))
{
for(int i = 0; i < m; i++)
{
scanf("%d%d", &a, &b);
add_edge(a, b);
}
int cnt = scc() - 1, v, num = 0;
for(int i = 1; i <= n; i++)
if(cmp[i] == cnt)
v = i, num++;
memset(used, 0, sizeof used);
rdfs(v, 0);
for(int i = 1; i <= n; i++)
if(! used[i])
{
num = 0; break;
}
printf("%d\n", num);
}
return 0;
}