2023HW部分笔试题

最新推荐文章于 2024-11-03 11:01:20 发布

Mr_Richard

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量509

点赞数 6

分类专栏：笔试文章标签： java 字符串 bfs

本文链接：https://blog.csdn.net/Mr_Richard/article/details/140084667

版权

笔试专栏收录该内容

1 篇文章 0 订阅

订阅专栏

题目来源：卡码网

136. 字符串处理器

问题描述

时间限制：1.000S 空间限制：256MB

题目描述

产品代码需要设计一个带游标的字符串处理器，它需要实现以下功能:

插入：在游标所在处添加文本，其对应操作为 insert str,insert 表示插入操作命令关键字 (区分大小写)，str 表示待操作的字符串，insert 操作执行后将 str 拼接到游标当前位置，同时游标移动到 str 的右边;

删除：在游标所在处删除文本，其对应操作为 delete len，delete 表示删除操作命令关键字(区分大小写)，len 为整数，表示删除游标左边字符串的长度，此时 len 要求大于等于 0，如果len大于游标所在处左侧字符串长度，认为输入命名非法，不做任何处理;

移动：将游标往左或者往右移动，其对应操 move cnt，move 表示游标移动操作命令关键字(区分大小写)，cnt 为整数，表示游标移动次数，cnt 如果为负数时表示向左移动 cnt 次，如果为正数表示向右移动 cnt 次数，如果 cnt 等于 0，则表示游标不移动，如果移动次数 cnt 超过字符串左右边界则认为输入命名非法，不做任何处理;

复制：将游标左边字符串复制并插入到游标的右边，游标位置不变(如果游标右边有字符，复制插入到游标和原有字符中间)，其对应操作为 copy，copy 表示复制操作命令关键字(区分大小写);

输入描述

支持输入多行，每个仅支持输入一个操作命令，当输入 end 结束操作命令关键字（区分大小写）时则代表操作停止。

首次执行时字符串处理器内部字符串为空，游标位置索引为 0，此时字符串处理器序列化结果为 1。

1 <= str.length<= 40

1 <= len<= 40

-40 <= cnt <= 40

调用 insert，delete，move 和copy 的总次数不超过 200 次。

输出描述

当前字符串处理器的序列化结果，游标使用“|”来表示。

输入示例

insert test
insert hellohuawei
move -6
delete 5
insert practice
copy
end

输出示例

testpractice|testpracticehuawei

解题思路与代码实现

思路：模拟字符串操作过程

代码实现：

import java.util.Map;
import java.util.Scanner;
import java.util.HashMap;
 
public class Main {
    static StringBuilder builder = new StringBuilder();
    static int index = 0;
 
    // 游标处插入字符串
    static void insert(String str) {
        if (str == null || str.isEmpty()) {  // 字符串为空
            return;
        }
        builder.insert(index, str);
        index += str.length();
    }
 	
    // 删除游标左侧len个字符
    static void delete(int len) {
        if (len < 0 || len > index) {    // 非法输入
            return;
        }
        int start = index - len;    // 删除左边区间部分字符
        builder.delete(start, index);
        index -= len;
    }
 	
    // 移动游标
    static void move(int cnt) {
        int newPos = index + cnt;
        // 判断新位置是否越界
        if (newPos < 0 || newPos > builder.length()){
            return;
        }
        index = newPos; // 更新游标
    }
 
    // 复制游标左侧子串
    static void copy(){
        String leftStr = builder.substring(0,index);
        builder.insert(index,leftStr);
        // 游标位置不变
    }
 
    public static void main(String[] args) {
 
        Scanner in = new Scanner(System.in);
        // ACM输入
        while (true) {
            String command = in.next();
            if (command.equals("end")) {
                builder.insert(index, '|');
                // ACM输出
                System.out.println(builder.toString());
                break;
            } else if (command.equals("insert")) {
                String str = in.next();
                insert(str);
            }else if (command.equals("delete")) {
                int len = in.nextInt();
                delete(len);
            }else if (command.equals("move")) {
                int cnt =in.nextInt();
                move(cnt);
            }else {
                copy();
            }
        }
    }
}

