java实现第四届蓝桥杯危险系数

危险系数

抗日战争时期，冀中平原的地道战曾发挥重要作用。

地道的多个站点间有通道连接，形成了庞大的网络。但也有隐患，当敌人发现了某个站点后，其它站点间可能因此会失去联系。

我们来定义一个危险系数DF(x,y)：

对于两个站点x和y (x != y), 如果能找到一个站点z，当z被敌人破坏后，x和y不连通，那么我们称z为关于x,y的关键点。相应的，对于任意一对站点x和y，危险系数DF(x,y)就表示为这两点之间的关键点个数。

本题的任务是：已知网络结构，求两站点之间的危险系数。

输入数据第一行包含2个整数n(2 <= n <= 1000), m(0 <= m <= 2000),分别代表站点数，通道数；

接下来m行，每行两个整数 u,v (1 <= u, v <= n; u != v)代表一条通道；

最后1行，两个数u,v，代表询问两点之间的危险系数DF(u, v)。

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

例如：

用户输入：

7 6

1 3

2 3

3 4

3 5

4 5

5 6

1 6

则程序应该输出：

2

资源约定：

峰值内存消耗（含虚拟机） < 64M

CPU消耗 < 2000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意：不要使用package语句。不要使用jdk1.6及以上版本的特性。

注意：主类的名字必须是：Main，否则按无效代码处理。

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

public class Main {
    public static int n, m, start, end;
    public static ArrayList<Integer>[] map;
    public static int count, root;
    public static int[] DFN;
    public static int[] Low;
    public static int[] Parent;
    public ArrayList<Integer> point;

    public void init() {
        count = 0;
        root = 1;
        DFN = new int[n + 1];
        Low = new int[n + 1];
        Parent = new int[n + 1];
        point = new ArrayList<Integer>();
        for(int i = 1;i <= n;i++) {
            DFN[i] = -1;
            Low[i] = -1;
            Parent[i] = -1;
        }
    }

    public void TarJan(int begin, int parent) {
        DFN[begin] = ++count;
        Low[begin] = DFN[begin];
        Parent[begin] = parent;
        int Childern = 0;
        for(int i = 0;i < map[begin].size();i++) {
            int j = map[begin].get(i);
            if(DFN[j] == -1) {
                Childern++;
                TarJan(j, begin);
                Low[begin] = Math.min(Low[begin], Low[j]);
                if(begin == root && Childern > 1) {
                    if(!point.contains(begin))
                        point.add(begin);
                } else if(begin != root && Low[j] >= DFN[begin]) {
                    if(!point.contains(begin))
                        point.add(begin);
                }
            } else if(j != Parent[begin]) {
                Low[begin] = Math.min(Low[begin], DFN[j]);
            }
        }
    } 

    public void dfs(int begin, boolean[] visited) {
        visited[begin] = true;
        for(int i = 0;i < map[begin].size();i++) {
            int j = map[begin].get(i);
            if(visited[j] == false)
                dfs(j, visited);
        }
    }

    public void getResult() {
        boolean[] visited = new boolean[n + 1];
        dfs(start, visited);
        if(visited[end] == false) {
            System.out.println("-1");
            return;
        }
        init();
        TarJan(1, 0);
        int count = 0;
        for(int i = 0;i < point.size();i++) {
            int j = point.get(i);
            if(j != start && j != end) {
                visited = new boolean[n + 1];
                visited[j] = true;
                dfs(start, visited);
                if(visited[end] == false)
                    count++;
            }
        }
        System.out.println(count);
    }

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        Main test = new Main();
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        map = new ArrayList[n + 1];
        for(int i = 1;i <= n;i++)
            map[i] = new ArrayList<Integer>();
        for(int i = 1;i <= m;i++) {
            int u = in.nextInt();
            int v = in.nextInt();
            map[u].add(v);
            map[v].add(u);
        }
        start = in.nextInt();
        end = in.nextInt();
        test.getResult();
    }
}