[LeetCode] 135. Candy

本文针对LeetCode上的糖果分配问题,提出了一种高效算法。通过定位极小值并以此为中心向两边分配糖果,确保了高评分的孩子获得更多的糖果,同时达到了糖果数量的最小化。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目链接: https://leetcode.com/problems/candy/description/

Description

There are N children standing in a line. Each child is assigned a rating value.

You are giving candies to these children subjected to the following requirements:

  • Each child must have at least one candy.
  • Children with a higher rating get more candies than their neighbors.

What is the minimum candies you must give?

解题思路

图例

注: 下文所说极小值不是数学函数定义的极小值,只是与其有相似的性质,暂且对其命名为极小值。并且,在此处不要求极小值左右相邻的值必须比其大,而只需其小于左侧相邻的值,小于等于右侧相邻的值。上图中五角星所标注的位置即为此文所定义的极小值。

主要思路是找出ratings中所有的极小值,发给他们一颗糖,并从每一个极小值处,向左向右依次递增糖的数量,直到rating开始下降停止更新。

这其中有一个关键地方需要注意,就是 rating 相等的两个人挨在一起,糖的数量不需要一样多,并且应该尽可能只给一颗糖,例如:

  • ratings [1, 2, 2, 3] -> candies [1, 2, 1, 2]
  • ratings [2, 3, 3, 2, 1] –> candies [1, 2, 3, 2, 1]
  • ratings [1, 2, 2, 2, 2, 1] –> candies [1, 2, 1, 1, 2, 1]

详细过程为,对于 ratings 从头扫到尾寻找极小值,首尾单独写出来。每当找到一个极小值,向左向右更新糖的数量,由于寻找极小值时是从左向右扫,所以向左更新可能会遇到被前一个极小值向右更新过的个体,这两个方向的做法有点区别,分开来讲:

向右更新

可以大致分为三种情况:

  • 一直单调递增:糖的数量依次加一就可以;
  • 先增后平再增:平即是 rating 相等,此时会有两个拐角,第一个拐角还是按照前面糖的数量加一,其后面rating相等的个体都只给一颗糖,第二个拐角后面继续依次从两颗糖开始递增;
  • 先增后平再减:因为在找到下一个极小值点时,会更新这种情况的第二个拐点,所以在此处可以与第二种情况一样处理。

向左更新

只用考虑一种情况——单调递增。即使遇到先增后平,也只考虑拐点那一个点,再往前的不需要修改,所以本质也是单调递增。

向左更新的一个主要目的,就是完善前一个极小值点的漏洞,例如上图中,红橙交界点。

算法也很简单,向左遍历,不是递增就终止;否则,判断当前糖的数量是否小于右侧糖的数量加一(递增则从右往左依次加一),若小于则修改为右侧糖的数量加一,否则不变。

具体示例

如上图,ratings 为 [1, 2, 4, 3, 2, 1, 1, 2, 2, 3, 3, 3, 2, 2, 1, 3]

