当前位置：首页 > news >正文

贪心算法应用：活动选择问题详解

news 2025/9/17 7:20:14

在这里插入图片描述

Java中的贪心算法应用：活动选择问题详解

贪心算法是一种在每一步选择中都采取当前状态下最优的选择，从而希望导致结果是全局最优的算法策略。活动选择问题是贪心算法的一个经典应用场景。下面我将从多个维度全面详细地讲解这个问题及其Java实现。

一、问题定义

1.1 问题描述

活动选择问题(Activity Selection Problem)是指给定一组活动，每个活动都有一个开始时间和结束时间，要求从中选择出最大数量的互不冲突的活动（即这些活动的时间段不重叠）。

1.2 形式化定义

给定：

n个活动的集合S = {a₁, a₂, …, aₙ}
每个活动aᵢ有一个开始时间sᵢ和结束时间fᵢ，其中0 ≤ sᵢ < fᵢ < ∞

求：

最大兼容活动子集A ⊆ S，其中对于任意两个活动aᵢ, aⱼ ∈ A，有[sᵢ, fᵢ)和[sⱼ, fⱼ)不重叠

二、贪心算法解决思路

2.1 贪心选择性质

活动选择问题具有贪心选择性质，即局部最优选择能导致全局最优解。具体策略是：

按照结束时间对活动进行排序
总是选择结束时间最早的活动
然后排除与该活动时间冲突的所有活动
重复上述过程，直到没有活动可选

2.2 为什么贪心算法有效

贪心算法有效的关键在于：

选择结束时间最早的活动可以为后续活动留下尽可能多的时间
这种选择方式能确保最大数量的活动被安排
数学上可以证明这种策略能得到最优解

三、Java实现详解

3.1 活动类定义

首先定义一个表示活动的类：

public class Activity {private String name;    // 活动名称private int startTime; // 开始时间private int endTime;   // 结束时间public Activity(String name, int startTime, int endTime) {this.name = name;this.startTime = startTime;this.endTime = endTime;}// Getterspublic String getName() { return name; }public int getStartTime() { return startTime; }public int getEndTime() { return endTime; }@Overridepublic String toString() {return name + "(" + startTime + "-" + endTime + ")";}
}

3.2 贪心算法实现

3.2.1 递归实现

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;public class ActivitySelection {// 递归实现public static List<Activity> selectActivitiesRecursive(List<Activity> activities) {// 先按照结束时间排序activities.sort(Comparator.comparingInt(Activity::getEndTime));List<Activity> selected = new ArrayList<>();// 第一个活动总是被选中（结束时间最早）selected.add(activities.get(0));// 递归选择剩余活动selectRecursive(activities, 0, selected);return selected;}private static void selectRecursive(List<Activity> activities, int lastSelectedIndex, List<Activity> selected) {// 找到下一个开始时间 >= 上一个选中活动结束时间的活动int nextIndex = lastSelectedIndex + 1;while (nextIndex < activities.size() && activities.get(nextIndex).getStartTime() < activities.get(lastSelectedIndex).getEndTime()) {nextIndex++;}// 如果找到符合条件的活动if (nextIndex < activities.size()) {selected.add(activities.get(nextIndex));selectRecursive(activities, nextIndex, selected);}// 否则递归终止}
}

3.2.2 迭代实现（更高效）

public static List<Activity> selectActivitiesIterative(List<Activity> activities) {// 先按照结束时间排序activities.sort(Comparator.comparingInt(Activity::getEndTime));List<Activity> selected = new ArrayList<>();// 第一个活动总是被选中selected.add(activities.get(0));int lastSelectedIndex = 0;// 遍历剩余活动for (int i = 1; i < activities.size(); i++) {// 如果当前活动的开始时间 >= 上一个选中活动的结束时间if (activities.get(i).getStartTime() >= activities.get(lastSelectedIndex).getEndTime()) {selected.add(activities.get(i));lastSelectedIndex = i;}}return selected;
}

3.3 测试代码

