华为OD机试真题-停车场车辆统计-思路与java代码

1.原题链接

华为OD机试真题-停车场车辆统计-2023年OD统一考试（C卷）-CSDN博客

2.思路

统计两个空车位之间有多少个车位被占用.即统计数组中两个0之间1的数量 temp,并根据统计到的数量temp进行分配,得到最少辆车.

为了得到最少量车,所以,车位优先分配给卡车

卡车数量 = temp /  3

车位分配给卡车后,剩余的车位(temp % 3)尽可能给货车

货车数量 = (temp % 3) / 2

最后的车位(temp % 3) % 2给小车

小车数量 = (temp % 3) % 2 / 1 

3.java代码实现

主要代码

  public static int solution(int[] arr) {
        //返回的结果
        int ans = 0;
        //left 记录上一次空车位的位置,初始值借一个空车位,所以是在数组边界外
        int left = -1;
        //right 记录这一次空车位的位置,初始值借一个空车位,所以是在数组边界外
        int right = -1;

        for (int i = 0; i < arr.length; i++) {

            if (arr[i] == 0) {
                right = i;
                //right - left + 1 两个空车位之间有几个车位被使用
                int temp = right - left - 1;
                //车位优先计算卡车
                ans += temp / 3;
                //计算大车后的余数用来计算货车,值可能是0,1,2
                ans += (temp % 3) / 2;
                //计算完卡车和货车,最后的余量(边角料)用来计算小车,只能是0或1
                ans += (temp % 3) % 2;
                left = right;
            }
        }
        //特殊边界条件,如果最后的车位不是空车位
        if (right != arr.length - 1) {
            //逻辑上,认为边界外有一个空车位,即借右边一个空车位(因为arr.length 放在数组里已经越界了,但假定没越界,且arr[length] = 0)
            right = arr.length;
            int temp = right - left - 1;
            //车位优先计算卡车
            ans += temp / 3;
            //计算大车后的余数用来计算货车,值可能是0,1,2
            ans += (temp % 3) / 2;
            //计算完卡车和货车,最后的余量(边角料)用来计算小车,只能是0或1
            ans += (temp % 3) % 2;
        }

        // System.out.println(ans);
        return ans;
    }

生成随机的测试用例代码

public static int[] getRandom01Arr() {
        Random random = new Random();
        int length = random.nextInt(0, 20) + 1;//[1,20]

        int[] arr = new int[length];

        int oneNums = random.nextInt(0, length) + 1;//[1,length]
        HashSet<Integer> set = new HashSet<Integer>();

        //在随机位置赋值随机的1
        while (oneNums > 0) {
            int index = random.nextInt(0, length);// [0,length-1]
            if (!set.contains(index)) {
                arr[index] = 1;
                set.add(index);
                oneNums--;
            }
        }

        return arr;
    }

主函数

public static void main(String[] args) {
        //更改i可到达的最大值即可修改测试次数
        for (int i = 1; i <= 20; i++) {
            int[] arr = getRandom01Arr();
            System.out.println("===============");
            System.out.println("第" + i + "轮测试,生成数组如下:");
            for (int num : arr) {
                System.out.print(num + " ");
            }
            int result = solution(arr);
            System.out.println("\n计算结果为:\n" + result);
        }

    }

测试结果

因为是随机生成的数组,所以20次可能会有些重复的测试

第1轮测试,生成数组如下:
0 0 0 0 1 0 1 1 0 0 0 
计算结果为:
2
===============
第2轮测试,生成数组如下:
1 0 0 0 0 0 0 0 1 0 0 1 
计算结果为:
3
===============
第3轮测试,生成数组如下:
0 1 1 0 0 0 0 0 
计算结果为:
1
===============
第4轮测试,生成数组如下:
1 0 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 1 0 
计算结果为:
6
===============
第5轮测试,生成数组如下:
1 
计算结果为:
1
===============
第6轮测试,生成数组如下:
1 
计算结果为:
1
===============
第7轮测试,生成数组如下:
0 1 0 
计算结果为:
1
===============
第8轮测试,生成数组如下:
1 1 0 1 1 1 1 0 1 0 0 1 1 1 1 1 1 1 0 
计算结果为:
7
===============
第9轮测试,生成数组如下:
1 
计算结果为:
1
===============
第10轮测试,生成数组如下:
1 1 1 0 0 0 1 1 0 1 1 1 0 
计算结果为:
3
===============
第11轮测试,生成数组如下:
1 1 1 1 1 1 1 1 1 1 1 
计算结果为:
4
===============
第12轮测试,生成数组如下:
0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 
计算结果为:
2
===============
第13轮测试,生成数组如下:
1 1 1 
计算结果为:
1
===============
第14轮测试,生成数组如下:
0 1 0 1 0 0 0 1 0 0 0 1 1 0 1 0 
计算结果为:
5
===============
第15轮测试,生成数组如下:
1 1 
计算结果为:
1
===============
第16轮测试,生成数组如下:
1 0 0 1 1 0 1 0 1 1 1 1 0 1 
计算结果为:
6
===============
第17轮测试,生成数组如下:
0 1 1 0 1 1 1 1 0 1 1 1 
计算结果为:
4
===============
第18轮测试,生成数组如下:
1 
计算结果为:
1
===============
第19轮测试,生成数组如下:
1 0 0 0 1 0 0 
计算结果为:
2
===============
第20轮测试,生成数组如下:
1 1 1 1 1 1 1 1 0 
计算结果为:
3