leecode 解题总结：135. Candy

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
using namespace std;
/*
问题:
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?

分析: rating value排名。
N个孩子站成一排，每个人被分配了一个排名值。你需要给孩子分配糖果：
每个孩子至少有一个糖果，较高排名的孩子需要比他的邻居都要多。
这里第二点有歧义，较高排名的比左边较低排名的多，比右边较低排名的多。
举例：
r:1 5 2 4 3
设n个人每个人分配的糖果为x[i],i从1到N
根据当前题目:
x[1] < x[2]
x[2] > x[3]
x[3] < x[4]
x[4] > x[5]
难点在于不知道从哪个地方选取赋予最少的糖果，假设我们选取排名最小的第一个孩子，发一个糖果
那么x[1]=1,根据关系式:x[2] >= 2,
    x[3] <= 1,
	x[4] >= 2
	x[5] <= 1
	综上，最少糖果为: 1 + 2 + 1 + 2 + 1 = 7
假设是:
r:1 2 3 4 5
则糖果至少为:1 + 2 + 3 + 4 + 5 = 15
如果是:
r:5 4 3 2 1
糖果也是:5 + 4 + 3 + 2 + 1 = 15
如果是:
r:4 2 1 3 5,
那么糖果是: 3 + 2 + 1 + 2 + 3 = 11
r:4 3 1 5 3
糖果是: 3 + 2 + 1 + 2 + 1 = 9
发现：将一个高排名的左右安排比他排名低的，比一直按排名升序或降序排列好
如果仅仅是给定排名，我们可以得到一个关系式，利用关系式来推出当前第i个孩子，
至少要分配多少糖果。
顺序可以从前向后递推。
如果是: 1 2 6 5 4 3,那么就需要: 1 + 2 + 4 + 3 + 2 + 1 = 13
也就是可以确定发送糖果最多的个数= 寻找到的排名单调增区间或者单调减区间的最大长度
以1 2 6 5 4 3为例找到最大单调递增区间是{1,2,6}，最大单调减区间是{6,5,4,3}，
所以发给的糖果个数等于4，将该最长的单调增区间或减区间
左右分成两半，对左边继续上述操作，对右边继续寻找上述操作
累加结果。这个应该是分治算法。
如果出现多个相同长度的单调区间，随便选择一个，即可。
dp[i][j]表示从A[i...j]花费的最少糖果数
分析时间复杂度：每次先要找到当前部分中长度最长的单调区间，耗时O(n)，
然后将数组分成左边和右边，对左边和右边重复上述过程
总的时间复杂度为O(n^2)

竟然有排名相同的，排名相同的可以给相同的糖果。这个不影响给出的单人最高糖果数量
我需要修改的地方：

比如给定的是
1 1 2 2 3 3:那么长度为6，但是不重复元素数量为3，最高糖果数为3，然后还得遍历一把

输入:
6
1 2 6 5 4 3
5
1 2 3 4 5
5
1 5 2 4 3
12
12 9 2 7 8 6 5 3 4 1 11 10
11
10 9 2 7 8 6 5 10 3 1 11
1
1
2
2 2

3
1 2 2
输出:
13
15
7
23
20
1
2
4

报错:
Input:[1,2,2]
Output:5
Expected:4
为什么?

别人的解法:http://www.cnblogs.com/AndyJee/p/4483043.html
关键：
1
可以从题目角度来看：从前到后，如果后面人排名比前面人高，后面人给的糖果数=前面一个人给的糖果数+1
但是后面<=前面的情况无法判断，我们暂时不处理。
然后从后向前，每个元素与其后面的元素比较，如果ratings[i] > ratings[i+1]，且
令candy[i] = max(candy[i] , ratings[i+1]+1)，因为至少要比后面的人多1
题目中没有说明如果两个人排名相同是否需要给相同数量的糖果，所以1,2,2.只需要1 + 2 + 1共4颗。

2 典型的双向贪心算法
*/

class Solution {
public:
    int candy(vector<int>& ratings) 
	{
		if(ratings.empty())
		{
			return 0;
		}
		if(ratings.size() <= 1)
		{
			return 1;
		}
		int size = ratings.size();
		vector<int> candyNum(size , 1);//初始化每个人至少一个糖果
		for(int i = 1 ; i < size ; i++)
		{
			//如果从前向后遍历，元素>前面元素，则元素的糖果数=前面元素的糖果数+1
			if(ratings.at(i) > ratings.at(i-1))
			{
				candyNum.at(i) = candyNum.at(i-1) + 1;
			}
		}
		//从后向前遍历， 当前元素>后面元素，则当前元素糖果数=max(当前元素糖果数，后面元素糖果数+1)，
		//取较大值，才能满足比两边相邻较小排名分得的糖果数更多一点
		int result = candyNum.at(size - 1);
		//逆序遍历,i--
		for(int i = size - 2; i >= 0; i--)
		{
			if(ratings.at(i) > ratings.at(i+1))
			{
				candyNum.at(i) = max(candyNum.at(i) , candyNum.at(i+1) + 1);
			}
			result += candyNum.at(i);
		}
		return result;
	}
};

void print(vector<int>& result)
{
	if(result.empty())
	{
		cout << "no result" << endl;
		return;
	}
	int size = result.size();
	for(int i = 0 ; i < size ; i++)
	{
		cout << result.at(i) << " " ;
	}
	cout << endl;
}

