# 贪心算法

贪心算法 (opens new window) （英语：greedy algorithm），又称贪婪算法，是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致结果是最好或最优的算法 (opens new window)。

# 455. 分发饼干 (opens new window)

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

示例 1:

输入: g = [1,2,3], s = [1,1]
输出: 1
解释: 
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。

1
2
3
4
5
6

示例 2:

输入: g = [1,2], s = [1,2,3]
输出: 2
解释: 
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

1
2
3
4
5
6

题解：

/*
 * @lc app=leetcode.cn id=455 lang=javascript
 *
 * [455] 分发饼干
 */

// @lc code=start
/**
 * @param {number[]} g
 * @param {number[]} s
 * @return {number}
 */
var findContentChildren = function (g, s) {
  g.sort((a, b) => a - b)
  s.sort((a, b) => a - b)

  let count = 0
  let j = 0
  for (let i in g) {
    while (j < s.length) {
      if (g[i] <= s[j]) {
        count++
        j++
        break;
      }
      j++
    }
  }
  return count
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 435. 无重叠区间 (opens new window)

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意:

可以认为区间的终点总是大于它的起点。
区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。

示例 1:

输入: [ [1,2], [2,3], [3,4], [1,3] ]

输出: 1

解释: 移除 [1,3] 后，剩下的区间没有重叠。

1
2
3
4
5

示例 2:

输入: [ [1,2], [1,2], [1,2] ]

输出: 2

解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

1
2
3
4
5

题解：

思路：按照头排序后，依次比较当前屁股和下一组的头，如果屁股比头大，我们需要跳过当前这个屁股大的【因为他如果无穷大，那么他的区间就会影响后面所有数组】，否则忽略后面那组，自己保留屁股，直到遇到不重叠的数组交出屁股。

/*
 * @lc app=leetcode.cn id=435 lang=javascript
 *
 * [435] 无重叠区间
 */

// @lc code=start
/**
 * @param {number[][]} intervals
 * @return {number}
 */
var eraseOverlapIntervals = function (intervals) {

  if (intervals.length == 0) return 0

  let count = 0
  intervals.sort((a, b) => {
    return a[0] - b[0]
  })

  let ass = intervals[0][1]//初始化第一个屁股
  let i = 0//下标
  let len = intervals.length
  while (++i < len) {
    if (intervals[i][0] < ass) {
      // 如果下一个的头比当前屁股小，那么一定要删除一个
      count++
      if (intervals[i][1] < ass) {
        // 去掉屁股大的那个
        ass = intervals[i][1]
      }
    } else {
      // 正常情况下要把屁股给最新的正常数组
      ass = intervals[i][1]
    }
  }

  return count
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 452. 用最少数量的箭引爆气球 (opens new window)

在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 x``start，x``end，且满足 xstart ≤ x ≤ x``end，则该气球会被引爆。可以射出的弓箭的数量没有限制。弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。

示例 1：

输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球

1
2
3

题解：

/*
 * @lc app=leetcode.cn id=452 lang=javascript
 *
 * [452] 用最少数量的箭引爆气球
 */

// @lc code=start
/**
 * @param {number[][]} points
 * @return {number}
 */
var findMinArrowShots = function (points) {
  if (points.length == 0) return 0
  points.sort((a, b) => a[0] - b[0])
  let count = 1
  let i = 0
  let ass = points[0][1]
  while (++i < points.length) {
    if (points[i][0] > ass) {
      // 头大于屁股 必须多一箭
      count++
      ass = points[i][1]
    } else if (points[i][0] < ass && points[i][1] < ass) {
      // 头小于屁股 且后者屁股小 
      ass = points[i][1]
    }
  }
  return count
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 406. 根据身高重建队列⭐ (opens new window)

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面正好有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

示例 1：

输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
解释：
编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。
编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。
编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。
编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。
编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。

1
2
3
4
5
6
7
8
9
10

示例 2：

输入：people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]
输出：[[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]

1
2

题解：

思路：按照身高降序排列，循环按照下标插入，个子矮的永远看不到个子高的！

/*
 * @lc app=leetcode.cn id=406 lang=javascript
 *
 * [406] 根据身高重建队列
 */

// @lc code=start
/**
 * @param {number[][]} people
 * @return {number[][]}
 */
var reconstructQueue = function (people) {
  people.sort((a, b) => a[0] == b[0] ? a[1] - b[1] : b[0] - a[0])

  let queue = []
  for (let item of people) {
    queue.splice(item[1], 0, item)
  }
  return queue
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 121. 买卖股票的最佳时机⭐ (opens new window)

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。

注意：你不能在买入股票前卖出股票。

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

1
2
3
4

题解：

/*
 * @lc app=leetcode.cn id=121 lang=javascript
 *
 * [121] 买卖股票的最佳时机
 */

// @lc code=start
/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function (prices) {
  if (!prices || !prices.length) return 0
  
  let minPrice = Number.MAX_VALUE // 最小购入股价
  let max = 0// 最大收益

  for (let price of prices) {
    minPrice = Math.min(minPrice, price)
    max = Math.max(max, price - minPrice)// 负数的话就是 0 
  }

  return max
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 122. 买卖股票的最佳时机 II (opens new window)

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意： 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

1
2
3
4

题解：

思路：假设 [1,3,5] ，1 买入 5 卖出，和 1 买入 3 卖出，3 再买入 5再卖出，结果是一样的，所以只需要一步步遍历即可，如果后面比前面的值大相当于这步不买入，即为 0。

/*
 * @lc app=leetcode.cn id=122 lang=javascript
 *
 * [122] 买卖股票的最佳时机 II
 */

// @lc code=start
/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function (prices) {
  if (!prices || !prices.length) return 0

  let max = 0
  let i = 0
  while (++i < prices.length) {
    max += Math.max(0, prices[i] - prices[i - 1])
  }
  return max
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 605. 种花问题 (opens new window)

假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false。

示例 1：

输入：flowerbed = [1,0,0,0,1], n = 1
输出：true

1
2

示例 2：

输入：flowerbed = [1,0,0,0,1], n = 2
输出：false

1
2

题解：

思路：可以种花的条件：①当前为 0 ；② 左右都不为 1（0 或者 undefined【头尾时】都可以）

/*
 * @lc app=leetcode.cn id=605 lang=javascript
 *
 * [605] 种花问题
 */

// @lc code=start
/**
 * @param {number[]} flowerbed
 * @param {number} n
 * @return {boolean}
 */
var canPlaceFlowers = function (flowerbed, n) {
  let count = 0

  for (let i = 0; i < flowerbed.length; i++) {
    if (flowerbed[i] == 0 && flowerbed[i - 1] != 1 && flowerbed[i + 1] != 1) {
      if (++count >= n) return true
      flowerbed[i] = 1
    }
  }
  return count >= n
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 392. 判断子序列 (opens new window)

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

示例 1：

输入：s = "abc", t = "ahbgdc"
输出：true

1
2

示例 2：

输入：s = "axc", t = "ahbgdc"
输出：false

1
2

题解：

双指针

/*
 * @lc app=leetcode.cn id=392 lang=javascript
 *
 * [392] 判断子序列
 */

// @lc code=start
/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isSubsequence = function (s, t) {
  if (s.length > t.length) return false
  if (s === "") return true

  let sindex = 0
  let tindex = 0
  while (tindex < t.length) {
    if (s[sindex] == t[tindex]) {
      if (++sindex >= s.length) return true
    }
    tindex++
  }
  return false
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 665. 非递减数列⭐ (opens new window)

给你一个长度为 n 的整数数组，请你判断在最多改变 1 个元素的情况下，该数组能否变成一个非递减数列。

我们是这样定义一个非递减数列的：对于数组中所有的 i (0 <= i <= n-2)，总满足 nums[i] <= nums[i + 1]。

示例 1:

输入: nums = [4,2,3]
输出: true
解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。

1
2
3

示例 2:

输入: nums = [4,2,1]
输出: false
解释: 你不能在只改变一个元素的情况下将其变为非递减数列。

1
2
3

题解

关键在于当 nums[i]>nums[i+1] 时，肯定需要改一个值，但是具体改哪个值需要根据 nums[i-1] 和 nums[i+1] 的值来比较。

比如👉：[5,7,1,8] ，在 7 的位置，需要把 1 改为 7 。[1,4,2,3] 在 4 的位置，需要把 4 改为 1 。

/*
 * @lc app=leetcode.cn id=665 lang=javascript
 *
 * [665] 非递减数列
 */

// @lc code=start
/**
 * @param {number[]} nums
 * @return {boolean}
 */
var checkPossibility = function (nums) {
  let haschange = false
  for (let i = 0; i < nums.length - 1; i++) {
    if (nums[i] > nums[i + 1]) {
      if (haschange) return false

      haschange = true
      if (nums[i - 1] > nums[i + 1]) {
        nums[i + 1] = nums[i]
      } else {
        nums[i] = nums[i - 1]
      }
    }
  }
  return true
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 53. 最大子序和 (opens new window)

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

1
2
3

题解：

/*
 * @lc app=leetcode.cn id=53 lang=javascript
 *
 * [53] 最大子序和
 */

// @lc code=start
/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function (nums) {
  let max = nums[0]
  let presum = 0 // 存储上一轮的总和，并不是上一轮的实际最大值

  for (let num of nums) {
    if (presum > 0) {
      presum += num
    } else {
      presum = num
    }
    max = Math.max(presum, max)
  }
  return max
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 763. 划分字母区间⭐ (opens new window)

字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。

示例：

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

1
2
3
4
5
6

题解：

思路：遍历字符串时，需要更新最远切割点。

/*
 * @lc app=leetcode.cn id=763 lang=javascript
 *
 * [763] 划分字母区间
 */

// @lc code=start
/**
 * @param {string} S
 * @return {number[]}
 */
var partitionLabels = function (S) {
  let start = 0 // 记录当前开始切割点
  let end = 0 // 记录循环中当前结束切割点
  let result = [] // 记录结果
  let map = {} // 存放 字母：字母的最远距离
  let set = new Set(S.split(''))// 去重一下数组
  for (let char of set) {
    map[char] = S.lastIndexOf(char)
  }

  for (let i in S) {
    let charMax = map[S[i]]// 获取当前字母最远距离
    // 结束切割点取最远的值，如果当前最远距离更大就更新结束点
    end = Math.max(end, charMax)
    // 如果一路走到了切割结束点的位置结束点都没更新，就切割
    if (+i === end) {
      result.push(i - start + 1)
      start = +i + 1
    }
  }
  return result
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 55. 跳跃游戏 (opens new window)

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

示例 1：

输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

1
2
3

示例 2：

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

1
2
3

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var canJump = function (nums) {
  /**
   * 贪心 记录每个下标可以走到的最远的
   * 但是最远的下标位置是在不停变化的 要注意
   */
  // maxCount 记录目前最远的距离（也是下标位置
  let maxCount = nums[0];

  for (let i = 0; i <= maxCount; i++) {
    maxCount = Math.max(maxCount, nums[i] + i);
    if (maxCount >= nums.length - 1) return true;
  }

  return false;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

← 搜索特殊 →