蓝桥杯_风险度量_dfs_无向图两节点间的所有路径

标题：风险度量

X星系的的防卫体系包含 n 个空间站。这 n 个空间站间有 m 条通信链路，构成通信网。
两个空间站间可能直接通信，也可能通过其它空间站中转。

对于两个站点x和y (x != y), 如果能找到一个站点z，使得：
当z被破坏后，x和y无法通信，则称z为关于x,y的关键站点。

显然，对于给定的两个站点，关于它们的关键点的个数越多，通信风险越大。

你的任务是：已知网络结构，求两站点之间的通信风险度，即：它们之间的关键点的个数。

输入数据第一行包含2个整数n(2 <= n <= 1000), m(0 <= m <= 2000),分别代表站点数，链路数。
空间站的编号从1到n。通信链路用其两端的站点编号表示。
接下来m行，每行两个整数 u,v (1 <= u, v <= n; u != v)代表一条链路。
最后1行，两个数u,v，代表被询问通信风险度的两个站点。

输出：一个整数，如果询问的两点不连通则输出-1.

例如：
用户输入：
7 6
1 3
2 3
3 4
3 5
4 5
5 6
1 6
则程序应该输出：
2

仔细看这道题，其实就是求两个节点间的所有路径，然后判断哪个节点是必不可少的。

示例中的路径有两条

1->3->4->5->6

1->3->5->6

看出3和5节点都是必不可少的，去掉3或者5后1->6无法联通。

那么用dfs求出所有路径，然后判断有多少节点出现次数跟起始节点一样多就可以了。

dfs思路大概是从起点开始搜索邻接矩阵中能访问的节点，若到达终点或者没有下一个节点可以访问就返回

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

 public class t3 {

     static int[][] graph;
     static int[] visit;
     static Stack<Integer> res = new Stack<Integer>();
     static ArrayList<Integer[]> temp = new ArrayList<Integer[]>();

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Scanner scanner = new Scanner(System.in);
         int n = scanner.nextInt();
         int m = scanner.nextInt();
         visit = new int[n];
         graph = new int[n][n];
         for (int i = 0; i < m; i++) {
             int t1 = scanner.nextInt();
             int t2 = scanner.nextInt();
             graph[t1 - 1][t2 - 1] = 1;
             graph[t2 - 1][t1 - 1] = 1;
         }
         int q1 = scanner.nextInt();
         int q2 = scanner.nextInt();
         dfs(q1 - 1, q2 - 1);
         int[] z = new int[n + 1];
         for (int i = 0; i < temp.size(); i++) {
             Integer[] t = temp.get(i);
             for (int j = 0; j < t.length; j++) {
                 z[t[j]]++;  //统计出现次数
             }
         }
         int fin = 0;
         for (int i = 0; i < z.length; i++) {
             if (z[i] == z[q1] && i != q1 && i != q2) {
                 fin++;
             }
         }
         System.out.println(fin);
     }

     public static void dfs(int n, int m) {
         res.push(n); // 当前节点入栈
         visit[n] = 1; // 设置访问位为1
         while (true) {
             if (n == m) { // 如果已经访问完毕，则输出
                 Integer[] t = new Integer[res.size()];
                 for (int i = 0; i < res.size(); i++) {
                     t[i] = res.get(i) + 1;
                 }
                 temp.add(t);
                 res.pop(); // 弹出顶层
                 visit[n] = 0; // 设置未访问
                 break;
             }
             for (int i = 0; i < graph.length; i++) {
                 if (graph[n][i] == 1) {
                     if (visit[i] == 0) {
                         dfs(i, m);
                     }
                 }
             }
             res.pop(); // 到这里说明到了边界，弹出当前位置
             visit[n] = 0; // 访问位重置
             break;
         }
     }

 }