数据结构-实验三 图型实验（java）

题目一：拯救007

在老电影“007之生死关头”（Live and Let Die）中有一个情节，007被毒贩抓到一个鳄鱼池中心的小岛上，他用了一种极为大胆的方法逃脱 —— 直接踩着池子里一系列鳄鱼的大脑袋跳上岸去！（据说当年替身演员被最后一条鳄鱼咬住了脚，幸好穿的是特别加厚的靴子才逃过一劫。）

设鳄鱼池是长宽为100米的方形，中心坐标为 (0, 0)，且东北角坐标为 (50, 50)。池心岛是以 (0, 0) 为圆心、直径15米的圆。给定池中分布的鳄鱼的坐标、以及007一次能跳跃的最大距离，你需要告诉他是否有可能逃出生天。

输入格式：

首先第一行给出两个正整数：鳄鱼数量 N（≤100）和007一次能跳跃的最大距离 D。随后 N 行，每行给出一条鳄鱼的 (x,y) 坐标。注意：不会有两条鳄鱼待在同一个点上。

输出格式：

如果007有可能逃脱，就在一行中输出"Yes"，否则输出"No"。

输入样例 1：

14 20

25 -15

-25 28

8 49

29 15

-35 -2

5 28

27 -29

-8 -28

-20 -35

-25 -20

-13 29

-30 15

-35 40

12 12

输出样例 1：

Yes

输入样例 2：

4 13

-12 12

12 12

-12 -12

12 -12

输出样例 2：

No

解题过程：

图解：

实现代码：

import java.util.Scanner; // 导入Scanner类，用于获取用户的输入

public class Main {
    // 内部类Point用于表示二维空间中的点
    static class Point {
        int x, y;
        Point(int x, int y) {
            this.x = x; // 构造函数，设置点的x坐标
            this.y = y; // 构造函数，设置点的y坐标
        }
    }

    // 定义静态变量
    static Point[] crocodiles; // 存储鳄鱼位置的数组
    static boolean[] visited; // 标记每个鳄鱼是否被访问过的数组
    static int n, d; // n是鳄鱼的数量，d是007一次能跳跃的最大距离
    static boolean flag = false; // 标记是否找到逃脱路径的布尔变量

    // 判断一个点是否能成功到达岸边
    static boolean canReachShore(Point p) {
        // 如果点的x坐标或y坐标超出了边界，则表示已经到达岸边
        return (p.x - d <= -50) || (p.x + d >= 50) || (p.y - d <= -50) || (p.y + d >= 50);
    }

    // 判断从中心岛出发的第一步是否有效
    static boolean isFirstStepValid(Point p) {
        // 计算点到原点的距离的平方，并与最大跳跃距离加中心岛半径的平方进行比较
        int p1 = p.x * p.x;
        int p2 = p.y * p.y;
        int r = (d + 7) * (d + 7);
        return p1 + p2 <= r;
    }

    // 判断从一个鳄鱼头跳到另一个鳄鱼头是否可能
    static boolean canJump(Point a, Point b) {
        // 计算两个点之间的距离的平方，并与最大跳跃距离的平方进行比较
        int p1 = (a.x - b.x) * (a.x - b.x);
        int p2 = (a.y - b.y) * (a.y - b.y);
        int r = d * d;
        return p1 + p2 <= r;
    }

