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?

Solution:

最开始想到的是 从左往右循环，如果遇到 左边小于右边的， 右边的+1。 遇到左边大于右边的， 回退，直到右边大于左边，给每一个元素+1， 这样时间复杂度是O(n^2)。 得降：

接着就想到用stack，循环从左边开始，如果发现左边比右边大 则入stack，直到左边比右边小 ，然后出stack，给每个出stack的数加上其在stack里面的位置，即深度。

如果当前点比它前面的点大呢？ candy[i] = candy[i - 1] + 1; 否则， candy[i] = 1;

这里新建了一个数组，rating， 它扩展了原数组，末尾加了一个-1， 用于对最后一个元素进行判断。

对于栈底元素，即临界元素，其值应该等于左边得到的值 和通过栈的到的值中间最大的那一个。

还要在循环外， 对stack进行一次操作。

对最后一个点 还得讨论，

1）如果最后一个点 比 前一个小 则不变
2）比前一个大 则为D(n -1) + 1

 

464 ms过大测试~~时间复杂度 O(n)。

 public class Solution {
     public int candy(int[] ratings) {
         // Note: The Solution object is instantiated only once and is reused by each test case.
         int l = ratings.length;
         int[] rating = new int[l + 1];
         for(int i = 0; i < l; i ++){
             rating[i] = ratings[i];
         }
         rating[l] = -1;
         int sum = 0;
         int d = 0;
         int[] candy = new int[l];
         Stack<Integer> st = new Stack<Integer>();
         for(int i = 0; i < l; i ++){
             if(i > 0 && rating[i] > rating[i - 1]){
                 candy[i] = candy[i - 1] + 1;
             }else{
                 candy[i] = 1;
             }
             if(rating[i] > rating[i+1]){
                 st.push(i);
             }else{
                 d = st.size();
                 if(d > 0){
                     for(int ii = 0; ii < d - 1; ii ++){
                         int cur = st.pop();
                         candy[cur] += ii+1;
                     }
                     int cur = st.pop();
                     candy[cur] = ((d + 1) > candy[cur] ? (d + 1) : candy[cur]);// d+1 原因： 最小的那个元素没有入栈，栈的深度少了1.
                 }
             }

         }
         d = st.size();
         for(int ii = 0; ii < d - 1; ii ++){
             int cur = st.pop();
             candy[cur] += ii;
         }
         int cur = st.pop();
         candy[cur] = (d > candy[cur] ? d : candy[cur]);
         for(int i = 0; i < candy.length; i ++){
             sum += candy[i];
         }
         return sum;
     }
 }

其实，这一题可以想象成一个波， 它有上升和下降。 第一遍，考虑上升的所以情况； 第二遍，考虑下降的所以情况。 然后对于波峰，用两边的max 值当成它的值即可。

这样 思路变得更加清晰。

 public class Solution {
     public int candy(int[] ratings) {
         // Note: The Solution object is instantiated only once and is reused
 //by each test case.
         int rLen = ratings.length;
         if (rLen == 0) return 0;
         int min = rLen; int give = 0;
         int[] gives = new int[rLen];
         for (int i = 1; i < rLen; i++) {
             if (ratings[i] > ratings[i - 1]) give++;
             else give = 0;
             gives[i] = give;
         }
         give = 0;
         for (int i = rLen - 2; i >= 0; i--) {
             if (ratings[i] > ratings[i + 1]) give++;
             else give = 0;
             min += Math.max(give, gives[i]);
         }
         min += gives[rLen - 1];
         return min;
     }
 }

find out all local min rating, 
for each local min rating, start with 1 candy, and expand on both directions
until hit by local max.
return total candies.

O(n)

第二遍： 波的方法， 左边走一次右边走一次。

 public class Solution {
     public int candy(int[] ratings) {
         // Note: The Solution object is instantiated only once and is reused by each test case.
         if(ratings == null || ratings.length == 0) return 0;
         int len = ratings.length;
         int[] candy = new int[len];
         int sum = 0;
         for(int i = 0; i < len; i ++)
             candy[i] = 1;
         for(int i = 1; i < len; i ++){
             if(ratings[i - 1] < ratings[i]) candy[i] = candy[i - 1] + 1;
         }
         for(int i = len - 1; i > 0; i --){
             if(ratings[i] < ratings[i - 1]) candy[i - 1] = Math.max(candy[i - 1], candy[i] + 1);
         }
         for(int i = 0; i < len; i ++)
             sum += candy[i];
         return sum;
     }
 }