135. Candy

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?

第一种方法：暴力求解
count[i] 是给第i个小孩最少几块糖

ratings[i] > ratings[i - 1]，必须比前一个多给一块，count[i] = count[i - 1] + 1

ratings[i] == ratings[i - 1]，两个排名一样，第二个就给一块就行了, count[i] = 1

ratings[i] < ratings[i - 1]，比上一个排名低，应该少给一块，但是若上一个已经只给一块了，

就得往前推一个一个多给。推到什么时候为止呢？直到ratings[i]>=ratings[i-1]。

class Solution {
public:
    int candy(vector<int>& ratings) 
    {
        int up_index=0;//这里up_index用来标记逆序的开头
        vector<int>num(ratings.size(),1);
        for(int i=1;i<ratings.size();i++)
        {
            if(ratings[i]>ratings[i-1])
            {
                num[i]=num[i-1]+1;
                up_index=i;
            }
            else if(ratings[i]<ratings[i-1])
            {
                for(int j=i-1;j>=up_index;j--)
                {
                    if(num[j]<=num[j+1])
                        num[j]=num[j+1]+1;
                }
            }
            else
                up_index=i;
        }
        int ret=0;
        for(int i=0;i<num.size();i++)
            ret+=num[i];
        return ret;
    }
};

但是这样做超时了，因为如果ratings逆序排列的话，时间复杂度达到最差的O(N^2)。

第二种方法：贪心法
这题本身可以用贪心法来做，我们用candy[n]表示每个孩子的糖果数，遍历过程中，如果孩子i+1的rate大于孩子i 的rate，那么当前最好的选择自然是：给孩子i+1的糖果数=给孩子i的糖果数+1

如果孩子i+1的rate小于等于孩子i 的rate，暂时不处理这种情况。等数组遍历完了，我们再一次从尾到头遍历数组，这回逆过来贪心，就可以处理之前略过的孩子。

最后累加candy[n]即得到最小糖果数。

class Solution {
public:
    int candy(vector<int>& ratings) 
    {
        vector<int>num(ratings.size(),1);
        for(int i=1;i<ratings.size();i++)
        {
            if(ratings[i]>ratings[i-1])
                num[i]=num[i-1]+1;
        }
        for(int i=ratings.size()-2;i>=0;i--)
        {
            if(ratings[i]>ratings[i+1])
                num[i]=max(num[i],num[i+1]+1);
        }
        int ret=0;
        for(int i=0;i<num.size();i++)
            ret+=num[i];
        return ret;
    }
};

第三种方法：使用最小堆
准备一个最小值堆，把所有孩子按照优先级放入其中。

每次弹出优先级最低的一个，如果它比任何一个邻居的优先级高，就更改它得到的糖果数，使其拥有更多的糖果。

class Solution
{
public:
    int candy(vector<int>& ratings)
    {
        vector<Child> children;
        for (int i = 0; i < ratings.size(); i++)
        {
            children.push_back(Child(ratings[i], i));
        }
        make_heap(children.begin(), children.end(), compare);

        vector<int> candies(ratings.size(), 1);
        while (!children.empty())
        {
            pop_heap(children.begin(), children.end(), compare);//将第一个和最后一个元素交换，并重新排列堆
            auto child = children.back();//取出最后一个元素，也就是堆顶元素
            children.pop_back();

            int neighbor = child.pos - 1;
            if (child.pos > 0 && child.rating > ratings[neighbor] && candies[child.pos] <= candies[neighbor])
            {
                candies[child.pos] = candies[neighbor] + 1;
            }

            neighbor = child.pos + 1;
            if (child.pos < ratings.size() - 1 && child.rating > ratings[neighbor] && candies[child.pos] <= candies[neighbor])
            {
                candies[child.pos] = candies[neighbor] + 1;
            }
        }

        return accumulate(candies.begin(), candies.end(), 0);
    }

private:
    struct Child
    {
        int rating;
        int pos;
        Child(int r, int p) : rating(r), pos(p) {}
    };

    static bool compare(const Child &c1, const Child &c2)
    {
        return c1.rating > c2.rating;
    }
};