Java 中的贪心算法应用：活动安排问题
**
贪心算法以其高效性和直观性，在众多算法问题求解中占据重要地位。在活动安排场景下，贪心算法同样能发挥出色的作用。接下来，我们将深入探讨活动安排问题，并展示其 Java 实现过程。
一、问题定义
活动安排问题可以描述为：给定一系列活动，每个活动都有开始时间和结束时间，目标是在同一时间资源限制下，选择尽可能多的活动来执行，且这些活动之间不能在时间上存在重叠。
问题示例
假设有以下活动及其时间安排（已按开始时间排序）：
活动 A：10:00 - 11:00
活动 B：10:30 - 12:00
活动 C：11:30 - 12:30
活动 D：12:00 - 13:00
活动 E：13:30 - 14:30
在同一时间只能进行一个活动的情况下，最多能安排多少个活动？
二、问题分析
关键点
时间重叠：若两个活动的时间区间有重叠部分，就不能同时进行
最大化活动数量：目标是选取数量最多的活动组合
贪心选择：每次都选择 "最有利" 的活动加入已选集合
解决思路
排序：首先将所有活动按照结束时间进行升序排序
贪心选择：依次遍历活动，只要当前活动的开始时间大于等于已选活动中最后一个活动的结束时间，就将该活动加入已选活动集合
三、算法设计
算法步骤
- 将所有活动按照结束时间升序排序
- 初始化一个列表，用于存储已选活动
- 遍历每个活动：
-
- 如果列表为空，直接将当前活动加入列表
-
- 如果当前活动的开始时间大于等于列表中最后一个活动的结束时间，则将当前活动加入列表
- 最终列表的大小就是能够安排的最多活动数量
为什么使用按结束时间排序？
按结束时间排序可以确保每次选择的活动是最早结束的，这样后续能为其他活动留出更多的可用时间，从而更有可能选出更多不重叠的活动。
四、Java 实现
1. 活动表示类
arduino
class Activity {
int start;
int end;
public Activity(int start, int end) {
this.start = start;
this.end = end;
}
@Override
public String toString() {
return "[" + start + ", " + end + "]";
}
}2. 解决方案实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ActivityScheduling {
/**
* 计算最多能安排的活动数量
* @param activities 活动时间区间数组
* @return 最多能安排的活动数量
*/
public static int maxActivities(Activity[] activities) {
if (activities == null || activities.length == 0) {
return 0;
}
// 1. 按照结束时间排序
Arrays.sort(activities, (a, b) -> a.end - b.end);
// 2. 创建列表存储已选活动
List<Activity> selectedActivities = new ArrayList<>();
selectedActivities.add(activities[0]);
// 3. 遍历剩余的活动
for (int i = 1; i < activities.length; i++) {
Activity current = activities[i];
Activity lastSelected = selectedActivities.get(selectedActivities.size() - 1);
// 如果当前活动的开始时间 >= 已选最后一个活动的结束时间
// 则可以选择该活动
if (current.start >= lastSelected.end) {
selectedActivities.add(current);
}
}
// 4. 列表的大小就是最多能安排的活动数量
return selectedActivities.size();
}
public static void main(String[] args) {
// 示例数据
Activity[] activities = {
new Activity(1000, 1100),
new Activity(1030, 1200),
new Activity(1130, 1230),
new Activity(1200, 1300),
new Activity(1330, 1430)
};
int maxActs = maxActivities(activities);
System.out.println("最多能安排的活动数量: " + maxActs);
}
}3. 输出结果
对于给定的示例，程序将输出：
最多能安排的活动数量: 3
五、算法复杂度分析
时间复杂度
排序：O (n log n)，其中 n 是活动数量
遍历：O (n)，每个活动最多被遍历一次
总时间复杂度：O (n log n)
空间复杂度
O (n) 用于存储排序后的活动列表（在最坏情况下，所有活动都能被选入）
总空间复杂度：O (n)
六、算法正确性证明
贪心算法的正确性通常需要证明两点：
贪心选择性质
每一步选择最早结束的活动是正确的，因为这样能为后续活动留出尽可能多的可用时间。若存在一个最优解不包含最早结束的活动，通过交换操作，依然可以得到一个最优解。
最优子结构
在选择第 i 个活动时，前 i - 1 个活动的最优选择不会影响后续活动的选择，子问题的最优解能够组合成原问题的最优解。
七、变种与扩展
- 输出具体的活动安排方案：除了计算最多活动数量，还可以修改算法来输出具体的活动安排。在遍历活动过程中，记录每个被选中活动的信息，最后返回存储活动信息的列表。
- 带权重的活动安排：如果每个活动有不同的权重（如活动的重要程度），问题变为在时间资源限制下最大化权重和。此时，贪心算法可能不再适用，需要使用动态规划等方法来解决。
- 多时间资源的活动安排：考虑有多个并行的时间资源（如多个会议室），在这种情况下，活动安排问题会更加复杂，需要综合考虑多个时间资源的使用情况来进行活动分配。
八、实际应用场景
项目任务调度：在软件开发项目中，合理安排各项任务的执行顺序
会议安排：在企业或组织中，高效安排各类会议的时间
课程表编排：学校为学生和教师安排课程时间表
体育赛事赛程安排：在举办体育赛事时，确定各项比赛的时间
九、与其他算法的比较
贪心算法 vs 暴力搜索
暴力搜索尝试所有可能的活动选择组合，复杂度极高（O (2^n)）；贪心算法通过局部最优选择达到全局最优，效率更高。
贪心算法 vs 动态规划
动态规划可以解决更复杂的带权重活动安排等一般问题；贪心算法更简单直观，但只适用于满足贪心选择性质和最优子结构的特定问题。
贪心算法 vs 回溯算法
回溯算法可以找到所有可能的活动安排解；贪心算法只找到一个较优解，但效率比回溯算法高得多。
十、边界情况处理
在实际实现中，需要考虑以下边界情况：
- 空输入：没有活动时返回 0
- 单个活动：只有一个活动时，能安排的活动数量为 1
- 完全重叠的活动：所有活动都重叠时，能安排的活动数量为 1
- 完全不重叠的活动：所有活动都不重叠时，能安排的活动数量为活动总数
十一、测试用例设计
完整的实现应该包含以下测试用例：
scss
import org.junit.Test;
import static org.junit.Assert.*;
public class ActivitySchedulingTest {
@Test
public void testEmptyInput() {
Activity[] activities = {};
assertEquals(0, ActivityScheduling.maxActivities(activities));
}
@Test
public void testSingleInterval() {
Activity[] activities = {new Activity(1000, 1100)};
assertEquals(1, ActivityScheduling.maxActivities(activities));
}
@Test
public void testNonOverlappingIntervals() {
Activity[] activities = {
new Activity(1000, 1100),
new Activity(1100, 1200),
new Activity(1200, 1300)
};
assertEquals(3, ActivityScheduling.maxActivities(activities));
}
@Test
public void testAllOverlappingIntervals() {
Activity[] activities = {
new Activity(1000, 1100),
new Activity(1000, 1100),
new Activity(1000, 1100)
};
assertEquals(1, ActivityScheduling.maxActivities(activities));
}
@Test
public void testComplexCase() {
Activity[] activities = {
new Activity(1000, 1100),
new Activity(1030, 1200),
new Activity(1130, 1230),
new Activity(1200, 1300),
new Activity(1330, 1430)
};
assertEquals(3, ActivityScheduling.maxActivities(activities));
}
}十二、性能优化
虽然算法已经是 O (n log n) 复杂度，但在实际应用中还可以考虑以下优化：
- 原始数据预处理：如果数据已经排序，可以跳过排序步骤
- 自定义排序：对于特定数据分布，可以使用更高效的排序算法
- 并行处理：对于极大数量级的活动，可以考虑并行处理
- 内存优化：如果不需要记录具体的活动信息，可以只维护活动的开始和结束时间，减少内存占用
十三、可视化理解
为了更好地理解算法，我们可以可视化处理过程：
时间轴: 10:00 10:30 11:00 11:30 12:00 12:30 13:00 13:30 14:00 14:30
活动 A: |=========| (10:00 - 11:00)
活动 B: |=============| (10:30 - 12:00)
活动 C: |=========| (11:30 - 12:30)
活动 D: |=========| (12:00 - 13:00)
活动 E: |=========| (13:30 - 14:30)
已选活动变化过程:
- 初始：空
- 处理 A: [A]
- 处理 B: 11:00 < 10:30 → 不选
- 处理 C: 11:00 ≤ 11:30 → 选 C → [A, C]
- 处理 D: 12:30 > 12:00 → 不选
- 处理 E: 12:30 ≤ 13:30 → 选 E → [A, C, E]
最终已选活动数量: 3
十四、常见错误与陷阱
在实现过程中，开发者容易犯以下错误：
- 错误的排序标准：按开始时间而非结束时间排序
- 忽略边界条件：活动开始时间等于另一个活动结束时间的情况
- 逻辑判断错误：在判断活动是否重叠时出现逻辑漏洞
- 数据类型问题：使用不合适的数据类型表示时间，导致时间比较错误
十五、相关 LeetCode 题目
无重叠区间（LeetCode 435） - 类似问题，需要移除最少数量的区间使剩余区间不重叠
最大活动数量（可自定义类似题目） - 直接对应本问题
任务调度（LeetCode 621） - 涉及任务安排的相关问题
十六、总结
活动安排问题是贪心算法的典型应用之一。通过按结束时间排序活动、利用贪心策略选择活动，能够高效地解决问题。Java 实现借助数组排序和列表操作，实现了对活动的有效管理。该算法时间复杂度为 O (n log n)，空间复杂度为 O (n) ，在多种资源分配和任务调度场景中都具有很高的实用价值，且易于理解和实现。
上述内容从多方面呈现了贪心算法在活动安排问题中的应用。若你对内容深度、其他应用场景等有新想法，欢迎随时告诉我。
欢迎关注 ❤
我们搞了一个免费的面试真题共享群，互通有无，一起刷题进步。
没准能让你能刷到自己意向公司的最新面试题呢。
感兴趣的朋友们可以加我微信：wangzhongyang1993，备注：面试群。