【leectode 2022.1.22】批量处理任务

某实验室计算机待处理任务以 [start,end,period] 格式记于二维数组 tasks，表示完成该任务的时间范围为起始时间 start 至结束时间 end 之间，需要计算机投入 period 的时长，注意：

period 可为不连续时间
首尾时间均包含在内
处于开机状态的计算机可同时处理任意多个任务，请返回电脑最少开机多久，可处理完所有任务。

示例 1：

输入：tasks = [[1,3,2],[2,5,3],[5,6,2]]

输出：4

解释：
tasks[0] 选择时间点 2、3；
tasks[1] 选择时间点 2、3、5；
tasks[2] 选择时间点 5、6；
因此计算机仅需在时间点 2、3、5、6 四个时刻保持开机即可完成任务。

示例 2：

输入：tasks = [[2,3,1],[5,5,1],[5,6,2]]

输出：3

解释：
tasks[0] 选择时间点 2 或 3；
tasks[1] 选择时间点 5；
tasks[2] 选择时间点 5、6；
因此计算机仅需在时间点 2、5、6 或 3、5、6 三个时刻保持开机即可完成任务。

提示：

2 <= tasks.length <= 10^5
tasks[i].length == 3
0 <= tasks[i][0] <= tasks[i][1] <= 10^9
1 <= tasks[i][2] <= tasks[i][1]-tasks[i][0] + 1

java代码：

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

class Pair {
    public int slots;
    public int index;

    public Pair(int slots, int index) {
        this.slots = slots;
        this.index = index;
    }
}

class PairComparator implements Comparator<Pair> {
    @Override
    public int compare(Pair p1, Pair p2) {
        if (p1.slots > p2.slots || (p1.slots == p2.slots && p1.index > p2.index)) {
            return 1;
        } else if (p1.slots < p2.slots || p1.index < p2.index) {
            return -1;
        }
        return 0;
    }
}

class Solution {
    public int processTasks(int[][] tasks) {
        int n = tasks.length;
        var ts = new TreeSet<Integer>();
        for (var task : tasks) {
            ts.add(task[0]);
            ts.add(task[1] + 1);
        }
        var vt = new ArrayList<>(ts);
        int m = vt.size();
        var mp = new HashMap<Integer, Integer>(m);
        for (int i = 0; i < m; ++i) {
            mp.put(vt.get(i), i);
        }

        var starts = Stream.generate(ArrayList<Integer>::new)
                .limit(m)
                .collect(Collectors.toList());
        for (int i = 0; i < n; ++i) {
            starts.get(mp.get(tasks[i][0])).add(i);
        }

        int ans = 0;
        int extra = 0;
        var pq = new PriorityQueue<Pair>(n, new PairComparator());

        for (int i = 0; i < m - 1; ++i) {
            while (!pq.isEmpty() && tasks[pq.peek().index][1] < vt.get(i)) {
                pq.poll();
            }

            for (int u : starts.get(i)) {
                pq.add(new Pair(extra + tasks[u][1] - vt.get(i) + 1 - tasks[u][2], u));
            }

            int currentSeg = vt.get(i + 1) - vt.get(i);
            if (!pq.isEmpty()) {
                int minSlots = pq.peek().slots - extra;
                int slotsToDel = currentSeg;

                if (minSlots < currentSeg) {
                    int delta = currentSeg - minSlots;
                    ans += delta;
                    slotsToDel -= delta;
                }

                extra += slotsToDel;
            }
        }

        return ans;
    }
}