leetcode Candy

1 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?

解析：

1 先求出相邻小孩的优先级。

2 积分得到每个小孩的糖果数。再加上最小小孩糖果数等于1的限制条件。

3 积分得到总的糖果数。

代码如下：

    /*
     * 优先级相同时，糖果数相同
     */
    private int sign(int i) {
        if (i > 0) { return 1; }
        if (i < 0) { return -1; }
        return 0;
    }
    
    private int[] candyDelta(int[] ratings) {
        // delta保存与上一个小孩的优先级
        int[] delta = new int[ratings.length];
        delta[0] = 0;
        for (int i = 1; i < ratings.length; i++) {
            delta[i] = sign(ratings[i] - ratings[i-1]);
        }
        return delta;
    }
    
    private int calCandies(int[] delta) {
        // 计算第一个小孩糖果数为0时，每一个小孩的糖果数。这里糖果数可能为负。
        int[] candies = new int[delta.length];
        candies[0] = 0;
        for (int i = 1; i < candies.length; i++) {
            candies[i] = candies[i-1] + delta[i];
        }

        // 找到糖果数最小的小孩
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < candies.length; i++) {
            if (min > candies[i]) {
                min = candies[i];
            }
        }
        
        // 糖果数最小的小孩给1个糖果，并据此分配糖果给其他小絯
        for (int i = 0; i < candies.length; i++) {
            candies[i] = candies[i] - min + 1; 
        }
        // 计算糖果数
        Integer total = 0;
        for (int candy : candies) {
            total += candy;
        }
        return total;
    }
    
    public int candy(int[] ratings) {   
        if (ratings.length == 1) {
            return 1;
        }
        
        int[] delta = candyDelta(ratings);

        int total = calCandies(delta);

        return total;
    }

2 Candy

代码1放到leetcode中，通不过{1,2,2}这个测试用例，返回5，而leetcode结果是4。其原因在于题设中并没有限定两个相邻的rating相同的小孩的糖果数相等。

可以在有相邻小孩rating相同处截断，然后分别计算两部分的candies。

更进一步的，可以从左往右计算，在左边小孩权重不小于右边小孩处截断；然后从右往左计算，在右边小孩权重不小于左边小孩处截断。

即从左往右报数时，第一次的计算结果是满足条件的；从右往左报数时，第二次的计算结果是满足条件的。最后将两次的计算结果合并，即为最终解。

代码如下：

    private void calCandies(int[] candies, int[] ratings) {
        candies[0] = 1;
        if (ratings.length == 1) { return; }
        
        // 从左往右
        int[] candiesLeft = new int[ratings.length];
        candiesLeft[0] = 1;
        for (int i = 1; i < ratings.length; i++) {
            if (ratings[i] > ratings[i-1]) {
                candiesLeft[i] = candiesLeft[i-1] + 1;
            }else {
                candiesLeft[i] = 1;
            }
        }
        
        // 从右往左
        int[] candiesRight = new int[ratings.length];
        candiesRight[ratings.length-1] = 1;
        for (int i = ratings.length-2; i >= 0; i--) {
            if (ratings[i] > ratings[i+1]) {
                candiesRight[i] = candiesRight[i+1] + 1;
            }else {
                candiesRight[i] = 1;
            }
        }
        
        // 合并
        for (int i = 0; i < candies.length; i++) {
            candies[i] = Math.max(candiesLeft[i], candiesRight[i]);
        }
    }


    public int candy(int[] ratings) {
        if (ratings.length == 1) {
            return 1;
        }

        int[] candies = new int[ratings.length];
        calCandies(candies, ratings);

        // 计算糖果数
        Integer total = 0;
        for (int candy : candies) {
            total += candy;

        }
        return total;
    }