public static void main(String[] args) {List<Activity> activities = new ArrayList<>();activities.add(new Activity("A1", 1, 4));activities.add(new Activity("A2", 3, 5));activities.add(new Activity("A3", 0, 6));activities.add(new Activity("A4", 5, 7));activities.add(new Activity("A5", 3, 9));activities.add(new Activity("A6", 5, 9));activities.add(new Activity("A7", 6, 10));activities.add(new Activity("A8", 8, 11));activities.add(new Activity("A9", 8, 12));activities.add(new Activity("A10", 2, 14));activities.add(new Activity("A11", 12, 16));System.out.println("所有活动:");activities.forEach(System.out::println);System.out.println("\n递归选择结果:");List<Activity> selectedRecursive = selectActivitiesRecursive(activities);selectedRecursive.forEach(System.out::println);System.out.println("\n迭代选择结果:");List<Activity> selectedIterative = selectActivitiesIterative(activities);selectedIterative.forEach(System.out::println);
}

四、算法分析

4.1 时间复杂度

排序阶段：O(n log n) - 使用快速排序或归并排序
选择阶段：
- 递归实现：最坏情况下O(n)，因为每个活动最多被检查一次
- 迭代实现：O(n)，因为只需要一次遍历

总体时间复杂度为O(n log n)，主要由排序阶段决定。

4.2 空间复杂度

递归实现：O(n) - 由于递归调用栈的深度在最坏情况下为n
迭代实现：O(1) - 除了结果存储外，只需要常数空间

五、算法正确性证明

贪心算法的正确性可以通过贪心选择性质和最优子结构性质来证明：

5.1 贪心选择性质

设活动按结束时间排序为a₁, a₂, …, aₙ，且f₁ ≤ f₂ ≤ … ≤ fₙ。

定理：存在一个最优解包含活动a₁。

证明：
设A是一个最优解，且A中第一个活动是aₖ。

如果k=1，定理成立
如果k≠1，构造解A’ = (A - {aₖ}) ∪ {a₁}
因为f₁ ≤ fₖ，A’中的活动都是兼容的
|A’| = |A|，所以A’也是最优解

5.2 最优子结构性质

设Sᵢⱼ = {aₖ ∈ S | fᵢ ≤ sₖ < fₖ ≤ sⱼ}，即所有开始时间不早于aᵢ结束，结束时间不晚于aⱼ开始的活动。

定理：如果Aᵢⱼ是Sᵢⱼ的一个最优解，且aₖ ∈ Aᵢⱼ，则Aᵢⱼ = Aᵢₖ ∪ {aₖ} ∪ Aₖⱼ。

这表明问题具有最优子结构性质，即最优解包含子问题的最优解。

六、变种与扩展

6.1 加权活动选择

每个活动有一个权重，目标是选择权重和最大的兼容活动集。这时贪心算法不再适用，需要使用动态规划。

6.2 多资源活动选择

有多个资源（如多个会议室），需要安排尽可能多的活动。可以使用贪心算法结合优先队列。

6.3 最早开始时间优先

如果改为选择最早开始的活动，贪心算法可能得不到最优解。例如：

活动A: 0-6
活动B: 1-4
活动C: 5-7

最早开始优先会选择A，而最优解是B和C。

七、实际应用场景

会议室安排：选择最多数量的会议安排在有限的会议室中
课程表安排：安排最多数量的课程不冲突
任务调度：在单处理器上调度最多数量的任务
电视节目安排：选择最多数量的电视节目观看而不冲突
交通调度：安排火车或飞机在跑道上的起降时间

八、完整Java实现示例

下面是一个更完整的实现，包含更多功能和测试用例：

