代码随想录第三十七天|华为秋季笔试真题230823

最新推荐文章于 2025-04-25 18:24:00 发布

Aqua Cheng.

最新推荐文章于 2025-04-25 18:24:00 发布

阅读量805

点赞数 21

分类专栏：代码随想录算法训练营一刷面经分享文章标签：华为动态规划算法 leetcode java

本文链接：https://blog.csdn.net/csy031117/article/details/147433423

版权

代码随想录算法训练营一刷同时被 2 个专栏收录

42 篇文章

订阅专栏

面经分享

16 篇文章

订阅专栏

刷题小记：

主要偏向扎实编码基础的考察，但貌似近些年题目难度有所提高，仅供参考。

卡码网136.获取连通的相邻节点列表（卡码网136.获取连通的相邻节点列表）

题目分析：

题目描述：

存在N个转发节点，每个转发节点有自己唯一的标识TB且每个节点有M个端口，节点间通过端口通讯。现在将这些端口划分为多个通讯平面，通过VLAN隔离：

如果两个端口的VLAN ID相同，则说明位于同个VLAN，处于连通状态。
如果两个端口的VLAN ID不同，则说明位于不同VLAN，彼此不连通。

现在给出节点A的端口数以及每个端口的VLAN ID，以及节点A相邻的其他节点及其端口信息，求所有与节点A连通的相邻节点的标识符列表（按从小到大的顺序输出）。

输入描述：

输入的第一行：包含M + 1个用空格隔开的数，第一个数表示A有M个端口，后M个数分别表示这M个端口的VLAN ID。

输入的第二行：包含一个整数N，表示有N个与A相邻的节点，取值为[0, 4000)

输入的第三行开始有N行数据，每一行：第一个数表示节点x的标识符，第二个数表示它的端口数m_x，然后有m_x个数表示每个端口所属的VLAN ID。

其中，标识符TB的的取值范围达到long型。

输出描述：

第一行：与节点A连通的相邻节点的个数。

第二行：升序排列的这些连通节点的标识符TB

解题思路：

关键点是处理好输入，尤其是TB需要用long型存储。

遍历每个相邻节点的端口数，只要有端口的VLAN ID与节点A的端口的VLAN ID相同（即contains），那么该节点就与节点A连通。

import java.util.*;
class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            int M = in.nextInt();
            List<Integer> portA = new ArrayList<>();
            for(int i = 0; i < M; i++) {
                portA.add(in.nextInt());
            }

            int N = in.nextInt();
            long[] TB = new long[N];

            List<List<Integer>> ports = new ArrayList<>();
            for(int i = 0; i < N; i++) {
                List<Integer> port_i = new ArrayList<>();
                TB[i] = in.nextLong();
                int m = in.nextInt();
                for(int j = 0; j < m; j++) {
                    port_i.add(in.nextInt());
                }
                ports.add(new ArrayList<>(port_i));
            }
            List<Long> resList = new ArrayList<>();
            for(int i = 0; i < N; i++) {
                List<Integer> port_i = ports.get(i);
                for(int port : port_i) {
                    if(portA.contains(port)) {
                        resList.add(TB[i]);
                        break;
                    }
                }
            }
            Collections.sort(resList);
            System.out.println(resList.size());
            for(int i = 0; i < resList.size(); i++) {
                if(i != 0) System.out.print(" ");
                System.out.print(resList.get(i));
            }
        }
    }
}

卡码网137.字符串处理器（卡码网137.字符串处理器）

题目分析：

设计一个带游标的字符处理器，实现如下功能：

插入：在游标处添加文本，其对应操作是insert str：insert表示插入操作命令关键字（区分大小写），str表示待操作的字符串，该操作执行后将str拼接到右表当前位置，且游标移动到str的右边。
删除：在游标处删除文本，其对应操作是delete len：delete表示删除命令关键字，len是一个整数，表示删除游标左边字符串的长度，如果len大于游标所在处左侧字符串的长度或者 len是负数，那么操作非法，不做任何处理。
移动：将游标左右移动，其对应操作是move cnt：move表示移动命令关键字，cnt是一个整数，表示游标移动次数，如果cnt为负数表示向左移动cnt次，如果cnt为正数表示向右移动cnt次，如果为0则不移动，如果超过字符串左右边界则认为输入命名非法，不做任何处理。
复制：将游标左边字符串复制并插入到游标的右边，且游标位置不变（如果游标右边有字符，复制插入到游标和原有字符中间），对应操作为copy：copy表示复制操作命令关键字。

输入描述：

支持输入多行，每行包含一个操作命令，当输入end（区分大小写）表示操作停止。

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

输出描述：

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

