【限时免费】20天拿下华为OD笔试之【队列】2023B-不开心的小朋友全网注释最详细分类最全的华为OD真题题解

文章目录

  • 题目描述与示例
    • 题目描述
    • 输入描述
    • 输出描述
    • 示例一
      • 输入
      • 输出
      • 说明
    • 示例二
      • 输入
      • 输出
      • 说明
  • 解题思路
  • 代码
    • Python
    • Java
    • C++
    • 时空复杂度
  • 华为OD算法/大厂面试高频题算法练习冲刺训练

题目描述与示例

题目描述

游乐场里增加了一批摇摇车,非常受小朋友欢迎,但是每辆摇摇车同时只能有一个小朋友使用,如果没有空余的摇摇车需要排队等候,或者直接离开,最后没有玩上的小朋友会非常不开心。

请根据今天小朋友的来去情况,统计不开心的小朋友数量。

  1. 摇摇车数量为N,范围是: 1 <= N < 10;
  2. 每个小朋友都对应一个编码,编码是不重复的数字,今天小朋友的来去情况,可以使用编码表示为:1 1 2 3 2 3。(若小朋友离去之前有空闲的摇摇车,则代表玩耍后离开;不考虑小朋友多次玩的情况)。小朋友数量≤ 100
  3. 题目保证所有输入数据无异常且范围满足上述说明

输入描述

第一行: 摇摇车数量 第二行: 小朋友来去情况

输出描述

返回不开心的小朋友数量

示例一

输入

1
1 2 1 2

输出

0

说明

第一行,1个摇摇车 第二行,1号来 2号来(排队) 1号走 2号走(1号走后摇摇车已有空闲,所以玩后离开)

示例二

输入

1
1 2 2 3 1 3

输出

1

说明

第一行,1个摇摇车 第二行,1号来 2号来(排队) 2号走(不开心离开) 3号来(排队)1号走 3号走(1号走后摇摇车已有空闲,所以玩后离)

解题思路

在摇摇车满位的情况下,小朋友的排队顺序天然地符合先进先出的顺序,很容易想到用队列维护排队过程。

wait_queue = deque()

但本题的难点在于处理好每一个小朋友的状态。每一个小朋友均有三种不同的状态:

  • 是否出现过
  • 是否玩上了摇摇车
  • 是否离开(无论是玩完离开还是生气离开)

因此可以用哈希表记录每一个小朋友的状态,哈希表的默认值为一个长度为3的列表,分别对应上述的三种状态。

children_state_dic = defaultdict(lambda: [False, False, False])

遍历小朋友来去情况的序列。每一个小朋友,一共存在以下四种情况:

  1. 小朋友第一次出现(来到),摇摇车有位置。
    1. 标记小朋友已经来过
    2. 小朋友直接去玩
    3. 正在玩摇摇车的人数+1
    4. 注意:此时排队队列一定为空,否则摇摇车不可能有位置
  2. 小朋友第一次出现(来到),摇摇车没位置
    1. 标记小朋友已经来过
    2. 小朋友加入队列末尾
  3. 小朋友第二次出现(离开),刚刚玩上了摇摇车(满意离开)
    1. 标记小朋友已经离开
    2. 正在玩摇摇车的人数-1
    3. 由于玩摇摇车的人数减少,排在队头的小朋友(如果他刚刚没有生气离开),则可以出队去玩摇摇车
  4. 小朋友第二次出现(离开),刚刚没玩上摇摇车(生气离开)
    1. 标记小朋友已经离开
    2. 不开心的小朋友人数+1

上述分类讨论组织成代码即为

for child in children:
    if children_state_dic[child][0] is False:
        children_state_dic[child][0] = True
        if play_num < n:
            children_state_dic[child][1] = True
            play_num += 1
        else:
            wait_queue.append(child)
    else:
        children_state_dic[child][2] = True
        if children_state_dic[child][1] is True:
            play_num -= 1
            while len(wait_queue) > 0 and play_num < n:
                nxt_child = wait_queue.popleft()
                if children_state_dic[nxt_child][2] is False:
                    children_state_dic[nxt_child][1] = True
                    play_num += 1
        else:
            angry_num += 1

代码

Python

# 题目:【队列】2023B-不开心的小朋友
# 分值:200
# 作者:闭着眼睛学数理化
# 算法:队列
# 代码看不懂的地方,请直接在群上提问


from collections import deque, defaultdict

