135.Candy---贪心

题目链接

题目大意：分糖果，每个小朋友都有一个ratings值，且每个小朋友至少都要有一个糖果，而且每个小朋友的ratings值如果比左右邻舍的小朋友的ratings值高，则其糖果数量也比邻舍的小朋友多。

法一：超时。按照要求，从前往后比较每个小朋友的ratings值，如果后一个小朋友的ratings值比前一个大，则更新小朋友糖果值dp[i]=dp[i-1]+1；否则，将当前小朋友的糖果值置1，然后考察其前一个小朋友糖果值是否满足dp[i-1]<=dp[i]，且ratings[i-1]>ratings[i]，如果满足这两个条件，则说明前小朋友的糖果值需要更新，且需要循环遍历更新前面小朋友的糖果值。o(n^2)。代码如下：

     public int candy(int[] ratings) {
         int len = ratings.length;
         if(len == 0) {
             return 0;
         }
         else if(len == 1) {
             return 1;
         }
         int[] dp = new int[len];
         //初始化第一个小伙伴的糖果值
         dp[0] = ratings[0] <= ratings[1] ? 1 : 2;
         int cnt = 0;
         for(int i = 1; i < len; i++) {
             //只与前面小伙伴的ratings进行比较
             if(ratings[i] > ratings[i - 1]) {
                 dp[i] = dp[i - 1] + 1;
             }
             else {
                 dp[i] = 1;
                 //如果前面小伙伴的糖果是1，且ratings比较高，则遍历其前面的所有小伙伴
                 if(dp[i - 1] == 1 && ratings[i - 1] > ratings[i]) {
                     //更新前面的小伙伴的糖果值，因为这个更新，对于这种用例5，3，1，这个小伙伴前面的所有糖果值都要更新，所以进入下面的for循环进行判断
                     dp[i - 1] = 2;
                     for(int j = i - 2; j >= 0; j--) {
                         //如果前面的小伙伴的糖果值小，且ratings又比较高，则更新其值
                         if(ratings[j] > ratings[j + 1] && dp[j] <= dp[j + 1]) {
                             dp[j] = dp[j + 1] + 1;
                         }
                         else {
                             break;
                         }
                     }
                 }
             }
         }
         //计算所有的糖果值
         for(int i = 0; i < len; i++) {
             cnt += dp[i];
         }
         return cnt;
     }

法二（借鉴）：两个数组，一个数组从前往后遍历，一旦ratings值比前一个大，则dp[i]=dp[i-1]+1；一个数组从后往前遍历，一旦ratings值比后一个大，则dp[i]=dp[i+1]+1。最后从这两个数组中取一个较大者，计算最终糖果值。o(n)。当然也可以用一个数组，但是思想逻辑都是一样的，只是如果用一个数组的话，就是从后往前遍历得到的新值与当前数组值进行比较，取较大者就是了。代码如下（耗时5ms）：

     public int candy(int[] ratings) {
         int len = ratings.length;
         if(len == 0) {
             return 0;
         }
         else if(len == 1) {
             return 1;
         }
         int[] left_candy = new int[len];
         int[] right_candy = new int[len];
         //初始化
         left_candy[0] = ratings[0] <= ratings[1] ? 1 : 2;
         right_candy[len - 1] = ratings[len - 1] <= ratings[len - 2] ? 1 : 2;
         //从前往后遍历
         for(int i = 1; i < len; i++) {
             if(ratings[i] > ratings[i - 1]) {
                 left_candy[i] = left_candy[i - 1] + 1;
             }
             else {
                 left_candy[i] = 1;
             }
         }
         //从后往前遍历
         for(int j = len - 2; j >= 0; j--) {
             if(ratings[j] > ratings[j + 1]) {
                 right_candy[j] = right_candy[j + 1] + 1;
             }
             else {
                 right_candy[j] = 1;
             }
         }
         //两者中取较大者，计算糖果值
         int cnt = 0;
         for(int i = 0; i < len; i++) {
             cnt += Math.max(left_candy[i], right_candy[i]);
         }
         return cnt;
     }

法三（借鉴）：最优解。只遍历一遍，o(n)。一旦遍历到递减rating，则计数递减的个数，而暂停计算其糖果值；当遍历到递增rating时，则开始计算前面递减的小朋友的糖果值，以及当前小朋友的糖果值。具体注释看代码。代码如下（耗时5ms）：

     public int candy(int[] ratings) {
         int first = 1, cnt = 0, res = 1, len = ratings.length;
         for(int i = 1; i < len; i++) {
             //如果比前一个小朋友rating高，则计算总糖果值
             if(ratings[i] >= ratings[i - 1]) {
                 //如果当前小朋友前面有递减rating，先处理这几个小朋友的糖果值
                 if(cnt > 0) {
                     //从递减的第二个数开始，到最后一个递减rating结束为止，这几个小朋友的糖果总值就是cnt * (cnt + 1) / 2
                     res += cnt * (cnt + 1) / 2;
                     //处理开始递减的第一个数，即将其需要增加的糖果数cnt-res+1，加入res中
                     if(cnt >= first) {
                         res += cnt - first + 1;
                     }
                     //重置
                     cnt = 0;
                     first = 1;
                 }
                 //对于当前第i个小朋友，正常计算其糖果值，将其加入res结果中
                 first = (ratings[i] == ratings[i - 1]) ? 1 : first + 1;
                 res += first;
             }
             //计数递减rating的个数
             else {
                 cnt++;
             }
         }
         //处理最后一组递减rating，而其后没有再反弹的小伙伴，即一直递减，不满足ratings[i] >= ratings[i - 1]就到数组终结
         if(cnt > 0) {
             res += cnt * (cnt + 1) / 2;
             if(cnt >= first) {
                 res += cnt - first + 1;
             }
         }
         return res;
     }