【华为机考E卷】-“高矮个子”题解思路java

算法每一题，成长每一天~

C0E36 高矮个子

真题链接：【持续更新】2024华为 OD 机试E卷 机考真题库清单（全真题库）

思路

不会做。
deepseek之后也没太看懂，先把结果码这儿。等看懂了再更新 T . T

Java

package com.ccr.paper_f;

import java.util.*;

public class C0E36 {

    static class Element {
        int index;
        int value;

        Element(int index, int value) {
            this.index = index;
            this.value = value;
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] split = in.nextLine().split(" ");
        int[] arr = new int[split.length];
        for (int i = 0; i < split.length; i++) {
            arr[i] = Integer.parseInt(split[i]);
        }

        int[] result = minimalStepsWiggle(arr);

        System.out.println("Total steps: " + result[0]);
        System.out.print("Sorted array: [");
        for (int i = 1; i < result.length; i++) {
            System.out.print(result[i] + (i < result.length - 1 ? ", " : ""));
        }
        System.out.println("]");
    }

    public static int[] minimalStepsWiggle(int[] arr) {
        int n = arr.length;
        if (n == 0) return new int[0];

        List<Element> elements = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            elements.add(new Element(i, arr[i]));
        }

        // 按元素值排序
        elements.sort(Comparator.comparingInt(a -> a.value));

        int k = (n + 1) / 2; // 大元素数量
        List<Element> bigElements = new ArrayList<>(elements.subList(n - k, n));
        List<Element> smallElements = new ArrayList<>(elements.subList(0, n - k));

        // 处理大元素的目标位置 (0, 2, 4...)
        List<Integer> bigTargets = new ArrayList<>();
        for (int i = 0; i < k; i++) {
            bigTargets.add(i * 2);
        }

        // 处理小元素的目标位置 (1, 3, 5...)
        List<Integer> smallTargets = new ArrayList<>();
        for (int i = 0; i < n - k; i++) {
            smallTargets.add(i * 2 + 1);
        }

        // 创建映射并计算步数
        int totalSteps = createMapping(bigElements, bigTargets)
                + createMapping(smallElements, smallTargets);

        // 构建结果数组
        int[] result = new int[n + 1];
        result[0] = totalSteps;
        for (Element e : bigElements) {
            result[e.index + 1] = e.value; // +1因为result[0]存储步数
        }
        for (Element e : smallElements) {
            result[e.index + 1] = e.value;
        }
        return result;
    }

    private static int createMapping(List<Element> elements, List<Integer> targets) {
        // 分离原始索引和目标位置
        List<Integer> originalIndices = new ArrayList<>();
        for (Element e : elements) {
            originalIndices.add(e.index);
        }
        List<Integer> sortedTargets = new ArrayList<>(targets);

        // 双重排序确保最小步数
        Collections.sort(originalIndices);
        Collections.sort(sortedTargets);

        int steps = 0;
        for (int i = 0; i < originalIndices.size(); i++) {
            int original = originalIndices.get(i);
            int target = sortedTargets.get(i);
            steps += Math.abs(original - target);
            // 更新元素索引用于后续结果构建
            elements.get(i).index = target;
        }
        return steps;
    }
}

总结

但是从deepseek给的测试结果，看着有点不对头：

xx：不会做。有大神吗？

---

算法要多练多练多练！！