# 摇摇车数量
n = int(input())
# 小朋友序列,编码用字符串即可
children = input().split()
# 初始化小朋友的等待队列
wait_queue = deque()
# 用一个哈希表记录每一个小朋友的状态,默认值为一个长度为3的列表
# 分别表示:是否之前出现过/是否玩上了摇摇车/是否已经离开
children_state_dic = defaultdict(lambda: [False, False, False])
play_num = 0
angry_num = 0
# 遍历小朋友序列
for child in children:
    # 小朋友编号第一次出现,过来玩摇摇车
    if children_state_dic[child][0] is False:
        # 将小朋友标记为已经来过
        children_state_dic[child][0] = True
        # 第一种情况:摇摇车有位置,可以玩,不用排队
        if play_num < n:
            children_state_dic[child][1] = True
            play_num += 1
        # 第二种情况:摇摇车没位置,不可以玩,加入队列排队
        else:
            wait_queue.append(child)
    # 小朋友编号第二次出现,玩完/生气离开
    else:
        # 将小朋友标记为已经离开
        children_state_dic[child][2] = True
        # 第三种情况:这个小朋友刚刚玩上了摇摇车,现在玩完摇摇车离开
        if children_state_dic[child][1] is True:
            # 玩摇摇车人数-1
            play_num -= 1
            # 队列中正在排队的小朋友可以进来玩
            while len(wait_queue) > 0 and play_num < n:
                # 队头等待的小朋友nxt_child出队
                nxt_child = wait_queue.popleft()
                # 如果在等待队列中的小朋友,没有被标记为生气离开,则可以玩摇摇车
                if children_state_dic[nxt_child][2] is False:
                    children_state_dic[nxt_child][1] = True
                    # 玩摇摇车人数+1
                    play_num += 1
        # 第四种情况:这个小朋友刚刚没玩上摇摇车,生气离开
        else:
            # 生气人数+1
            angry_num += 1

print(angry_num)

Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        String[] children = scanner.nextLine().split(" ");
        Queue<String> waitQueue = new LinkedList<>();
        Map<String, List<Boolean>> childrenState = new HashMap<>();
        int playNum = 0;
        int angryNum = 0;
        
        for (String child : children) {
            if (!childrenState.containsKey(child)) {
                childrenState.put(child, Arrays.asList(false, false, false));
            }
            
            if (!childrenState.get(child).get(0)) {
                childrenState.get(child).set(0, true);
                if (playNum < n) {
                    childrenState.get(child).set(1, true);
                    playNum++;
                } else {
                    waitQueue.add(child);
                }
            } else {
                childrenState.get(child).set(2, true);
                if (childrenState.get(child).get(1)) {
                    playNum--;
                    while (!waitQueue.isEmpty() && playNum < n) {
                        String nxtChild = waitQueue.poll();
                        if (!childrenState.get(nxtChild).get(2)) {
                            childrenState.get(nxtChild).set(1, true);
                            playNum++;
                        }
                    }
                } else {
                    angryNum++;
                }
            }
        }

        System.out.println(angryNum);
    }
}

C++

#include 
#include 
#include 

using namespace std;

int main() {
    int n;
    cin >> n;
    string child;
    queue<string> waitQueue;
    unordered_map<string, vector<bool>> childrenState;
    int playNum = 0;
    int angryNum = 0;
    
    while (cin >> child) {
        if (childrenState.find(child) == childrenState.end()) {
            childrenState[child] = {false, false, false};
        }
        if (!childrenState[child][0]) {
            childrenState[child][0] = true;
            if (playNum < n) {
                childrenState[child][1] = true;
                playNum++;
            } else {
                waitQueue.push(child);
            }
        } else {
            childrenState[child][2] = true;
            if (childrenState[child][1]) {
                playNum--;
                while (!waitQueue.empty() && playNum < n) {
                    string nxtChild = waitQueue.front();
                    waitQueue.pop();
                    if (!childrenState[nxtChild][2]) {
                        childrenState[nxtChild][1] = true;
                        playNum++;
                    }
                }
            } else {
                angryNum++;
            }
        }
    }

    cout << angryNum << endl;

    return 0;
}

时空复杂度

时间复杂度:O(M)。遍历每一个小朋友的情况,每一个小朋友最多出入队一次。

空间复杂度:O(M)。哈希表和队列所占空间均为O(M)


华为OD算法/大厂面试高频题算法练习冲刺训练

  • 华为OD算法/大厂面试高频题算法冲刺训练目前开始常态化报名!目前已服务100+同学成功上岸!

  • 课程讲师为全网50w+粉丝编程博主@吴师兄学算法 以及小红书头部编程博主@闭着眼睛学数理化

  • 每期人数维持在20人内,保证能够最大限度地满足到每一个同学的需求,达到和1v1同样的学习效果!

  • 60+天陪伴式学习,40+直播课时,300+动画图解视频,300+LeetCode经典题,200+华为OD真题/大厂真题,还有简历修改、模拟面试、专属HR对接将为你解锁

  • 可上全网独家的欧弟OJ系统练习华子OD、大厂真题

  • 可查看链接 大厂真题汇总 & OD真题汇总(持续更新)

  • 绿色聊天软件戳 od1336了解更多

你可能感兴趣的:(最新华为OD真题,华为,华为od,算法)