135分发糖果（单调递减栈、贪心）

1、题目描述

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

你需要按照以下要求，帮助老师给这些孩子分发糖果：

每个孩子至少分配到 1 个糖果。
相邻的孩子中，评分高的孩子必须获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？

2、示例

输入: [1,0,2]
输出: 5
解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。

3、题解

解法一：

基本思想：贪心算法

• 把所有孩子的糖果数初始化为 1；
• 先从左往右遍历一遍，如果右边孩子的评分比左边的高，则右边孩子的糖果数更新为左边孩子的糖果数加 1；
• 再从右往左遍历一遍，如果左边孩子的评分比右边的高，且左边孩子当前的糖果数不大于右边孩子的糖果数，则左边孩子的糖果数更新为右边孩子的糖果数加 1

解法二：

基本思想：单调递减栈，因为当前小孩给的糖果数取决于相邻的小孩评分，对于评分递减的情况就暂时不确定给当前小孩几个糖果，利用单调递减栈，如果当前小孩评分大于下一个小孩入栈，直到当前小孩评分小于下一个小孩出栈。

• 当前孩子评分大于下一个孩子，孩子评分开始下坡递减全都入栈
• 当前孩子评分小于下一个孩子，孩子评分开始上坡递增
• 当前孩子评分大于上一个孩子直接糖果数+1，孩子评分上坡递增
• 当前孩子评分是左右两边最低评分，位于坡脚情况
• 如果当前孩子评分是左右两边最高评分，位于坡顶

解法三：

基本思想：递归，超时

#include<iostream>
#include<vector>
#include<algorithm>
#include<stack>
#include<numeric>
using namespace std;
class Solution {
public:
	int candy(vector<int>& ratings) {
	    //基本思想：贪心算法
	    //把所有孩子的糖果数初始化为 1；
        //先从左往右遍历一遍，如果右边孩子的评分比左边的高，则右边孩子的糖果数更新为左边孩子的糖果数加 1；
        //再从右往左遍历一遍，如果左边孩子的评分比右边的高，且左边孩子当前的糖果数不大于右边孩子的糖果数，则左边孩子的糖果数更新为右边孩子的糖果数加 1
        if (ratings.size() < 2) return ratings.size();
        vector<int> nums(ratings.size(), 1);
        for (int i = 1; i < ratings.size(); ++i) {
            if (ratings[i] > ratings[i-1])
                nums[i] = nums[i-1] + 1;
        }
        for (int i = ratings.size() - 1; i > 0; --i) {
            if (ratings[i] < ratings[i-1])
                nums[i-1] = max(nums[i-1], nums[i] + 1);
        }
		int sum = 0;
		//最后返回nums元素之和
		for_each(nums.begin(), nums.end(), [&sum](const int& v) {sum += v; });
		return sum;
	}
};
class Solution1 {
public:
	int candy(vector<int>& ratings) {
		//基本思想：单调递减栈，因为当前孩子给的糖果数取决于相邻的孩子评分，对于评分递减的情况就暂时不确定给当前孩子几个糖果
		//利用单调递减栈，如果当前孩子评分大于下一个孩子入栈，直到当前孩子评分小于下一个孩子出栈
		if (ratings.size() <= 1)
			return ratings.size();
		//nums保存对应下标孩子的糖果数，最后返回nums元素之和
		vector<int> nums(ratings.size(), 0);
		stack<int> st;    //单调递减栈
		int i = 0;
		while (i < ratings.size() || !st.empty())
		{
			//当前孩子评分大于下一个孩子，孩子评分开始下坡递减全都入栈
			if (i + 1<= ratings.size() - 1 && ratings[i] > ratings[i + 1])
			{
				st.push(i);
			}
			//当前孩子评分小于下一个孩子，孩子评分开始上坡递增
			else
			{
				//当前孩子评分大于上一个孩子直接糖果数+1，孩子评分上坡递增
				if (i < ratings.size() && i - 1 >= 0 && ratings[i] > ratings[i - 1])
					nums[i] = nums[i - 1] + 1;
				//当前孩子评分是左右两边最低评分，位于坡脚情况
				else
				    nums[i] = 1;
				while (!st.empty())
				{
					int pos = st.top();
					st.pop();
					//如果当前孩子评分是左右两边最高评分，位于坡顶
					if (pos - 1 >= 0 && ratings[pos] > ratings[pos - 1])
						nums[pos] = max(nums[pos + 1], nums[pos - 1]) + 1;
					else
						nums[pos] = nums[pos + 1] + 1;
				}
			}
			i++;
		}
		int sum = 0;
		//最后返回nums元素之和
		for_each(nums.begin(), nums.end(), [&sum](const int& v) {sum += v; });
		return sum;
	}
};
class Solution2 {
public:
	vector<int> nums;
	int candy(vector<int>& ratings) {
		//基本思想：递归，超时
		if (ratings.size() <= 1)
			return ratings.size();
		for (int i = 0; i < ratings.size(); i++)
			nums.push_back(0);
		for (int i = 0; i < ratings.size(); i++)
		{
			if (nums[i] == 0)
				dfs(ratings, i);
		}
		int sum = 0;
		for_each(nums.begin(), nums.end(), [&sum](const int& v) {sum += v; });
		return sum;
	}
	int dfs(vector<int>& ratings, int pos)
	{
		//右边界
		if (pos == ratings.size() - 1)
		{
			nums[pos] = ratings[pos] <= ratings[pos - 1] ? 1 : dfs(ratings, pos - 1) + 1;
			return nums[pos];
		}
		//左边界
		if (pos == 0)
		{
			nums[pos] = ratings[pos] <= ratings[pos + 1] ? 1 : dfs(ratings, pos + 1) + 1;
			return nums[pos];
		}
		//同时小于两边值
		if (ratings[pos] <= ratings[pos + 1] && ratings[pos] <= ratings[pos - 1])
		{
			nums[pos] = 1;
			return  nums[pos];
		}
		//同时大于两边值
		if (ratings[pos] > ratings[pos + 1] && ratings[pos] > ratings[pos - 1])
		{
			nums[pos] = max(dfs(ratings, pos + 1), dfs(ratings, pos - 1)) + 1;
			return nums[pos];
		}
		//小于一边值大于一边值
		nums[pos] = ratings[pos] > ratings[pos + 1] ? dfs(ratings, pos + 1) + 1 : dfs(ratings, pos - 1) + 1;
		return nums[pos];
	}
};
int main()
{
	Solution solute;
	vector<int> ratings = { 1,2,2 };
	cout << solute.candy(ratings) << endl;
	return 0;
}