信息学奥赛一本通 1383：刻录光盘(cdrom) | 洛谷 P2835 刻录光盘

【题目链接】

ybt 1383：刻录光盘(cdrom)
洛谷 P2835 刻录光盘

【题目考点】

1. 图论：强连通分量

【解题思路】

首先对该问题进行抽象，每个人是一个顶点，如果A愿意把资料拷给B，那么存在有向边<A, B>，这是一个有向图。
资料分发的过程类似于深搜，如果一个顶点出发进行深搜，那么该顶点所在强连通分量中的顶点都会被访问到。即如果一个人收到资料，那么该人对应的顶点所在强连通分量中的所有顶点所表示的人都会收到资料。
将该图缩点，每个顶点代表一个强连通分量，求出每个强连通分量的入度。

• 入度为0的强连通分量无法从他处获得资料，必须由组委会把光盘给这个强连通分量中的某个人，该强连通分量中的所有人才能获得资料。
• 入度大于0的强连通分量可以从其它强连通分量处获得资料。

因此发放光盘的数量，就是将该图缩点后，入度为0的强连通分量的数量。

求强连通分量可以使用

• Kosaraju算法
• Tarjan算法
• Floyd算法求传递闭包
  传递闭包为一个二维数组path，如果path[i][j]为真，则从i到j有一条路径。配合并查集，将i到j与j到i都有路径的顶点合成一个集合，每个集合为一个强连通分量。

解法1：Kosaraju算法

解法2：Tarjan算法

两种算法都是先求强连通分量，而后求每个强连通分量的入度，统计入度为0的强连通分量的数量即为需要分发的光盘数量。
判断一条边<u, v>是缩点后图中边的方法：原图中有<u, v>这条边，且u, v不在一个强连通分量中。
而后v所在的强连通分量的入度增加1。
这两种算法的复杂度为：$O(V+E)$

解法3：Floyd算法求传递闭包+并查集

先使用Floyd算法求传递闭包，得到path数组。
设并查集，每个集合表示图中的一棵子树，该子树有唯一的入度为0的根结点。
遍历每条边，如果i到j有路径，那么将j的双亲设为i所在集合的根结点。这样做即使有环，环上顶点形成的树只有一个根结点。
最后统计树的数量，即为入度为0的强连通分量的数目。
该算法的复杂度为：$O(V^3)$

【题解代码】

解法1：Kosaraju算法

#include <bits/stdc++.h>
using namespace std;
#define N 205
int n;
vector<int> g[N], rg[N];//g:原图 rg:反图 
bool vis[N];
int scc[N], sn;//scc[i]：顶点i所属的强连通分量 
int degIn[N];//deg[i]：编号为i的强连通分量的入度 
stack<int> stk;
void dfs_rg(int u)
{
	for(int v : rg[u])
	{
		if(vis[v] == false)
		{
			vis[v] = true;
			dfs_rg(v);
			stk.push(v);
		}
	}
}
void dfs_g(int u)
{
	for(int v : g[u])
	{
		if(vis[v] == false)
		{
			vis[v] = true;
			scc[v] = sn;
			dfs_g(v);
		}
	}
}
void kosaraju()
{
	for(int u = 1; u <= n; ++u)
	{
		if(vis[u] == false)
		{
			vis[u] = true;
			dfs_rg(u);
			stk.push(u);
		}
	}
	memset(vis, 0, sizeof(vis));
	while(stk.empty() == false)
	{
		int u = stk.top();
		stk.pop();
		if(vis[u] == false)
		{
			vis[u] = true;
			scc[u] = ++sn;
			dfs_g(u);
		}
	}
}
int main()
{
	int t, ct = 0;
   	cin >> n;
   	for(int f = 1; f <= n; ++f)
   	{
   		while(cin >> t && t != 0)
   		{
   			g[f].push_back(t);
   			rg[t].push_back(f);
		}
	}
	kosaraju();
	for(int u = 1; u <= n; ++u)
		for(int v : g[u])
			if(scc[u] != scc[v])
				degIn[scc[v]]++;	
	for(int i = 1; i <= sn; ++i)
		if(degIn[i] == 0)
			ct++;
    cout << ct;
	return 0;
}

解法2：Tarjan算法

#include <bits/stdc++.h>
using namespace std;
#define N 205
vector<int> edge[N];
int dfn[N], low[N], ts;//dfn[i]：顶点i的时间戳 low[i]：顶点i通过有向边能回溯到的最早时间戳 ts：时间戳 
int n, scc[N], sn, degIn[N];//scc[i]：顶点i所属的强连通分量 degIn[i]：强连通分量i的入度 
stack<int> stk;
bool inStk[N];//顶点i是否在栈中 
void tarjan(int u)
{
	int t;
	dfn[u] = low[u] = ++ts;
	stk.push(u);
	inStk[u] = true;
	for(int v : edge[u])
	{
		if(dfn[v] == 0)
		{
			tarjan(v);
			low[u] = min(low[u], low[v]);
		}
		else if(inStk[v])
			low[u] = min(low[u], low[v]);//或low[u] = min(low[u], dfn[v]);
	}
	if(dfn[u] == low[u])
	{
		++sn;
		do
		{
			t = stk.top();
			stk.pop();
			scc[t] = sn;
			inStk[t] = false;
		}while(t != u);
	}
}
int main()
{
	int t, ct = 0;
   	cin >> n;
   	for(int f = 1; f <= n; ++f)
   		while(cin >> t && t != 0)
   			edge[f].push_back(t);
	for(int v = 1; v <= n; ++v)
		if(dfn[v] == 0)
			tarjan(v);
	for(int u = 1; u <= n; ++u)
		for(int v : edge[u])
			if(scc[u] != scc[v])
				degIn[scc[v]]++;
	for(int i = 1; i <= sn; ++i)
		if(degIn[i] == 0)
			ct++;
    cout << ct;
	return 0;
}

解法3：Floyd求传递闭包+并查集

#include <bits/stdc++.h>
using namespace std;
#define N 205
int n, edge[N][N], path[N][N];//path[i][j]：i到j有路径为1，否则为0 
int fa[N];//并查集 
void init(int n)
{
	for(int i = 1; i <= n; ++i)
		fa[i] = i;
}
int find(int x)
{
	return x == fa[x] ? x : fa[x] = find(fa[x]);
}

void floyd()//floyd求传递闭包（path数组） 
{
	memcpy(path, edge, sizeof(edge));//先让path与edge相同 
	for(int k = 1; k <= n; ++k)
		for(int i = 1; i <= n; ++i)
			for(int j = 1; j <= n; ++j)
				path[i][j] = path[i][j] || path[i][k] && path[k][j];
}
int main()
{
	int j, ct = 0;
   	cin >> n;
   	init(n);//初始化并查集 
	for(int i = 1; i <= n; ++i)
		while(cin >> j && j != 0)
			edge[i][j] = 1;
	floyd();
	for(int i = 1; i <= n; ++i)//起始顶点i 
		for(int j = 1; j <= n; ++j)//到达顶点j 
			if(path[i][j])//如果i到j有路径，就把树的双亲表示法fa中j的双亲设为i所在的树的根结点。
				fa[j] = find(i);//这样即使有环，环上顶点形成的树只有一个根 
	for(int i = 1; i <= n; ++i)
		if(find(i) == i)//统计树的数量，就是入度为0的强连通分量的数目 
			ct++;
	cout << ct;
	return 0;
}