    // 深度优先搜索算法
    static void dfs(int t) {
        visited[t] = true; // 标记当前鳄鱼位置已访问
        if (canReachShore(crocodiles[t])) {
            flag = true; // 如果当前位置能到达岸边，设置标记为真
        }
        // 遍历所有鳄鱼位置，如果未访问且可以跳跃，则递归调用dfs
        for (int i = 0; i < n; i++) {
            if (!visited[i] && canJump(crocodiles[t], crocodiles[i])) {
                dfs(i);
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建Scanner对象用于读取输入
        n = scanner.nextInt(); // 读取鳄鱼的数量
        d = scanner.nextInt(); // 读取一次能跳跃的最大距离
        crocodiles = new Point[n]; // 初始化鳄鱼位置数组
        visited = new boolean[n]; // 初始化访问标记数组

        // 读取每个鳄鱼的位置
        for (int i = 0; i < n; i++) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            crocodiles[i] = new Point(x, y);
        }
        scanner.close(); // 关闭Scanner对象

        // 如果跳跃距离足够大，007可以直接到达岸边
        if (d >= 42.5) {
            System.out.println("Yes");
        } else {
            // 否则，从每个有效的初始位置开始DFS搜索
            for (int i = 0; i < n; i++) {
                // 如果鳄鱼位置是有效的初始位置，则开始深度优先搜索
                if (!visited[i] && isFirstStepValid(crocodiles[i])) {
                    dfs(i);
                }
            }
            // 如果在任何时候找到了逃脱路径，则输出"Yes"；否则输出"No"
            if (flag) {
                System.out.println("Yes");
            } else {
                System.out.println("No");
            }
        }
    }
}

运行结果：

题目二：哈利·波特的考试 

2、哈利·波特要考试了，他需要你的帮助。这门课学的是用魔咒将一种动物变成另一种动物的本事。例如将猫变成老鼠的魔咒是haha，将老鼠变成鱼的魔咒是hehe等等。反方向变化的魔咒就是简单地将原来的魔咒倒过来念，例如ahah可以将老鼠变成猫。另外，如果想把猫变成鱼，可以通过念一个直接魔咒lalala，也可以将猫变老鼠、老鼠变鱼的魔咒连起来念：hahahehe。

现在哈利·波特的手里有一本教材，里面列出了所有的变形魔咒和能变的动物。老师允许他自己带一只动物去考场，要考察他把这只动物变成任意一只指定动物的本事。于是他来问你：带什么动物去可以让最难变的那种动物（即该动物变为哈利·波特自己带去的动物所需要的魔咒最长）需要的魔咒最短？例如：如果只有猫、鼠、鱼，则显然哈利·波特应该带鼠去，因为鼠变成另外两种动物都只需要念4个字符；而如果带猫去，则至少需要念6个字符才能把猫变成鱼；同理，带鱼去也不是最好的选择。

输入格式:

输入说明：输入第1行给出两个正整数N (≤100)和M，其中N是考试涉及的动物总数，M是用于直接变形的魔咒条数。为简单起见，我们将动物按1~N编号。随后M行，每行给出了3个正整数，分别是两种动物的编号、以及它们之间变形需要的魔咒的长度(≤100)，数字之间用空格分隔。

输出格式:

输出哈利·波特应该带去考场的动物的编号、以及最长的变形魔咒的长度，中间以空格分隔。如果只带1只动物是不可能完成所有变形要求的，则输出0。如果有若干只动物都可以备选，则输出编号最小的那只。

输入样例:

6 11

3 4 70

1 2 1

5 4 50

2 6 50

5 6 60

1 3 70

4 6 60

3 6 80

5 1 100

2 4 60

5 2 80

输出样例:

4 70

解题过程：

图解：

代码实现：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        StringTokenizer st = new StringTokenizer(br.readLine());
        // 读取动物的数量N和魔咒的数量M
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());
        // 初始化一个二维数组来存储每对动物之间的最短距离
        int[][] dist = new int[N + 1][N + 1];
        int INF = 1_000_000_000; // 一个足够大的值，但不会导致整数溢出
        for (int i = 1; i <= N; i++) {
            Arrays.fill(dist[i], INF);
            dist[i][i] = 0;
        }
        // 读取每个魔咒，并更新相应的距离
        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            int d = Integer.parseInt(st.nextToken());
            dist[a][b] = dist[b][a] = d;
        }
        // 使用Floyd算法来找出所有对动物之间的最短距离
        for (int k = 1; k <= N; k++) {
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    if (dist[i][k] != INF && dist[k][j] != INF) {
                        dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
                    }
                }
            }
        }
        // 找出哈利·波特应该带去考场的动物和最长的变形魔咒的长度
        int minAnimal = 0;
        int minDist = INF;
        for (int i = 1; i <= N; i++) {
            int maxDist = 0;
            for (int j = 1; j <= N; j++) {
                if (i != j && dist[i][j] == INF) {
                    maxDist = INF;
                    break;
                }
                maxDist = Math.max(maxDist, dist[i][j]);
            }
            if (maxDist < minDist) {
                minDist = maxDist;
                minAnimal = i;
            }
        }
        // 如果没有动物可以带到考场，就输出0
        if (minDist == INF) {
            pw.println("0");
        } else {
            // 否则，输出带到考场的动物的编号和最长的变形魔咒的长度
            pw.println(minAnimal + " " + minDist);
        }
        pw.flush();
    }
}

运行结果：