void process()
{
	 vector<int> nums;
	 int value;
	 int num;
	 Solution solution;
	 vector<int> result;
	 while(cin >> num )
	 {
		 nums.clear();
		 for(int i = 0 ; i < num ; i++)
		 {
			 cin >> value;
			 nums.push_back(value);
		 }
		 num = solution.candy(nums);
		 cout << num << endl;
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}


/*
public:
	//计算某个单调区间的总糖果数，以及最高糖果数
	int calculate(vector<int>& ratings , int beg , int end, bool isIncreasing)
	{
		if(ratings.empty() || beg < 0 || end >= ratings.size() || beg > end)
		{
			return 0;
		}
		//如果只有一个元素，直接返回1
		if(beg == end)
		{
			return 1;
		}
		
		int result = 0;
		int curNum;
		//如果是递增的
		if(isIncreasing)
		{
			result = 1;
			curNum = 1;
			for(int i = beg + 1 ; i <= end ; i++)
			{
				//后面不等于前面
				if(ratings.at(i) != ratings.at(i-1))
				{
					curNum++;
				}
				//相同元素，curNum不变，
				result += curNum;
			}
		}
		else
		{
			result = 1;
			curNum = 1;
			for(int i = end - 1 ; i >= beg ; i--)
			{
				//后面不等于前面
				if(ratings.at(i) != ratings.at(i+1))
				{
					curNum++;
				}
				//相同元素，curNum不变，
				result += curNum;
			}
		}
		return result;
	}

	int getCandy(vector<int>& ratings , int beg , int end)
	{
		if(ratings.empty() || beg < 0 || end >= ratings.size() || beg > end)
		{
			return 0;
		}
		//如果只有一个元素，直接返回1
		if(beg == end)
		{
			return 1;
		}
		//如果剩余部分从beg到end为单调增区间或减区间，直接返回结果是从1到end-beg的累加和
		int decrementBeg = beg;
		int decrementEnd = beg;
		int incrementBeg = beg;
		int incrementEnd = beg;
		int realDecrementBeg = beg;
		int realDecrementEnd = beg;
		int realIncrementBeg = beg;
		int realIncrementEnd = beg;
		int maxIncrementLen = 1;
		int maxDecrementLen = 1;
		//先计算从beg到end中最长单调增区间和单调减区间，需要记录各自的下标
		for(int i = beg + 1 ; i <= end ; i++)
		{
			//寻找最长单调增区间，相同的元素也包含进来
			if(ratings.at(i) >= ratings.at(i-1))
			{
				incrementEnd = i;
			}
			//说明后面比前面小，是单调减区间，此时应该计算单调增区间的长度,如果遇到相同的元素，不算
			else
			{
				if(incrementEnd - incrementBeg + 1 > maxIncrementLen)
				{
					maxIncrementLen = incrementEnd - incrementBeg + 1 ;
					realIncrementBeg = incrementBeg;
					realIncrementEnd = incrementEnd;
				}
				//需要重新设定单调增区间的起始点和结束点为当前
				incrementEnd = incrementBeg = i;
			}

			//寻找最长单调增区间
			if(ratings.at(i) <= ratings.at(i-1))
			{
				//累加单调减区间的结束值
				decrementEnd = i;
			}
			//说明后面比前面小，是单调减区间，此时应该计算单调增区间的长度
			else
			{
				//计算单调减区间的长度
				if( decrementEnd - decrementBeg + 1 > maxDecrementLen)
				{
					maxDecrementLen = decrementEnd - decrementBeg + 1;
					realDecrementBeg = decrementBeg;
					realDecrementEnd = decrementEnd;
				}
				//更新单调减区间的起始值为当前下标
				decrementBeg = decrementEnd = i;
			}
		}
		//可能存在一种情况，一直到最后一个元素都一直降序或升序，导致遗漏一次，需要计算
		if(incrementEnd - incrementBeg + 1 > maxIncrementLen)
		{
			maxIncrementLen = incrementEnd - incrementBeg + 1 ;
			realIncrementBeg = incrementBeg;
			realIncrementEnd = incrementEnd;
		}
		if( decrementEnd - decrementBeg + 1 > maxDecrementLen)
		{
			maxDecrementLen = decrementEnd - decrementBeg + 1;
			realDecrementBeg = decrementBeg;
			realDecrementEnd = decrementEnd;
		}

		//比较单调增区间和单调减区间谁的长度长，就选择谁的长度作为最高糖果数，并将区间划分
		int realBeg;
		int realEnd;
		int maxLen = max(maxIncrementLen , maxDecrementLen);

		//判断从beg到end是否一直是升序或降序，如果是，就直接计算出结果并返回
		if(maxLen == end - beg + 1)
		{
			int sum = 0;
			if(maxLen == maxIncrementLen)
			{
				sum = calculate(ratings , beg , end , true);
			}
			else
			{
				sum = calculate(ratings , beg , end , false);
			}
			return sum;
		}

		if( maxIncrementLen > maxDecrementLen)
		{
			realBeg = realIncrementBeg;
			realEnd = realIncrementEnd;
		}
		else
		{
			realBeg = realDecrementBeg;
			realEnd = realDecrementEnd;
		}
		//将区间划分成左右不分，
		int leftResult = getCandy(ratings , beg , realBeg - 1);
		int rightResult = getCandy(ratings , realEnd + 1 , end);
		int result = 0;
		if(maxLen == maxIncrementLen)
		{
			result = calculate(ratings , realBeg, realEnd , true);
		}
		else
		{
			result = calculate(ratings , realBeg, realEnd , false);
		}
		result += leftResult + rightResult;
		return result;
	}

    int candy(vector<int>& ratings) {
		if(ratings.empty())
		{
			return 0;
		}
		int result = getCandy(ratings , 0 , ratings.size() - 1);
		return result;
    }
*/