程序员必须掌握的算法系列之贪心算法

news2025/1/12 22:51:08

一：引言

在计算机科学中，贪心算法（Greedy Algorithm）是一种基于贪心策略的算法思想，它在每一步选择中都采取当前状态下最优的选择，以希望最终能够得到全局最优解。贪心算法通常可以在较短的时间内找到问题的近似最优解，尤其适用于解决一些优化问题或拟合问题。

贪心算法在程序员的日常开发中非常常见，这是因为贪心算法能够快速得到一个可行解，在某些特定场景下能够得到最优解或近似最优解。因此，作为一名程序员，掌握贪心算法是必不可少的。

二：常见贪心算法介绍

1. 找零钱问题

找钱问题
找零钱问题是贪心算法的经典问题之一。问题描述：给定一个金额和不同面额的硬币，要求找零钱时所需的硬币数量最少。贪心策略是每次选择面额最大的硬币进行找零。以下是Java代码示例：

public class Change{
    public static int findMinCoins(int[] coins, int amount) {
        Arrays.sort(coins);
        int count = 0;
        for (int i = coins.length - 1; i >= 0; i--) {
            while (amount >= coins[i]) {
                amount -= coins[i];
                count++;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        int[] coins = {1, 5, 10, 25};
        int amount = 36;
        int minCoins = findMinCoins(coins, amount);
        System.out.println("最少需要 " + minCoins + " 枚硬币来找零 " + amount + " 元。");
    }
}

Python代码示例：

def find_min_coins(coins, amount):
    coins.sort(reverse=True)
    count = 0
    for coin in coins:
        while amount >= coin:
            amount -= coin
            count += 1
    return count

coins = [1, 5, 10, 25]
amount = 36
min_coins = find_min_coins(coins, amount)
print("最少需要", min_coins, "枚硬币来找零", amount, "元。")

2. 区间调度问题

在区间调度问题中，给定若干个区间，要求找到一个最大的互不重叠的子集。贪心策略是按照结束时间早的顺序对区间进行排序，然后从前往后依次选择互不重叠的区间。以下是Java代码示例：

public class IntervalSchedule{
    public static int findMaxNonOverlap(Inteval[] intervals){
        if(intervals == null || intervals.length == 0){
            return 0;
        }
        Arrays.sort(intervals, (a,b) -> a.end - b.end); // 按照结束时间排序
        int count = 1; // 至少有一个互不重叠的区间
        int end = intervals[0].end;
        for(int i=1; i<intervals.length; i++){
            if(intervals[i].start >= end){
                count++;
                end = intervals[i].end;
            }
        }
        return count;
    }

    public static void main(String[] args){
        Interval[] intervals = new Interval[4];
        intervals[0] = new Interval(1, 3);
        intervals[1] = new Interval(2, 4);
        intervals[2] = new Interval(3, 5);
        intervals[3] = new Interval(4, 6);
        int maxNonOverlap = findMaxNonOverlap(intervals);
        System.out.println("最多能够安排" + maxNonOverlap + "个互不重叠的区间。");
    }
}

Python代码示例：

class Interval:
    def __init__(self, start, end):
        self.start = start
        self.end = end

def find_max_non_overlap(intervals):
    intervals.sort(key=lambda x: x.end)  # 按照结束时间排序
    count = 1  # 至少有一个互不重叠的区间
    end = intervals[0].end
    for i in range(1, len(intervals)):
        if intervals[i].start >= end:
            count += 1
            end = intervals[i].end
    return count

intervals = []
intervals.append(Interval(1, 3))
intervals.append(Interval(2, 4))
intervals.append(Interval(3, 5))
intervals.append(Interval(4, 6))
max_non_overlap = find_max_non_overlap(intervals)
print("最多能够安排", max_non_overlap, "个互不重叠的区间。")