import java.util.*;
class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        StrOperator strOperator = new StrOperator();
        while(in.hasNext()) {
            String[] op = in.nextLine().split(" ");
            switch(op[0]) {
                case "insert":
                    strOperator.insert(op[1]);
                    break;
                case "delete":
                    strOperator.delete(Integer.parseInt(op[1]));
                    break;
                case "move":
                    strOperator.move(Integer.parseInt(op[1]));
                    break;
                case "copy":
                    strOperator.copy();
                    break;
                case "end":
                    strOperator.end();
                    break;
                default:
                    break;
            }
        }
        in.close();
    }
}
class StrOperator {
    int cur;
    int length;
    StringBuilder sb;

    StrOperator() {
        this.cur = 0;
        this.length = 0;
        this.sb = new StringBuilder();
    }
    void insert(String str) {
        sb.insert(cur, str);
        cur += str.length();
        length += str.length();
    }
    void delete(int len) {
        if(cur >= len && len >= 0) {
            sb.delete(cur - len, cur);
            cur -= len;
            length -= len;
        }
    }
    void move(int cnt) {
        if(cur + cnt < 0 || cur + cnt > length) {
            return;
        }else {
            cur += cnt;
        }
    }
    void copy() {
        String str = sb.substring(0, cur);
        sb.insert(cur, str);
        length += str.length();
    }
    void end() {
        if(length == 0) {
            System.out.println("|");
        } else {
            sb.insert(cur, "|");
            System.out.println(sb.toString());
        }
    }
}

卡码网138.消息传输（卡码网138.消息传输）

题目分析：

题目描述：

给定m×n（1<= m, n <= 1000)的网格地图grid中，分布着一些信号塔。

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

值0表示空地，无法传递信号
值1表示信号塔A，收到消息后，在1ms后将信号发送给上下左右四个方向的信号塔；
值2表示信号塔B，2ms后完成信号发送

给定一个坐标(j, k)，输入保证该处一定有信号塔。现求网格地图中所有信号塔收到信号的最短时间，单位为ms，如果有信号塔无法收到信号，则返回-1。

注意：以信号塔A为例，在它收到信号后，经过1ms将信号发送至上下左右四个方向的一格处，信号塔B同理。

输入描述：

第一行：网格的列数n

第二行：网格的行数m

第三行：给定坐标(j, k)

接下来的m行，每行n个用空格隔开的整数，表示单元格状态。

输出描述：

输出返回网格地图中所有信号塔都已收到信号的最小时间，如果无法实现，返回-1。

解题思路：

用一个大小与grid相同的time数组，初始化全部元素为-1，用于记录信号塔接收到信号的最短时间。

本题显然适用广度优先搜索遍历，当一个点接收到信号时，有4种可能性：

该点为空地，忽略
该点是信号塔，第一次接收信号，更新time并将其添入que
该点是信号塔，不是第一次接收信号，该次访问时间不小于time，忽略
该点是信号塔，不是第一次接收信号，该次访问时间小于time，更新time并将其添入que

最终遍历time数组，在确认全部信号塔的接收时间不为-1的情况下，所得到的最大值就是至少需要的时间。

import java.util.*;

class Main{
    private static int[][] dir={{1,0},{-1,0},{0,1},{0,-1}};
    public static void main (String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int startx = in.nextInt(), starty = in.nextInt();
        int[][] time=new int[m][n];
        int[][] grid=new int[m][n];
        for(int[] t:time){
            Arrays.fill(t,-1);
        }
        in.nextLine();
        for(int i = 0; i < m; i++){
            String s = in.nextLine();
            String[] t=s.split(" ");
            for(int j = 0; j < n; j++){
                grid[i][j]=Integer.valueOf(t[j]);
            }
        }
        
        bfs(grid, time, startx, starty);

        int ans = 0;
        boolean valid = true;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] > 0) {
                    if(time[i][j] == -1) {
                        valid = false;
                        break;
                    }
                    ans=Math.max(ans,time[i][j]);
                }
            }
            if(!valid) break;
        }
        if(valid) System.out.println(ans);
        else System.out.println(-1);
    }
    private static void bfs(int[][] grid, int[][] time, int startx, int starty) {
        Deque<int[]> que = new ArrayDeque<>();
        time[startx][starty] = 0;
        que.offer(new int[]{startx, starty});

        while (!que.isEmpty()) {
            int[] towerIndex = que.poll();
            int x = towerIndex[0], y = towerIndex[1];

            for (int[] d : dir) {
                int nextx = x + d[0];
                int nexty = y + d[1];
                if (nextx >= 0 && nextx < grid.length && nexty >= 0 && nexty < grid[0].length && grid[nextx][nexty] > 0) {
                    int newtime = time[x][y] + grid[x][y];
                    if (time[nextx][nexty] == -1 || newtime < time[nextx][nexty]) {
                        time[nextx][nexty] = newtime;
                        que.offer(new int[]{nextx, nexty});
                    }
                }
            }
        }
    }
}