四个极小值点分别为,(1, 1), (6, 1), (13, 2), (15, 1)

  1. (1, 1) 更新后,糖的数量分别为 [1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  2. (6, 1) 更新后,糖的数量分别为 [1, 2, 4, 3, 2, 1, 1, 2, 1, 2, 1, 1, 0, 0, 0, 0]
  3. (13, 2) 更新后,糖的数量分别为 [1, 2, 4, 3, 2, 1, 1, 2, 1, 2, 1, 2, 1, 1, 0, 0]
  4. (15, 1) 更新后,糖的数量分别为 [1, 2, 4, 3, 2, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

最终,糖的数量分别为 [1, 2, 4, 3, 2, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2],共计 28 颗。

Code

class Solution {
public:
    int candy(vector<int>& ratings) {
        int size = ratings.size();
        vector<int> candies(size, 0);

        if (size == 0 || size == 1) return size;

        // 首部单独判断是否为极小值,向右更新糖的数量
        if (ratings[0] <= ratings[1]) {
            candies[0] = 1;

            int right = 1;
            while (right < size) {
                if (ratings[right] > ratings[right - 1]) {
                    candies[right] = candies[right - 1] + 1;
                } else if (ratings[right] == ratings[right - 1]) {
                    candies[right] = 1;
                } else {
                    break;
                }
                right++;
            }
        }

        // 从第二个开始寻找极小值,向左右两边更新糖的数量
        for (int pos = 1; pos < size - 1; ++pos) {
            if (ratings[pos] < ratings[pos - 1] && ratings[pos] <= ratings[pos + 1]) {
                candies[pos] = 1;

                int left = pos - 1;
                int right = pos + 1;

                while (left >= 0) {
                    if (ratings[left] > ratings[left + 1]) {
                        if (candies[left + 1] + 1 > candies[left]) candies[left] = candies[left + 1] + 1;
                    } else {
                        break;
                    }
                    left--;
                }

                while (right < size) {
                    if (ratings[right] > ratings[right - 1]) {
                        candies[right] = candies[right - 1] + 1;
                    } else if (ratings[right] == ratings[right - 1]) {
                        candies[right] = 1;
                    } else {
                        break;
                    }
                    right++;
                }
            }
        }

        // 尾部单独判断是否为极小值,向左更新糖的数量
        if (ratings[size - 1] <= ratings[size - 2]) {
            candies[size - 1] = 1;

            int left = size - 2;
            while (left >= 0) {
                if (ratings[left] > ratings[left + 1] && candies[left + 1] + 1 > candies[left]) {
                    candies[left] = candies[left + 1] + 1;
                } else {
                    break;
                }
                left--;
            }
        }

        return accumulate(candies.begin(), candies.end(), 0);
    }
};
### 贪心算法在 LeetCode 上的应用 贪心算法是一种通过局部最优选择来达到全局最优解的方法。其核心思想是在每一步都做出当前状态下最好的选择,从而希望最终能够得到整体的最优解[^1]。 以下是基于 Python 的几个经典贪心算法题目及其解决方案: --- #### 题目 1: **LeetCode 455. Assign Cookies** 给定两个数组 `g` 和 `s`,分别表示孩子的胃口值和饼干大小。每个孩子最多只能吃一块饼干,求最大满足的孩子数量。 ##### 解法 先对两个数组进行排序,然后从小到大分配饼干给尽可能多的孩子。 ```python def findContentChildren(g, s): g.sort() s.sort() i, j = 0, 0 count = 0 while i < len(g) and j < len(s): if s[j] >= g[i]: count += 1 i += 1 j += 1 return count ``` 此方法利用了贪心策略,在每次循环中优先考虑最小需求的孩子并匹配最合适的饼干[^3]。 --- #### 题目 2: **LeetCode 135. Candy** 有 n 个小孩站在一条直线上,每个小孩有一个评分值。分发糖果的要求是:如果某个小孩的评分高于相邻的小孩,则该小孩获得更多的糖果;至少每人一颗糖果。 ##### 解法 两次遍历数组,一次从前向后,另一次从后向前,确保左右两侧的关系都被满足。 ```python def candy(ratings): n = len(ratings) candies = [1] * n for i in range(1, n): if ratings[i] > ratings[i - 1]: candies[i] = candies[i - 1] + 1 for i in range(n - 2, -1, -1): if ratings[i] > ratings[i + 1]: candies[i] = max(candies[i], candies[i + 1] + 1) return sum(candies) ``` 这种方法通过两轮扫描实现了局部最优条件下的全局最优解。 --- #### 题目 3: **LeetCode 621. Task Scheduler** 给定一组任务字符以及冷却时间 `n`,计算完成所有任务所需的最少单位时间数。 ##### 解法 统计频率最高的任务数目,并根据这些任务之间的间隔安排其他任务。 ```python from collections import Counter def leastInterval(tasks, n): task_counts = list(Counter(tasks).values()) max_freq = max(task_counts) max_count = task_counts.count(max_freq) intervals = (max_freq - 1) * (n + 1) + max_count return max(len(tasks), intervals) ``` 上述代码的关键在于理解如何合理填充高频任务之间的时间间隙。 --- #### 总结 解决贪心类问题时,通常需要明确以下几个方面: - 是否可以通过逐步优化子结构解决问题? - 如何定义“局部最优”,它是否能导向“全局最优”? 此外,清晰表达逻辑流程有助于构建完整的解决方案[^2]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值