[LeetCode]Candy

最新推荐文章于 2023-02-28 14:31:32 发布

原创最新推荐文章于 2023-02-28 14:31:32 发布 · 396 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

149 篇文章

订阅专栏

解决一个算法问题，即如何在满足特定条件下最小化分配给孩子的糖果数量。通过两次遍历数组，确保高评分的孩子得到比邻居更多的糖果。

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?

LeetCode Source

分析：分析数组的峰值，和左右侧的变化。

超出时间限制，对特殊情况下算法复杂度为最差情况O(N^2)。

class Solution {
public:
    int candy(vector<int> &ratings) {
        int ans=0;
        vector<int> ret(ratings.size(),1);
        for(auto i=0;i<ratings.size();++i){
            int temp1 = 1;
            int temp2 = 1;
            for(auto j=i-1;j>0;--j){
                if(ratings[i]>ratings[j]&&ratings[j]<ratings[j+1]){
                    temp1 = i-j+1;
                }
                else break;
            }
            for(auto j=i+1;j<ratings.size();++j){
                if(ratings[i]>ratings[j]&&ratings[j]<ratings[j-1]){
                    temp2 = j-i+1;
                }
                else break;
            }
            ret[i] = temp1>temp2?temp1:temp2;
        }
        for(auto i=0;i<ret.size();++i){
            ans+=ret[i];
        }
        return ans;
    }
};

O(N)

第一次满足该数比左边的数大；

第二次满足该数比右边的数大；

然后取两者较大的值，满足比邻居值大。

class Solution {
public:
    int candy(vector<int> &ratings) {
        int ans=0;
        int size=ratings.size();
        vector<int> ret1(ratings.size(),1);
        ret1[0] = 1;
        ret1[size-1] = 1;
        vector<int> ret2 = ret1;
        for(auto i=1;i<size;++i){
            ret1[i]=ratings[i]>ratings[i-1]?ret1[i-1]+1:1;
            ret2[size-i-1]=ratings[size-i-1]>ratings[size-i]?ret2[size-i]+1:1;
        }
        for(auto i=0;i<size;++i){
            ans+=ret1[i]>ret2[i]?ret1[i]:ret2[i];
        }
        return ans;
    }
};