华为OD机试 - 堆栈中的剩余数字 - 逻辑分析（Java 2023 B卷 200分）

news2025/1/16 4:49:56

在这里插入图片描述

专栏导读

本专栏收录于《华为OD机试（JAVA）真题（A卷+B卷）》。

刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

向一个空栈中依次存入正整数，假设入栈元素 n(1<=n=2^31-1)按顺序依次为 nx…n4、n3、n2、n1,每当元素入栈时，如果 n1=n2+…+ny(y 的范围[2,x]，1<=x<=1000)，则 n1~ny 全部元素出栈，重新入栈新元素 m(m=2*n1)。

如: 依次向栈存入 6、1、2、3, 当存入 6、 1、2 时，栈底至栈顶依次为[6、 1、2]; 当存入 3 时 3=2+1，3、2、1 全部出栈，重新入栈元素 6(6=2*3)，此时栈中有元素 6;因为 6=6，所以两个 6 全部出栈，存入 12，最终栈中只剩一个元素 12。

二、输入描述

使用单个空格隔开的正整数的字符串，如”5 6 7 8”，左边的数字先入栈，输入的正整数个数为,1<=X<=1000

三、输出描述

最终栈中存留的元素值，元素值使用空格隔开，如”8 7 6 5”，栈顶数字在左边6 1 2 3

1、输入

5 10 20 50 85 1

2、输出

1 170

3、说明

5 + 10 + 20 + 50 = 85

2 * 85入栈，1入栈，输出 1 170

四、解题思路

输入若干个数字，空格分割，放入数组arr；
遍历arr，取出待入栈元素current；
定义已经出栈的元素集合peekList；
倒序遍历，栈顶元素先出栈peek；
- 出栈元素依次相加，得到sum；
- 出栈元素之和大于当前待入栈元素，则没必要再比下去了，直接加入当前待入栈元素current；
- 出栈元素之和等于当前待入栈元素，则将已经比较过的栈内元素取出；
  - 重新入栈新元素 m(m=2*n1)；
- 如果不等，已经出栈的元素集合加入peek；
比较不等，则加入待入栈元素；
得到最终的list，倒序输出。

五、Java算法源码

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int[] arr = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < arr.length; i++) {
        // 待入栈元素
        int current = arr[i];
        if (list.size() == 0) {
            list.add(current);
            continue;
        }

        // 1 2 5 7 9 1 2 2
        int sum = 0;
        // 已经出栈的元素集合
        List<Integer> peekList = new ArrayList<>();
        boolean flag = false;
        // 倒序遍历，栈顶元素先出栈
        for (int j = list.size() - 1; j >= 0; j--) {
            int peek = list.get(j);
            // 出栈元素依次相加
            sum += peek;
            // 出栈元素之和大于当前待入栈元素，则没必要再比下去了
            if (sum > current) {
                list.add(current);
                flag = true;
                break;
            }

            // 出栈元素之和等于当前待入栈元素，则将已经比较过的栈内元素取出
            if (sum == current) {
                peekList.add(peek);
                for (int k = 0; k < peekList.size(); k++) {
                    list.remove(list.size() - 1);
                }
                // 重新入栈新元素 m(m=2*n1)
                list.add(2 * current);
                flag = true;
                break;
            } else {
                // 已经出栈的元素集合
                peekList.add(peek);
            }
        }

        // 比较不等，则加入待入栈元素
        if (!flag) {
            list.add(current);
        }
    }

    // 倒序输出
    StringJoiner stringJoiner = new StringJoiner(" ");
    for (int i = list.size() - 1; i >= 0; i--) {
        stringJoiner.add(list.get(i) + "");
    }
    System.out.println(stringJoiner);
}