从一团乱麻到井然有序：我的海量任务调度“秘密武器”（ 1353. 最多可以参加的会议数目）-CSDN博客

从一团乱麻到井然有序：我的海量任务调度“秘密武器” 😎

大家好，我是你们的老朋友，一个在代码世界里摸爬滚打多年的开发者。今天，我想和大家聊一个我最近在项目中遇到的一个非常棘手但又超有趣的问题，以及我是如何用一些经典的算法思想把它漂亮地解决的。相信我，这个故事不仅能让你学到东西，还会让你感受到算法的魅力！😉

我遇到了什么问题？

想象一下，我们正在开发一个大型的“全球开发者大会”在线平台。其中一个核心功能是为参会者提供一个“AI行程管家”，这个管家需要根据参会者感兴趣的所有议题（Events），自动规划出一个能参加最多场次议题的日程表。

每个议题都有一个开始日期 startDay 和一个结束日期 endDay，参会者可以在这个时间窗口内的任意一天参加该议题。但有一个硬性规定：一天只能参加一个议题。

初期，议题数量不多，随便搞搞都能应付。但随着平台上线，议题数量瞬间飙升到十万级别（10^5），日期范围也同样广阔。我的第一版天真烂漫的调度代码瞬间崩了，用户疯狂投诉：“AI管家怎么这么笨，好多会议明明可以参加的！”

看着后台那一堆 events = [[1,5], [2,3], [3,4], ...] 的数据，我陷入了沉思 🤔。这不就是一道活生生的算法题吗？1353. 最多可以参加的会议数目。

我是如何用贪心算法解决的

当面临“最优选择”问题时，我的第一反应就是：贪心算法！贪心，就是每一步都做出当前看起来最好的选择，并期望最终能得到全局最优解。但关键是，怎么“贪”才是正确的呢？

第一次尝试的“坑” 踩坑经验

我最初的想法很简单：按会议的开始时间排序，谁先开始就先给谁安排。听起来很合理对吧？

比如 events = [[1,2], [1,5], [2,3]]

先看 [1,2]，在第1天安排它。日程 [Day1: event_1]
再看 [1.5]，第1天被占了，就在第2天安排它。日程 [Day1: event_1, Day2: event_2]
最后看 [2,3]，第2天也被占了，就在第3天安排它。日程 [Day1: event_1, Day2: event_2, Day3: event_3]
完美！参加了3个会议。

但很快，我就找到了反例：events = [[1,10], [2,2], [3,3], [4,4]]
如果按开始时间贪心：

安排 [1,10] 在第1天。
然后…就没有然后了。其他三个会议的开始时间（2, 3, 4）虽然也在 [1,10] 的区间内，但我们一天只能参加一个会，第1天已经被这个“巨无霸”会议占了，后面的天也同样。最终只能参加1个会议。

而显而易见的最好策略是放弃 [1,10]，去参加后面那三个短会，总共可以参加3个。

恍然大悟的瞬间 😉：我的“贪心”策略错了！优先考虑开始早的，可能会导致我们过早地锁定一个结束晚、选择范围大的会议，从而错失掉好几个稍晚开始但即将结束的会议。问题的关键在于结束时间！

解法一：模拟每一天，优先“救火”🔥（贪心 + 最小堆）

正确的贪心思路应该是：我们模拟时间的流逝，一天一天地前进。在每一天 d，我们都问自己一个问题：“今天我可以参加的所有会议中，我应该参加哪一个？”

答案是：参加那个即将结束的会议！

为什么呢？因为那些结束晚的会议，我们明天、后天可能还有机会参加。而那个明天就要结束的会议，如果今天不参加，就永远没机会了。这就像救火一样，我们得先去救那个火势最急、最快要烧完的屋子。

为了实现这个策略，我需要一个工具，它能帮我做到：

把所有今天能参加的会议都放进一个“候选池”。
能让我快速地从池子里拿出那个结束日期最早的会议。

这不就是最小堆（Min-Heap） 的完美应用场景吗！在Java里，它叫 PriorityQueue。

具体步骤：

先把所有会议按开始日期排序。这样，当我们模拟到第 d 天时，就可以很方便地把所有在 d 天开始的会议加入候选池。
创建一个最小堆 pq，用来存放候选会议的结束日期。
从第1天开始，一天天向后遍历。
在第 d 天：
a. 把所有在第 d 天开始的会议的结束日期 endDay 扔进最小堆。
b. 清理一下堆，把那些已经结束了的（endDay < d）会议从堆顶移除。
c. 如果堆不为空，说明今天有会议可开！我们从堆顶 poll() 一个出来（这就是结束最早的那个），然后把计数器加一。搞定收工，今天的工作结束！

import java.util.Arrays;
import java.util.PriorityQueue;

