48天笔试训练错题——day38

最新推荐文章于 2024-08-06 13:17:15 发布

ミカミミミ

最新推荐文章于 2024-08-06 13:17:15 发布

阅读量742

点赞数 14

分类专栏： 48天笔试训练错题合集文章标签： 48天笔试强训 Java

本文链接：https://blog.csdn.net/weixin_74085729/article/details/140806579

版权

48天笔试训练错题合集专栏收录该内容

48 篇文章 0 订阅

订阅专栏

选择题

1.

TCP：有连接，可靠传输，面向字节流。

UDP：无连接，不可靠，面向数据报。

TCP 协议和 UDP 协议都是传输层协议。

2.

应用层：针对特定应用规定各层协议，时序，表示等，进行封装。如 HTTP。

表示层：规定数据的格式化表示，数据格式的转换。

会话层：规定通信时序，数据交换的定界，同步，创建检查点等。

传输层：节点(端口)之间可靠地分发数据包。

网络层：路由选择(IP 寻址)，拥塞控制。

数据连接层：检错与纠错(CRC 码)，多路访问，寻址。

物理层：定义机械特性，电气特性。

3.

应用层：文件传输协议(FTP)，远程登录协议(Telnet)，电子邮件协议(SMTP)，网络文件服务协议(NFS)，网络管理协议(SNMP)，域名解析协议(DNS)。

传输层：TCP，UDP 协议。

网络层：IP，ICMP，ARP，RARP。

PPP 是数据链路层协议。

4.

5.

6.

URL 又名统一资源定位符，方便确定一个资源，并表示它在哪里，可以使用大写字母。

80 端口是 HTTP 地端口。

URL 格式：
protocol://hostname[:port]/path/[;parameters][?query]#fragment

7.

8.

应用层：文件传输协议(FTP)，远程登录协议(Telnet)，电子邮件协议(SMTP)，网络文件服务协议(NFS)，网络管理协议(SNMP)，域名解析协议(DNS)。

传输层：TCP，UDP 协议。

网络层：IP，ICMP，ARP，RARP。

9.

211.168.15.192/26 ( /26 表示子网掩码使用了 26 个高位比特位 )

IP 地址：11010011 10101000 00001111 11000000

子网掩码：11111111 11111111 11111111 11000000

所以主机号范围使用 6 个比特位。

211.168.15.160/27

IP 地址：11010011 10101000 00001111 10100000

子网掩码：11111111 11111111 11111111 11100000

所以主机号范围使用 5 个比特位。

211.168.15.128/27

IP 地址：11010011 10101000 00001111 10000000

子网掩码：11111111 11111111 11111111 11100000

所以主机号范围使用 5 个比特位。

如上，能发现三个 IP 地址地前 25 位是一样的，所以聚合前 25 位比特位，剩下 7 位就作为主机号存在。211.168.15.128/25

所以网段号是 211.168.15.128，2^7 = 128，

所以子网范围是 211.168.15.128 - 211.168.15.255。除去全 0 (网段号)和全 1 (广播号)后，剩下 126 个。

10.

编程题

1. 蘑菇阵

这道题，我们可以用动态规划的方法来做，首先根据题目来设计 dp[i][j] 的含义。

如题，题目要求计算从 (1,1) 走到 (n,m) 不遇到蘑菇的概率，那么 dp[i][j] 就是从 (1,1) 走到 (i,j) 不遇到蘑菇的概率。然后再来推算状态转移方程，dp[i][j] = ?，看题，题目规定只能向右走和向下走，那么要到达 (i,j) 这个位置，只能是从上方下来的，或者是从左方过来的，所以 dp[i][j] 等于从 dp[i - 1][j] 向下走的概率，再加上从 dp[i][j - 1] 向右走的概率，一般来说只能走两个方向，概率就是 0.5，但是也有特殊情况，那就是在边界 i == n 和 j == m 的情况，只有一种选择，只能朝右走或者朝下走，所以概率要根据边界情况来决定，则最终 dp[i][j] = dp[i - 1][j] * (j == m ? 1 : 0.5) + dp[i][j - 1] *(i == n ? 1 : 0.5); 如果 (i,j) 是蘑菇的话，那么 dp[i][j] = 0，然后就是初始化，dp[1][1] = 0，最后返回 dp[n][m] 即可。