import java.util.*;
import java.util.stream.Collectors;public class AdvancedActivitySelection {public static void main(String[] args) {// 测试用例1：标准情况List<Activity> activities1 = Arrays.asList(new Activity("A1", 1, 4),new Activity("A2", 3, 5),new Activity("A3", 0, 6),new Activity("A4", 5, 7),new Activity("A5", 3, 9),new Activity("A6", 5, 9),new Activity("A7", 6, 10),new Activity("A8", 8, 11),new Activity("A9", 8, 12),new Activity("A10", 2, 14),new Activity("A11", 12, 16));testSelection(activities1, "标准测试用例");// 测试用例2：所有活动都冲突List<Activity> activities2 = Arrays.asList(new Activity("B1", 1, 5),new Activity("B2", 2, 6),new Activity("B3", 3, 7),new Activity("B4", 4, 8));testSelection(activities2, "所有活动冲突的情况");// 测试用例3：没有活动冲突List<Activity> activities3 = Arrays.asList(new Activity("C1", 1, 2),new Activity("C2", 3, 4),new Activity("C3", 5, 6),new Activity("C4", 7, 8));testSelection(activities3, "没有活动冲突的情况");// 测试用例4：单个活动List<Activity> activities4 = Collections.singletonList(new Activity("D1", 1, 2));testSelection(activities4, "单个活动的情况");// 测试用例5：空列表testSelection(new ArrayList<>(), "空活动列表");}private static void testSelection(List<Activity> activities, String testCaseName) {System.out.println("\n=== " + testCaseName + " ===");System.out.println("所有活动 (" + activities.size() + "个):");activities.forEach(a -> System.out.println("  " + a));List<Activity> selected = selectActivities(activities);System.out.println("\n选择结果 (" + selected.size() + "个活动):");selected.forEach(a -> System.out.println("  " + a));}public static List<Activity> selectActivities(List<Activity> activities) {if (activities == null || activities.isEmpty()) {return new ArrayList<>();}// 防御性拷贝List<Activity> sortedActivities = new ArrayList<>(activities);// 按照结束时间排序sortedActivities.sort(Comparator.comparingInt(Activity::getEndTime));List<Activity> selected = new ArrayList<>();selected.add(sortedActivities.get(0));int lastSelectedIndex = 0;for (int i = 1; i < sortedActivities.size(); i++) {Activity current = sortedActivities.get(i);Activity lastSelected = sortedActivities.get(lastSelectedIndex);if (current.getStartTime() >= lastSelected.getEndTime()) {selected.add(current);lastSelectedIndex = i;}}return selected;}// 带权重的活动选择（动态规划解法）public static List<Activity> selectWeightedActivities(List<WeightedActivity> activities) {if (activities == null || activities.isEmpty()) {return new ArrayList<>();}// 按照结束时间排序List<WeightedActivity> sorted = new ArrayList<>(activities);sorted.sort(Comparator.comparingInt(WeightedActivity::getEndTime));int n = sorted.size();int[] dp = new int[n + 1];// dp[i]表示前i个活动的最大权重dp[0] = 0;dp[1] = sorted.get(0).getWeight();for (int i = 2; i <= n; i++) {WeightedActivity current = sorted.get(i - 1);int latestNonConflict = findLatestNonConflict(sorted, i - 1);int includeWeight = current.getWeight();if (latestNonConflict != -1) {includeWeight += dp[latestNonConflict + 1];}int excludeWeight = dp[i - 1];dp[i] = Math.max(includeWeight, excludeWeight);}// 回溯找出具体选择了哪些活动return reconstructSolution(sorted, dp);}private static int findLatestNonConflict(List<WeightedActivity> activities, int index) {for (int i = index - 1; i >= 0; i--) {if (activities.get(i).getEndTime() <= activities.get(index).getStartTime()) {return i;}}return -1;}private static List<Activity> reconstructSolution(List<WeightedActivity> activities, int[] dp) {List<Activity> result = new ArrayList<>();int i = activities.size();while (i > 0) {if (i == 1) {result.add(activities.get(0));break;}if (dp[i] == dp[i - 1]) {i--;} else {result.add(activities.get(i - 1));int latestNonConflict = findLatestNonConflict(activities, i - 1);i = latestNonConflict + 1;}}Collections.reverse(result);return result;}
}class WeightedActivity extends Activity {private int weight;public WeightedActivity(String name, int startTime, int endTime, int weight) {super(name, startTime, endTime);this.weight = weight;}public int getWeight() {return weight;}
}