class Solution1 {
    public int maxEvents(int[][] events) {
        // 1. 按会议开始时间排序，方便按天推进
        Arrays.sort(events, (a, b) -> a[0] - b[0]);

        // 2. 最小堆，按结束时间升序排列，这就是我们的“候选池”
        // PriorityQueue 默认就是最小堆，完美！
        PriorityQueue<Integer> pq = new PriorityQueue<>();

        int count = 0; // 计数器
        int eventIndex = 0; // 扫到哪个会议了
        int n = events.length;

        // 找到最大的天数，确定我们模拟的范围
        int maxDay = 0;
        for (int[] event : events) {
            maxDay = Math.max(maxDay, event[1]);
        }
      
        // 3. 按天模拟
        for (int day = 1; day <= maxDay; day++) {
            // 4a. 将今天开始的会议的结束时间加入候选池
            while (eventIndex < n && events[eventIndex][0] == day) {
                // pq.offer(value) 是入队操作，时间复杂度 O(log k)
                pq.offer(events[eventIndex][1]);
                eventIndex++;
            }

            // 4b. 清理掉已经过期的会议
            // pq.peek() 查看堆顶元素但不移除，O(1)
            while (!pq.isEmpty() && pq.peek() < day) {
                // pq.poll() 移除并返回堆顶元素，O(log k)
                pq.poll();
            }

            // 4c. 如果还有候选会议，就参加一个！
            if (!pq.isEmpty()) {
                pq.poll(); // 参加这个结束最早的会议
                count++;
            }
        }
        return count;
    }
}

这种方法思路清晰，模拟了我们日常做决策的过程，非常直观！🚀

解法二：任务驱动，抢占先机 💡 (贪心 + 并查集)

换个角度思考。我们不按天来，而是按会议来。既然结束早的会议更“紧急”，那我们就把所有会议按结束日期排序，优先处理那些 deadline 最近的。

对于每个会议 [start, end]，我们的贪心策略是：为了给后面的会议（它们的deadline更晚）留出更多选择，我们应该为当前会议安排一个尽可能早的、并且还没被占用的天。

现在问题来了：如何高效地“找到从 start 开始的第一个可用天”？

用一个布尔数组 used[day] 记录每天是否被占用，然后从 start 循环到 end？这在 start 很小 end 很大的时候效率太低了，总体复杂度会退化到 O(N*D)，直接超时。

这时，我的“秘密武器”登场了：并查集 (Union-Find / Disjoint Set Union)！

可能你会觉得并查集是用来处理“连通分量”这种图论问题的，跟日期安排有什么关系？别急，看我怎么把它变废为宝😉。

改造思路：

我们把 1 到 maxDay+1 的每一天看作一个独立的集合。
我们用一个 parent 数组，让 parent[i] 指向 i 这个集合的代表元。我们赋予这个代表元一个新的含义：从第 i 天起，第一个可用的天是几号。
初始时，每天都可用，所以 parent[i] = i。
当我们占用了第 d 天后，就意味着第 d 天不再可用。下一次再想找从 d 开始的可用天时，应该直接去 d+1 找。所以我们把 d 和 d+1 合并 (union)，parent[d] = d+1。
这样，find(d) 操作就能自动地“跳过”所有被占用的天，直接返回那一连串被占用天之后的第一个可用天！

而find操作中那个神奇的路径压缩优化， parent[i] = find(parent[i])，就像一个极其聪明的助理。第一次你问他“1号之后的可用天是几号？”，他可能要一步步帮你找 1->2->3->...->k。但在找到 k 的同时，他会顺手把 1, 2, 3… 的联系方式都直接更新成 k。下次你再问，他就能秒回！这让 find 操作的平均时间复杂度近乎 O(1)！

import java.util.Arrays;

class Solution2 {
    private int[] parent;
  
    // find 操作，带路径压缩优化，这行代码是精髓！
    private int find(int i) {
        if (parent[i] == i) {
            return i;
        }
        // 递归查找根的同时，把路径上所有节点直接指向根
        parent[i] = find(parent[i]); 
        return parent[i];
    }
  
    public int maxEvents(int[][] events) {
        // 1. 按结束时间排序，优先处理deadline近的会议
        Arrays.sort(events, (a, b) -> a[1] - b[1]);

        // 2. 初始化并查集
        int maxDay = 0;
        for (int[] event : events) {
            maxDay = Math.max(maxDay, event[1]);
        }
        parent = new int[maxDay + 2];
        for (int i = 0; i <= maxDay + 1; i++) {
            parent[i] = i;
        }
      
        int count = 0;
        for (int[] event : events) {
            int start = event[0];
            int end = event[1];
          
            // 3. 寻找从 start 开始的第一个可用天
            int availableDay = find(start);
          
            // 4. 如果找到的可用天没超过会议的结束日期，就安排它！
            if (availableDay <= end) {
                count++;
                // 占用这一天，将其指向它的下一天
                // find(availableDay + 1) 是为了保证链式合并
                parent[availableDay] = find(availableDay + 1); 
            }
        }
        return count;
    }
}