算法讲解——贪心算法

露西西★

已于 2025-03-27 17:58:15 修改

阅读量1.2k

点赞数 10

分类专栏：刷题文章标签：贪心算法算法 javascript 前端数据结构

于 2025-03-18 15:22:30 首次发布

本文链接：https://blog.youkuaiyun.com/qq_62541773/article/details/146342301

版权

刷题专栏收录该内容

46 篇文章

订阅专栏

贪心算法（Greedy Algorithm）是一种在每一步选择中都采取当前状态下最优（局部最优）的选择，从而希望导致全局最优解的算法策略。贪心算法的核心思想是“贪心选择”，即通过局部最优解逐步构建全局最优解。

一、贪心算法的特点

局部最优选择：在每一步决策中，选择当前看起来最优的解决方案。
无后效性：当前的选择不会影响后续的选择，即不会回退或重新选择。
不保证全局最优：贪心算法不一定能得到全局最优解，但在某些问题中可以得到最优解。

二、贪心算法的适用场景

贪心算法适用于满足以下条件的问题：

最优子结构：问题的最优解包含子问题的最优解。
贪心选择性质：通过局部最优选择能够达到全局最优解。

常见的使用贪心算法的问题包括：

活动选择问题（选择最多的互不冲突的活动）。
霍夫曼编码（构建最优前缀编码）。
最小生成树问题（如 Kruskal 算法和 Prim 算法）。
最短路径问题（如 Dijkstra 算法）。
分数背包问题（物品可以分割）。

三、贪心算法的例子

1. 活动选择问题

问题描述：给定一组活动，每个活动有开始时间和结束时间，选择最多的互不冲突的活动。

贪心策略：每次选择结束时间最早的活动。

代码实现：

function activitySelection(activities) {
    // 按结束时间排序
    activities.sort((a, b) => a.end - b.end);

    let selected = [];
    let lastEnd = -Infinity;

    for (let activity of activities) {
        if (activity.start >= lastEnd) {
            selected.push(activity);
            lastEnd = activity.end;
        }
    }

    return selected;
}

let activities = [
    { start: 1, end: 4 },
    { start: 3, end: 5 },
    { start: 0, end: 6 },
    { start: 5, end: 7 },
    { start: 8, end: 9 },
];

console.log(activitySelection(activities));
// 输出: [{ start: 1, end: 4 }, { start: 5, end: 7 }, { start: 8, end: 9 }]

2. 分数背包问题

问题描述：给定一组物品，每个物品有重量和价值，背包有容量限制。可以选择物品的一部分，求最大价值。

贪心策略：每次选择单位重量价值最高的物品。

代码实现：

function fractionalKnapsack(items, capacity) {
    // 按单位重量价值排序
    items.sort((a, b) => b.value / b.weight - a.value / a.weight);

    let totalValue = 0;

    for (let item of items) {
        if (capacity >= item.weight) {
            // 全部装入
            totalValue += item.value;
            capacity -= item.weight;
        } else {
            // 装入部分
            totalValue += (item.value / item.weight) * capacity;
            break;
        }
    }

    return totalValue;
}

let items = [
    { weight: 10, value: 60 },
    { weight: 20, value: 100 },
    { weight: 30, value: 120 },
];

let capacity = 50;
console.log(fractionalKnapsack(items, capacity)); // 输出: 240

3. 划分字母区间

链接：763. 划分字母区间 - 力扣（LeetCode）

问题描述：

给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。例如，字符串 "ababcc" 能够被分为 ["abab", "cc"]，但类似 ["aba", "bcc"] 或 ["ab", "ab", "cc"] 的划分是非法的。

注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。

返回一个表示每个字符串片段的长度的列表。

示例 1：
输入：s = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。 
示例 2：
输入：s = "eccbbbbdec"
输出：[10]

代码：

/**
 * @param {string} s
 * @return {number[]}
 */
var partitionLabels = function(s) {
    let result = []
    while(true){
        let right = s.lastIndexOf(s[0]) , len = s.length
        for(let i = 1;i<right&&right<len-1; i++ ){
            if(s.lastIndexOf(s[i])>right) right = s.lastIndexOf(s[i])
        }
        result.push(right+1)
        if(right == len-1) break
        s = s.slice(right+1,len)
    }
    return result
};

4. 跳跃游戏

链接：55. 跳跃游戏 - 力扣（LeetCode）

问题描述：

给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。

示例 1：
输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
示例 2：
输入：nums = [3,2,1,0,4]
输出：false
解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
提示：

1 <= nums.length <= 104
0 <= nums[i] <= 105

代码：

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var canJump = function(nums) {
    let current = nums[0]
    for(let i = 1 ; i < nums.length ; i++ ){
        if(current<=0) return false 
        current = current-1>nums[i]?current-1:nums[i]
    }
    return true
};

5. 跳跃游戏2

链接：45. 跳跃游戏 II - 力扣（LeetCode）

问题描述：

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

每个元素 nums[i] 表示从索引 i 向后跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

0 <= j <= nums[i]
i + j < n

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

示例 1:
输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
     从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
示例 2:
输入: nums = [2,3,0,1,4]
输出: 2 

思路：我们可以「贪心」地选择距离最后一个位置最远的那个位置，也就是对应下标最小的那个位置。因此，我们可以从左到右遍历数组，选择第一个满足要求的位置。

/**
 * @param {number[]} nums
 * @return {number}
 */
var jump = function(nums) {
    let position = nums.length - 1;
    let steps = 0;
    while (position > 0) {
        for (let i = 0; i < position; i++) {
            if (i + nums[i] >= position) {
                position = i;
                steps++;
                break;
            }
        }
    }
    return steps;
};

6. 买卖股票的最佳时机

链接：45. 跳跃游戏 II - 力扣（LeetCode）121. 买卖股票的最佳时机 - 力扣（LeetCode）

问题描述：

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。45. 跳跃游戏 II - 力扣（LeetCode）

代码：

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    let left = prices[0], max = 0 , right = 0
    for(let i = 1 ; i < prices.length ; i++ ){
        if(prices[i]<left){
            left = prices[i]
        }else if(prices[i]>=right||prices[i]-left>max){
            right = prices[i]
            max = right-left>max?right-left:max
        }
    }
    return max
};