题目来源：卡码网

137. 消息传输

问题描述

时间限制：1.000S 空间限制：256MB

题目描述

在给定的 m x n (1 <= m, n <= 1000) 网格地图 grid 中，分布着一些信号塔，用于区域间通信。

每个单元格可以有以下三种状态：

值 0 代表空地，无法传递信号；

值 1 代表信号塔 A，在收到消息后，信号塔 A 可以在 1ms 后将信号发送给上下左右四个方向的信号塔；

值 2 代表信号塔 B，在收到消息后，信号塔 B 可以在 2ms 后将信号发送给上下左右四个方向的信号塔。

给定一个坐标 (j, k)，输入保证坐标 (j, k) 位置一定有信号塔。在坐标 (j, k) 位置的信号塔触发一个信号。

要求返回网格地图中所有信号塔收到信号的最短时间，单位为 ms。如果有信号塔无法收到信号，则返回 -1。

输入描述

第一行：网格的列数 n。

第二行：网格的行数 m。

第三行：触发信号的信号塔坐标 (j, k)。

接下来的 m 行：每行包含 n 个整数，表示该行网格中每个位置的信号塔安装信息（通过空格间隔每个状态值）。

输出描述

输出返回网格地图中所有信号塔收到信号的最小时间，单位为ms。如果不可能，返回-1。

输入示例

输出示例

解题思路与代码实现

思路：BFS搜索

代码实现：

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {
    static int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};   // 方向数组

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // ACM输入
        int n = in.nextInt();   // 列数
        int m = in.nextInt();   // 行数
        int startX = in.nextInt(), startY = in.nextInt();    // 起点坐标
        int[][] grid = new int[m][n];   // 地图
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                grid[i][j] = in.nextInt();
            }
        }
        // 处理
        // 辅助优先队列，存储数组，每个数组依次存储横坐标x、纵坐标y和起点（startX,startY）到(x,y)的最短耗时
        PriorityQueue<int[]> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(o -> o[2]));
        boolean[][] visited = new boolean[m][n]; // 辅助标记数组数组，visited[i][j]表示(i,j)位置已访问过
        int[][] dist = new int[m][n]; // 辅助数组，dist[i][j]表示(i,j)到(startX,startY)的最短耗时
        // 初始化dist数组
        for (int i = 0; i < dist.length; i++) {
            Arrays.fill(dist[i], Integer.MAX_VALUE);
        }
        dist[startX][startY] = 0;   // 起点位置耗时置0
        priorityQueue.offer(new int[]{startX, startY, 0});    // 起点入队

        while (!priorityQueue.isEmpty()) { // BFS
            int[] item = priorityQueue.poll();  // 队头元素出队
            int x = item[0], y = item[1], currentTime = item[2];
            visited[x][y] = true;   // 标记队头元素已访问
            for (int i = 0; i < directions.length; i++) {
                int newX = x + directions[i][0];
                int newY = y + directions[i][1];
                // 判断是否越界
                if (newX < 0 || newX >= m || newY < 0 || newY >= n) {
                    continue;
                }
                // 判断是否是未曾访问过的信号塔
                if (!visited[newX][newY] && grid[newX][newY] != 0) {
                    int newTime = currentTime + grid[x][y];
                    if (newTime < dist[newX][newY]){  // 找到了耗时更少的路径，需要更新dist数组
                        dist[newX][newY] = newTime;  // 更新耗时
                        priorityQueue.offer(new int[]{newX, newY, dist[newX][newY]});
                    }
                }
            }
        }
        // ACM输出，需要先判断是否所有信号塔都能收到信号
        int res = Integer.MIN_VALUE;
        // 选出dist数组所有信号塔的耗时最大值
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] != 0) {
                    if (!visited[i][j]) {    // bfs之后仍然有信号塔未被访问
                        System.out.println(-1);
                        return;
                    }
                    res = Math.max(res, dist[i][j]);    // 更新res为dist数组中对应信号塔的最大值
                }
            }
        }
        System.out.println(res);
    }
}