最小处理时间

import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.stream.IntStream;

// 思路：
// 1. 将任务数组按任务时间从大到小排序。
// 2. 为每个处理器建立一个最小堆，用于记录其每个核心的空闲时间。
// 3. 逐个将任务分配给最早空闲的核心。
// 4. 返回所有处理器中完成所有任务的最晚时间。

public class Solution {
    public int minTime(int[] processorTime, int[] tasks) {
        // 将任务数组按任务时间从大到小排序
        Arrays.sort(tasks);
        int n = processorTime.length;
        int cores = 4; // 每个处理器4个核心

        // 最小堆，用于记录每个核心的空闲时间
        PriorityQueue<Integer>[] processors = IntStream.range(0, n)
                .mapToObj(i -> new PriorityQueue<Integer>())
                .toArray(PriorityQueue[]::new);

        IntStream.range(0, n).forEach(i -> IntStream.range(0, cores)
                .forEach(j -> processors[i].offer(processorTime[i])));

        // 任务从大到小分配
        IntStream.iterate(tasks.length - 1, i -> i >= 0, i -> i - 1).forEach(i -> {
            // 寻找最早空闲的核心
            int minIndex = IntStream.range(0, n)
                    .reduce((a, b) -> processors[a].peek() < processors[b].peek() ? a : b)
                    .getAsInt();
            // 取出最早空闲的核心时间并更新
            int earliest = processors[minIndex].poll();
            processors[minIndex].offer(earliest + tasks[i]);
        });

        // 找到所有处理器中最晚的完成时间
        return IntStream.range(0, n)
                .flatMap(i -> processors[i].stream().mapToInt(Integer::intValue))
                .max()
                .orElse(0);
    }
}