【CCF】tarjan算法-求强联通分量例题

问题描述

试题编号： 201509-4
试题名称： 高速公路
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
　　某国有n个城市，为了使得城市间的交通更便利，该国国王打算在城市之间修一些高速公路，由于经费限制，国王打算第一阶段先在部分城市之间修一些单向的高速公路。
　　现在，大臣们帮国王拟了一个修高速公路的计划。看了计划后，国王发现，有些城市之间可以通过高速公路直接（不经过其他城市）或间接（经过一个或多个其他城市）到达，而有的却不能。如果城市A可以通过高速公路到达城市B，而且城市B也可以通过高速公路到达城市A，则这两个城市被称为便利城市对。
　　国王想知道，在大臣们给他的计划中，有多少个便利城市对。
输入格式
　　输入的第一行包含两个整数n, m，分别表示城市和单向高速公路的数量。
　　接下来m行，每行两个整数a, b，表示城市a有一条单向的高速公路连向城市b。
输出格式
　　输出一行，包含一个整数，表示便利城市对的数量。
样例输入
5 5
1 2
2 3
3 4
4 2
3 5
样例输出
3
样例说明

城市间的连接如图所示。有3个便利城市对，它们分别是(2, 3), (2, 4), (3, 4)，请注意(2, 3)和(3, 2)看成同一个便利城市对。
评测用例规模与约定
　　前30%的评测用例满足1 ≤ n ≤ 100, 1 ≤ m ≤ 1000；
　　前60%的评测用例满足1 ≤ n ≤ 1000, 1 ≤ m ≤ 10000；
　　所有评测用例满足1 ≤ n ≤ 10000, 1 ≤ m ≤ 100000。

---

题解

使用 tarjan 算法求出每一个强联通分量，然后根据题意计算求解。详情见代码注释！（tarjan 算法原理自行查阅，不难理解）

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
	方法：本质是求强连通分量，可以使用tarjan算法求出每一个强连通分量，之后再计算“便利城市对”

	tarjan算法：遍历每一个没有遍历过的节点，设置dfn和low数组分别记录遍历的时间点和最近父节点。
			之后遍历它能够到达的节点，并更新low数组；或当到达节点在栈中时直接更新low数组
			最后，若当前点low和dfn一样，表示没有其他点与其是强联通分量了，接着找出之前的所有强联通分量点
 *
 */
public class csp_2015_09_4 {
	
	static int ans = 0;
	static int time = 1;
	
	public static void main(String[] args) throws IOException {
		StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		
		in.nextToken();
		int n = (int) in.nval;
		in.nextToken();
		int m = (int) in.nval;
		
		List<Integer>[] map = new ArrayList[n + 5];
		for (int i = 0; i <= n; i ++) {
			map[i] = new ArrayList<Integer>();
		}
		
		for (int i = 0; i < m; i ++) {
			in.nextToken();
			int u = (int) in.nval;
			in.nextToken();
			int v = (int) in.nval;
			
			map[u].add(v);
		}
		
		tarjan(map, n);
		
		System.out.println(ans);
	}
	
	private static void tarjan(List<Integer>[] map, int n) {
		int[] dfn = new int[n + 5];  // 记录遍历的时间点
		int[] low = new int[n + 5];  // 记录最近可返回的父节点
		Stack<Integer> stack = new Stack<>();
		
		for (int i = 1; i <= n; i ++) {
			if (dfn[i] == 0) { // 没有被遍历时
				tarjanDfs(i, dfn, low, n, stack, map);
			}
		}
	}

	private static void tarjanDfs(int x, int[] dfn, int[] low, int n,
								Stack<Integer> stack, List<Integer>[] map) {
		dfn[x] = low[x] = time ++;
		stack.push(x);
		
		int num = map[x].size();
		for (int i = 0; i < num; i ++) {  // 遍历x可达的所有节点
			int y = map[x].get(i);
			if (dfn[y] == 0) {  // 没有被遍历时
				tarjanDfs(y, dfn, low, n, stack, map);
				low[x] = Math.min(low[x], low[y]);
			} else if (stack.contains(y)) {  // 当y在栈中时
				low[x] = Math.min(low[x], dfn[y]);
			}
		}
		
		if (dfn[x] == low[x]) {  // 若一样，表示自己本身就是一个强连通分量（可能包含其他节点一起）
			int k;
			int sum = 0;
			do {
				k = stack.pop();
				sum ++;
			} while (k != x);  // 找到跟x同一个强连通分量
			
			ans += (sum * (sum - 1) / 2);
		}
	}

}

更多CCF题目代码可参考：https://github.com/dhwgithub/CCF-CSP-Recording