【LeetCode candy】

135.Candy

解题思路

我首先想到的是如果序列是递增的，那么序列的值是逐渐递增的。如果序列是递减的，那么从最小的开始，往回来是递增的。如果遇到相等，就是1。

class Solution {
    public int candy(int[] ratings) {
        if (ratings.length == 1){
            return 1;
        }
        int[] res = new int[ratings.length];
        res[0] = 1;
        for (int i = 1; i < ratings.length; i++){
            if (ratings[i] >= ratings[i-1]){
                int start = i-1;
                while (i < ratings.length && ratings[i] >= ratings[i-1]){
                    i++;
                }
                int k = 1;
                for (int j = start; j < i-1; j++){
                    if (ratings[j] < ratings[j+1]){
                        res[j] = k;
                        k++;
                    }
                    else {
                        if (j - 1 < 0){
                            res[j] = 1;
                            continue;
                        }
                        if (ratings[j] > ratings[j-1]){
                            res[j] = k;
                            k = 1;
                            continue;
                        }
                        res[j] = 1;
                        //k = 1;
                    }
                }
                res[i-1] = k;
                i--;
            }
            if (ratings[i] < ratings[i-1]){
                int start = i-1;
                while (i < ratings.length && ratings[i] <= ratings[i-1]){
                    i++;
                }
                int k = 1;
                for (int j = i-1; j > start; j--){
                    if (ratings[j] < ratings[j-1]){
                        res[j] = k;
                        k++;
                    }
                    else {
                        if (j + 1 >= i){
                            res[j] = 1;
                            continue;
                        }
                        if (ratings[j] < ratings[j+1]){
                            res[j] = k;
                            k = 1;
                            continue;
                        }
                        res[j] = 1;
                        //k = 1;
                    }
                }
                res[start] = Math.max(k, res[start]);
                i--;
                continue;
            }
        }
        int sum = 0;
        for (int i = 0; i < res.length; i++){
            sum += res[i];
        }
        return sum;
    }
}

但是最后一个例子没有通过，说明还是有问题。
在网上看了一个新的思路，就是从左边往右边遍历，如果遇到右边比左边大，则右边比左边结果加1。然后从右边遍历，如果左边比右边大，如果左边结果小于右边结果，那么左边结果为右边结果加1。
其实在前一个思路中已经有一些端倪，可以通过往回遍历修改当前值了。其实上一个思路是这个思路的复杂实现。同样是遇到上升加1，遇到相等边为1，遇到下降往回遍历修改。那么既然是互相不干扰，可以分别便来实现。
代码如下

public class Candy {
    public int candy(int[] ratings) {
        int size = ratings.length;
        if (size == 0){
            return 0;
        }
        if (size == 1){
            return 1;
        }
        int[] res = new int[size];
        res[0] = 1;
        for (int i = 1; i < size; i++){
            if (ratings[i] > ratings[i-1]){
                res[i] = res[i-1] + 1;
            }
            else {
                res[i] = 1;
            }
        }
        for (int i = size-2; i >= 0; i--){
            if (ratings[i] > ratings[i+1]){
                res[i] = Math.max(res[i], res[i+1] + 1);
            }
        }
        int sum = 0;
        for (int i = 0; i < size; i++){
            sum += res[i];
        }
        return sum;
    }
}