重要城市（图的dfs）

 

解题思路 ：

        x：正向（i -> 方向）遍历i点得到的城市数目；

        y：反向（-> i 方向）遍历i点得到的城市数目；

       遍历城市数目：dfs非递归遍历，入栈的节点个数

代码实现：

import java.util.Scanner;
import java.util.Stack;

public class Main{
	
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
    	int n = in.nextInt();//城市数
    	int m = in.nextInt();//边数
    	int[][] adjArr = new int[n][n];
    	int[][] adjArrR = new int[n][n];
    	int p,q;
    	for (int i = 0; i < m; i++) {
    		p = in.nextInt()-1;
    		q = in.nextInt()-1;
    		adjArr[p][q] = 1; 
    		adjArrR[q][p] = 1; //反向矩阵，计算y
    	}
    	
    	
    	int count = 0;
    	for (int i = 0; i < n; i++) {
			if(dfs(adjArrR, i) > dfs(adjArr, i))
				count++;
		}
		System.out.println(count);
	}
	
	/**
	 * 
	 * @param a 
	 * @param start 开始索引位置
	 * @return 以节点start为起点遍历邻接矩阵a，遍历的节点个数
	 */
	private static int dfs(int[][] a,int start) {
		int[] depth = new int[a[0].length];
		depth[start] = 1;
		int i = start;//当前节点中间变量 
		int t = 0; //下一节点中间变量 
		int count = 1;
		Stack<Integer> s = new Stack<Integer>();
		while(true) {
			t = hasNext(a, i, depth);
			if (t != -1) {
				s.add(i);
				count++;
				i = t;
			}
			else {
				if(s.empty())
					break;
				i = s.pop();
			}
		}
		return count;
	}
    /**
	 * 判断邻接图a中，i是否存在下一节点
	 * @param a
	 * @param i
	 * @param depth 辅助矩阵：当前遍历过程中的深度矩阵
	 * @return 下一节点索引；没有返回-1
	 */
	private static int hasNext(int[][] a, int i, int[] depth) {
		for (int j = 0; j < depth.length; j++) {
			if(j!=i && a[i][j]==1 && depth[j] == 0) {
				depth[j] = depth[i]+1;
				return j;
			}
		}
		return -1;
	}
    
}