48天笔试训练错题—

48天笔试训练错题——day42

news2024/11/13 12:13:16

选择题

10.

编程题

1. 走迷宫

选择题

1.

动态分配：使用 DHCP 协议动态分配 IP。

IP 地址不但有单播地址，多播地址，还有广播地址。

如果一个主机有块个网卡，那么每块网卡都可以拥有 IP 地址。

ARP 协议就是根据 IP 地址来获取 MAC 地址的。

2.

bind 函数是不会阻塞执行流的。

3.

10.1.193.0：10100000.00000001.11000001.00000000

10.1.194.0：10100000.00000001.11000010.00000000

10.1.196.0：10100000.00000001.11000100.00000000

10.1.198.0：10100000.00000001.11000110.00000000

如上，前 21 位都是相同的，则路由汇聚之后，可以将前 21 位作为网络号，剩下 11 位(全部设置为 0)作为主机号，则 IP 地址为 10.1.192.0/21。/21 表示网络号有 21 位(在子网掩码中前 21 位是 1)

4.

IP 地址有可能会变，但是 MAC 地址不会改变，因为 MAC 地址绑定了网卡，全球唯一。

5.

服务器在收到 SYN 包时将加入半连接队列，这个对应到三次握手过程中，TCP 连接处于半连接状态。

服务器收到客户端的 ACK 包后将从半连接队列删除：当连接建立之后，TCP 连接则从半连接队列移动到已完成连接队列，这个时候，程序员就可以调用 accept 函数从已完成连接队列当中将连接取到。

6.

ping 是基于 ICMP 协议的。

7.

还需要被动连接方也断开连接，这个就是四次挥手的过程。

因为需要维护连接，例如长时间没有应用层数据的收发，此时，TCP 就需要用保活机制(心跳机制)来维护连接，所以会增加开销。

8.

40.15.128.0/17：00101000.11110000.10000000.00000000 前 17 位为网络号

划分了 2 个子网，则说明多了 1 位网络号(2^1 = 2)，所以子网的网络号应该是 18 位。

40.15.128.0/18：00101000.11110000.10000000.00000000 前 18 位为网络号

比原来多了 1 位，增加了 2 ^ 1 个子网，因为其中一个子网的第 18 位是 0，那么另一个子网的第 18 位可以是 1，可以用 0 和 1 来区分子网。

则第二个子网是 00101000.11110000.11000000.00000000 前 18 位为网络号，也就是 40.15.192.0/18

9.

host 文件是一个没有扩展名的系统文件，其作用就是用来存储一些常用的网络域名与其对应的 IP 地址，当用户输入一个需要登录的网址时，系统就会先去浏览器缓存中查找，然后再去 host 文件中查找，如果找到了就立即打开该网址，如果找不到就去 DNS 域名解析服务器中查找。

10.

32 - 28 = 4 位主机号，则有 2^4 = 16 个主机，范围如下：

10.174.20.1011 0000(176) ~ 10.174.20.1011 1111(191)，除去全 0 和全 1，可用的有 14 个。

编程题

1. 走迷宫

这种找所有迷宫路线最短的题目可以使用广度优先遍历来做。

广度优先遍历就跟二叉树的层序遍历差不多，也是用队列来实现，如果队列不为空，则从队列中弹出一个节点，然后标记该节点表示这个节点已经遍历过了，此时该节点可能就是出口，所以我们还需要判断该节点是否是出口，如果是，则返回当前最短路径的步数。如果不是，就再遍历该节点的四个方向(下右左上) ，如果当前遍历的节点是合法的节点(数组没越界)，并且是没有遍历过的节点，而且该节点还是通路(.)，那么就将该节点入队，重复上述过程直到队列为空，如果队列为空还没到达过出口，则说明这个迷宫到达不了出口，返回 -1 即可。

可以自己定义个对象来存放坐标，再新定义一个成员变量来表示从入口到该坐标的步数。

广度优先遍历最先达到出口的一条路径就是最短路径。

代码实现：

import java.util.*;

class Position {
    public int x;
    public int y;
    public int count;// 表示从入口走到 (x, y) 所需要的步数

    public Position(int x, int y, int count) {
        this.x = x;
        this.y = y;
        this.count = count;
    }
}


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            int n = 10;
            char[][] arr = new char[n][n];
            // 标记遍历过的数组
            boolean[][] flg = new boolean[n][n];
            for (int i = 0; i < n; i++) {
                arr[i] = in.next().toCharArray();
            }

            System.out.println(bfs(arr, flg, n));
        }
    }

    public static int bfs(char[][] arr, boolean[][] flg, int n) {
        // 方向数组：下 右 左 上
        int[][] dir = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
        // 用队列来实现，将起点 (0,1) 入队
        Queue<Position> queue = new LinkedList<>();
        queue.offer(new Position(0, 1, 0));

        // 广度优先遍历
        while (!queue.isEmpty()) {
            // 弹出坐标，然后标记坐标
            // 并将与该坐标连接的其他坐标(下右左上)也添加进队列中
            Position position = queue.poll();


            // 标记该坐标
            flg[position.x][position.y] = true;

            if (position.x == 9 && position.y == 8) {
                // 此时就说明找到了最短路径
                return position.count;
            }
            // 添加下，右，左，上 四个下标
            for (int i = 0; i < 4; i++) {
                Position next = new Position(position.x + dir[i][0], position.y + dir[i][1], position.count + 1);

                // 如果 next 坐标合法，并且没有遍历过，并且是通路，那么就将下标入队
                if (next.x >= 0 && next.x < n && next.y >= 0 && next.y < n &&
                        !flg[next.x][next.y] && arr[next.x][next.y] == '.')
                    queue.offer(next);
            }
        }
        return 0;
    }
}