[华为OD算法]不开心的小朋友 [java][100]

题目：不开心的小朋友题目描述：

游乐场里增加了一批摇摇车，非常受小朋友欢迎，但是每辆摇摇车同时只能有一个小朋友使

用，如果没有空余的摇摇车，需要排队等候，或者直接离开，最后没有玩上的小朋友会非常

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

1 、摇摇车数量为 N ，范围是： 1≤N<10 ；

2 、每个小朋友都对应一个编码，编码是不重复的数字，今天小朋友的来去情况，可以使用

编码表示为： 1 1 2 3 2 3 。（若小朋友离去之前有空闲的摇摇车，则代表玩耍后离开；

不考虑小朋友多次玩的情况）。小朋友数量 <=100

3 、题目保证所有输入数据无异常且范围满足上述说明。

输入描述：

第一行：摇摇车数量

第二行：小朋友来去情况

输出描述：

返回不开心的小朋友数量

示例 1

输入：

1

1 2 1 2

输出：

0

说明：

第一行， 1 个摇摇车 第二行， 1 号来 2 号来（排队） 1 号走 2 号走（ 1 号走后摇摇车已有空闲，所以玩后离

开）

示例 2

输入：

1

1 2 2 3 1 3

输出：

1

说明：

第一行， 1 个摇摇车

第二行， 1 号来 2 号来（排队） 2 号走（不开心离开） 3 号来（排队） 1 号走 3 号走

（ 1 号走后摇摇车已有空闲，所以玩后离开）

【解题思路】a.考虑到当有新来的小朋友的时候，需要根据当前车辆空余情况的等待情况进行判断

1）有空余车辆的时候，那么就直接玩，玩耍小朋友记录里面加上记录，空余车辆减1

2）没有空余车辆时候，等待小朋友记录加上当前数据

b.当前是等待小朋友走的时候

等待小朋友记录减一，并且不高兴数据加1

c.当前是玩耍小朋友走时候，需要根据等待数列判断

首先玩耍小朋友集合中减去记录

1）有等待小朋友，那么最前面等待小朋友开始玩车，等待列表中减去第一个数据

2）没有等待小朋友，那么直接玩耍小朋友集合中减去记录，空余车辆加1

这样的逻辑捋清楚之后，明显直接通过几个集合就可以解决。

import java.util.*;

public class PlayYaoyaoChe {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Integer playCarCount = Integer.valueOf(sc.nextLine());
        String childSequence = sc.nextLine();
        List<String> childSequenceList = Arrays.asList(childSequence.split(" "));
        int len = childSequenceList.size();
        Set<String> playSet = new HashSet<>(); // 记录正在玩的小朋友编号
        List<String> waitList = new ArrayList<>(); // 记录等待玩的小朋友编号
        int freeCount = playCarCount;  //当前空闲车的数量
        int unhappyCount = 0; //不高兴的统计数量

        for (int i = 0; i < len; i++) {
            String presentPlayNum = childSequenceList.get(i);
            if(freeCount>0)  //freeCount>0 时候 waitSet因为为空
            {
                if(playSet.contains(presentPlayNum)){ // 是正在玩的瑶离开
                    playSet.remove(presentPlayNum);
                    freeCount++;
                }
                else { // 新的玩家
                    playSet.add(presentPlayNum);
                    freeCount--;
                }
            }
            else {  // 玩的已经满了 都在等待
                if(playSet.contains(presentPlayNum)){ // 是正在玩的要离开
                    playSet.remove(presentPlayNum);
                    if(waitList.isEmpty()){
                        freeCount++;
                    }
                    else {  //一个等待的小朋友开始玩 并把他移出等待队列
                        String canPlayNum = waitList.get(0);
                        waitList.remove(canPlayNum);

                    }
                }
                else if(waitList.contains(presentPlayNum)){// 等待的走了
                    unhappyCount++; //不高兴加1
                    waitList.remove(presentPlayNum);

                }
                else {//是新来的小朋友
                    waitList.add(presentPlayNum);
                }
            }
        }

        System.out.println(unhappyCount); // 打印不高兴的数据
    }

}

输出记录：

import java.util.*;
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public List<Integer> relaxCarList = null;
    public List<Integer> runCarList = null;
    public Map<String, Integer> runCarMap = new HashMap<String, Integer>();
    public Integer maxCarNum = 0;
    public Integer relaxCarNum = 0;
    public Integer runCarNum = 0;
    public List<String> disAgreeList = new
            ArrayList<String>();//可能会不开心的小朋友
    public Integer disAgreeMapNum = 0;
    public static void main(String[] args) {
        new Main().test03();
    }
    public void test03() {
        Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            int maxCar = Integer.parseInt(in.nextLine());
            createCarPool(maxCar);//初始化最大车的值
            String ch = in.nextLine();
            disAgreeMapNum = 0;
            ch = ch.replaceAll(" ", ",");
            String[] children = ch.split(",");
            someMethod(children);
        }
    }
    private void someMethod(String[] children) {
        for (int i = 0; i < children.length; i++) {
            useCar(children[i]);
        }
        System.out.println(disAgreeMapNum);
    }
    private void useCar(String child) {
        if (runCarMap.containsKey(child)) {
            relaxCarList.add(runCarMap.get(child));
            runCarMap.remove(child);
            disAgreeList.remove(child);
            return;
        }
        if (relaxCarList != null && relaxCarList.size() > 0 ) {
            if (!runCarMap.containsKey(
                    child)) { //用车的 map 中不包含该小孩的时候，则去使用该车，
                //并且空闲车-1
                runCarMap.put(child, relaxCarList.get(0));
                relaxCarList.remove(0);
            } else {
                relaxCarList.add(runCarMap.get(child));
                runCarMap.remove(child);
                disAgreeList.remove(child);
            }
        } else { //用车的 map 中包含该小孩的时候，则该小孩离去,并且空闲车+1
            if (!disAgreeList.contains(child)) {
                disAgreeList.add(child);
            } else {
                disAgreeMapNum++;
                disAgreeList.remove(child);
            }
        }
    }
    /**
     * 初始化车的信息
     * @param maxCar */
    private void createCarPool(int maxCar) {
        maxCarNum = maxCar;
        relaxCarNum = maxCar;
        runCarNum = 0;
        runCarList = new ArrayList<Integer>(maxCar);
        relaxCarList = new ArrayList<Integer>(maxCar);
        for (int i = 0; i < maxCarNum; i++) {
//给每辆车编号
            relaxCarList.add(i);
        }
    }
}