代码实现：

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            // dp[i][j] 表示从 (1,1) 走到 (i,j) 的不遇到蘑菇概率
            double[][] dp = new double[n + 1][m + 1];

            // 用 -1 表示蘑菇位置
            for (int i = 0; i < k; i++) {
                int x = in.nextInt();
                int y = in.nextInt();
                dp[x][y] = -1;
            }

            // 初始化
            dp[1][1] = 1.0;
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= m; j++) {
                    if (i == 1 && j == 1) continue;
                    // 是蘑菇
                    if (dp[i][j] == -1) {
                        dp[i][j] = 0;
                    } else {
                        // 从上边来，如果不是边界，则往下走的概率要乘 0.5
                        double up = dp[i - 1][j] * (j == m ? 1 : 0.5);
                        // 从左边来，如果不是边界，则往右走的概率要乘 0.5
                        double left = dp[i][j - 1] * (i == n ? 1 : 0.5);
                        dp[i][j] = up + left;
                    }
                }
            }

            System.out.printf("%.02f\n", dp[n][m]);
        }
    }
}

2. 红与黑

像上面这种能往四个方向走的题目一般都是用深度优先遍历，深搜的过程都差不多，就是将瓷砖数组，标记数组，m，n，i，j 作为 dfs 的参数，然后定义一个静态成员变量 count 记录能遍历到的黑色瓷砖，然后进入 dfs 就先判断数组是否越界，是否是已经遍历过的格子，和是否是白色瓷砖，如果满足以上条件，那就直接返回，如果不是，那么则说明是第一次遇到黑色瓷砖，那就 count++，然后再将现在的格子标记一下，然后继续往上下左右四个方向走，就是这里不需要回溯，最后等 dfs 结束，再输出 count 即可，但是有一点需要注意，因为 count 是静态成员变量，所以只会初始化一次，所以成员都是共享的，为了防止 count 叠加多次测试用例的结果，则需要在进行 dfs 前将 count 置为 0.

代码实现：

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    // 记录深搜黑色瓷砖数量
    public static int count = 0;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int m = in.nextInt();
            int n = in.nextInt();

            // 记录起始位置
            int x = -1;
            int y = -1;
            // 接收瓷砖的数组
            char[][] arr = new char[m][n];
            // 标记走过的格子的数组
            boolean[][] flg = new boolean[m][n];
            for (int i = 0; i < m; i++) {
                String str = in.next();
                arr[i] = str.toCharArray();

                if (str.contains("@")) {
                    for (int j = 0; j < n; j++) {
                        char c = arr[i][j];
                        if (c == '@') {
                            x = i;
                            y = j;
                        }
                    }
                }
            }

            // 防止 count 叠加多次测试用例的运行结果(static 变量只会实例化一次)
            count = 0;

            dfs(arr, flg, x, y, m, n);
            System.out.println(count);
        }
    }


    public static void dfs(char[][] arr, boolean[][] flg, int i, int j, int m, int n) {
        // 越界或格子已经走过或白色瓷砖
        if (i < 0 || i >= m || j < 0 || j >= n || flg[i][j] || arr[i][j] == '#') {
            return;
        }
        count++;
        flg[i][j] = true;
        // 再往四个方向走
        dfs(arr, flg, i - 1, j, m, n);
        dfs(arr, flg, i + 1, j, m, n);
        dfs(arr, flg, i, j - 1, m, n);
        dfs(arr, flg, i, j + 1, m, n);
    }
}