历届试题 危险系数

@ 蓝桥杯 练习系统 历届试题 PREV-12

资源限制

时间限制：1.0s 内存限制：256.0MB

---

问题描述

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

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

我们来定义一个危险系数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.

---

测试样例

in: 
7 6
1 3
2 3
3 4
3 5
4 5
5 6
1 6

out:
2

---

AC code：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class Main {

    static int pi, cnt;
    static int[] mark, path;
    static boolean[] marked;
    static List<Integer>[] graph;

    public static void main(String[] args) throws IOException {
        InputReader in = new InputReader(System.in, " ");
        int n = in.nextInt() + 1, m = in.nextInt(), x, y;
        marked = new boolean[n];
        graph = new List[n];
        mark = new int[n];
        path = new int[n];
        for (int i = 1; i < n; i++)
            graph[i] = new ArrayList();
        while (m-- > 0) {
            x = in.nextInt();
            y = in.nextInt();
            graph[x].add(y);
            graph[y].add(x);
        }
        dfs(in.nextInt(), in.nextInt());
        if (cnt == 0) System.out.print(-1);
        else {
            int sum = -1;
            for (int i = 1; i < n; i++)
                if (mark[i] == cnt) sum++;
            System.out.print(sum);
        }
    }

    static void dfs(int start, int end) {
        if (start == end) {
            for (int i = 0; i < pi; i++)
                mark[path[i]]++;
            cnt++;
        } else {
            marked[start] = true;
            int now = pi++;
            for (int v: graph[start]) {
                if (marked[v]) continue;
                path[now] = v;
                dfs(v, end);
            }
            pi = now;
            marked[start] = false;
        }
    }

    static class InputReader {

        BufferedReader read;
        StringTokenizer tok;
        String delimiters;

        InputReader(InputStream in) { this(in, " \n\t\r\f"); }

        InputReader(InputStream in, String delimiters) {
            this.read = new BufferedReader(new InputStreamReader(in));
            this.tok = new StringTokenizer("", this.delimiters = delimiters);
        }

        String next() {
            while (!tok.hasMoreTokens())
                try {
                    tok = new StringTokenizer(read.readLine(), delimiters);
                } catch (IOException e) { }
            return tok.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }
    }
}

记录出连通路径各点出现的次数，如果等于路径数，既关键点

---

当然也可以嗯枚举，就嗯

ACcode：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class Main {

    static boolean[] marked;
    static List<Integer>[] graph;

    public static void main(String[] args) throws IOException {
        InputReader in = new InputReader(System.in, " ");
        int n = in.nextInt() + 1, m = in.nextInt(), cnt = 0, x, y;
        marked = new boolean[n];
        graph = new List[n];
        for (int i = 1; i < n; i++)
            graph[i] = new ArrayList();
        while (m-- > 0) {
            x = in.nextInt();
            y = in.nextInt();
            graph[x].add(y);
            graph[y].add(x);
        }
        x = in.nextInt(); y = in.nextInt();
        for (int i = 1; i < n; i++) {
            if (i == x || i == y) continue;
            marked[i] = true;
            if (!dfs(x, y)) cnt++;
            marked[i] = false;
        }
        if (cnt == 0) System.out.print(-1);
        else System.out.print(cnt);
    }

    static boolean dfs(int start, int end) {
        boolean res = false;
        if (start == end) return true;
        else {
            marked[start] = true;
            for (int v: graph[start]) {
                if (marked[v]) continue;
                res |= dfs(v, end);
            }
            marked[start] = false;
        }
        return res;
    }

    static class InputReader {

        BufferedReader read;
        StringTokenizer tok;
        String delimiters;

        InputReader(InputStream in) { this(in, " \n\t\r\f"); }

        InputReader(InputStream in, String delimiters) {
            this.read = new BufferedReader(new InputStreamReader(in));
            this.tok = new StringTokenizer("", this.delimiters = delimiters);
        }

        String next() {
            while (!tok.hasMoreTokens())
                try {
                    tok = new StringTokenizer(read.readLine(), delimiters);
                } catch (IOException e) { }
            return tok.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }
    }
}

做了裁剪后没跑出来，就这样吧