leetcode-135-分发糖果

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

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

• 每个孩子至少分配到 1 个糖果。

• 相邻的孩子中，评分高的孩子必须获得更多的糖果。

那么这样下来，老师至少需要准备多少颗糖果呢？

示例 1:

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

示例 2:

输入: [1,2,2]
输出: 4
解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这已满足上述两个条件。

分析

题目要求糖果的最少消耗值，怎么才能在满足上面要求的情况下最少的发放糖果呢？

我们可以秉持一个策略：

1. 从评分最低的孩子开始发
2. 尽可能地发满足条件的最小数量

按照这个策略，我们从给评分最低的孩子一个糖果，然后按照评分依次增加的顺序发放糖果，如果这个孩子周围有人评分比他低，则让他比那个低分的孩子多一个糖果，如果没有人比他低，则发放一个糖果(老资本家了)。按照这个方式便能得到最小数量。

首先我们需要在不破坏原有队形的情况下得到评分排名，这里我们可以引入一个聚合类stu(其中存有评分和在原有队形中的序号)，然后对这个聚合类按评分升序的条件排序(sort+lambda表达式)。排序成功后再按上述的方法不断分配糖果，从而得到正确答案。

//先按分数排序，再从分数最低的学生开始分糖果
struct stu{
	int score;//分数
	int index;//序号
};
/*
执行结果：通过
执行用时：88 ms, 在所有 C++ 提交中击败了5.22%的用户
内存消耗：19.4 MB, 在所有 C++ 提交中击败了5.02%的用户
*/
int candy(vector<int>& ratings) {
	if (ratings.size() == 1) {
		return 1;
	}
	vector<stu> vs;
	for (int i = 0; i < ratings.size(); ++i) {
		vs.push_back({ ratings[i], i });//放入保存有序号的vector中
	}
	//for (auto i : vs) {
	//	cout << i.score << "\t" << i.index << endl;
	//}
	auto sortFun = [](const stu& s1, stu& s2)  -> bool {
		if (s1.score < s2.score) {
			return true;
		}	return false;
	};
	sort(vs.begin(), vs.end(), sortFun);//按分数排序
	//cout << "------------" << endl;
	//for (auto i : vs) {
	//	cout << i.score << "\t" << i.index << endl;
	//}
	vector<int> candyPerChild(ratings.size(),0);
	for (int i = 0; i < ratings.size(); ++i) {
		int childIndex = vs[i].index;//评分第i低的孩子序号
		if (childIndex == 0) {//左侧没有小孩
			if (ratings[0] > ratings[1]) {//分数更高多分一个
				candyPerChild[0] = candyPerChild[1] + 1;
			}else {//分数相同或更低分一个
				candyPerChild[0] = 1;
			}
		}else if (childIndex == ratings.size() - 1) {//右侧没有小孩
			if (ratings[childIndex] > ratings[childIndex - 1]) {
				candyPerChild[childIndex] = candyPerChild[childIndex - 1] + 1;
			}else {
				candyPerChild[childIndex] = 1;
			}
		}else {//左右都有小孩
			if (ratings[childIndex] > ratings[childIndex - 1] && ratings[childIndex] > ratings[childIndex + 1]) {//如果左右两个小孩分数都高
				candyPerChild[childIndex] = max(candyPerChild[childIndex - 1], candyPerChild[childIndex + 1]) + 1;//等于相邻小孩糖果最大值加一
			}
			else if (ratings[childIndex]>ratings[childIndex-1]) {//仅比左边小孩分高
				candyPerChild[childIndex] = candyPerChild[childIndex - 1] + 1;
			}
			else if (ratings[childIndex]>ratings[childIndex+1]) {//仅比右边小孩分高
				candyPerChild[childIndex] = candyPerChild[childIndex + 1] + 1;
			}
			else {
				candyPerChild[childIndex] = 1;
			}
		}
	}
	int sum = 0;
	for (auto i : candyPerChild) {
		sum += i;
	}
	return sum;
}

虽然成功完成了任务，但是无论速度还是内存消耗都不太理想。

因为上面的方法在排序上浪费了时间，存储序号浪费了空间。

那么可不可以不排序，直接求呢？

当然可以，这就需要我们从约束条件下手了。由于每个孩子至少分配到一个糖果，我们可以将每个孩子的初始糖果值设置为1；相邻的孩子评分更高的必须获得更多，因此这个孩子

1. 如果比左边的孩子评分高，就比左边的孩子糖果多一个。
2. 如果比右边的孩子评分高，就比右边的孩子评分多一个。

因此这个孩子所得糖果值为与左边相比(1)，以及与右边相比(2)这两种情况下所能得到糖果值的最大值。

又由于最左侧的孩子左侧没有人，不需要和左侧的比较。

因此我们可以从左至右扫描一次队形，根据每个孩子相比其左侧孩子的评分关系所能得到的糖果数。

同理再从右向左扫描一次，每个孩子所获糖果数即为这两次扫描预估值中更大的那个值(只有这样才能满足约束条件)

代码实现如下：

/*
执行用时：40 ms, 在所有 C++ 提交中击败了87.19%的用户
内存消耗：17 MB, 在所有 C++ 提交中击败了28.89%的用户
*/
int candy(vector<int>& ratings) {
	if (ratings.size() == 1) {
		return 1;
	}
	vector<int> candyPerChild(ratings.size(), 1);//首先给每个孩子预分配一个糖果
	for (int i = 0; i < ratings.size()-1; ++i) {
		if (ratings[i + 1] > ratings[i]) {
			candyPerChild[i + 1] = candyPerChild[i] + 1;
		}
	}
	for (int i = ratings.size() - 2; i >= 0; --i) {
		if (ratings[i] > ratings[i + 1]) {
			candyPerChild[i] = max(candyPerChild[i],candyPerChild[i + 1] + 1);
		}
	}
	int sum = 0;
	for (auto i : candyPerChild) {
		sum += i;
	}
	return sum;
}

可见此时相比上一个方法要快上不少。