LeetCode

Candy

2014.2.25 21:34

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:

　　This problem seemed vague to me at first, as the key sentence in the problem: Children with a higher rating get more candies than their neighbors. It didn't specify the case for neighbors with equal rates.

　　For the sample case {7, 8, 4}, the result will be {1, 2, 1}. While the case {7, 8, 8} yields the result {1, 2, 1}.

　　Note that problem didn't tell you what to do when neighbors got the same rate value, you might assume that you can choose the way that saves most candies.

　　My first solution was to cut the sequence in half where neighbors got the same rate. For example {2, 3, 4, 7, 7, 2, 89, 21} => {2, 3, 7} + {7, 2, 89, 21}, and deal with each sequence as a subproblem. But it proved to be a bad idea later, the code wasn't so easy to write.

　　Then I sought another stupid way: do exactly as the problem told me:

　　　　1. Every child get one candy at first.

　　　　2. If a child's rate is higher than its left neighbor, he gets one more than his left neighbor.

　　　　3. If a child's rate is higher than its right neighbor, he gets one more than his right neighbor.

　　You would probably have known what I think: initialize an array, scan right, scan left and add'em up.

　　Total time complexity is O(n). Space complexity is O(n), too.

　　I believe there are O(n) solutions using only constant space, but haven't come up with a concise solution yet.

Accepted code:

// 1AC, DP solution with O(n) time and space.
class Solution {
public:
    int candy(vector<int> &ratings) {
        int i, n;
        
        n = (int)ratings.size();
        if (n == 0) {
            return 0;
        }
        
        vector<int> candy;
        int result;
        
        candy.resize(n);
        for (i = 0; i < n; ++i) {
            candy[i] = 1;
        }
        for (i = 0; i <= n - 2; ++i) {
            if (ratings[i] < ratings[i + 1]) {
                // at least one more candy
                candy[i + 1] = candy[i] + 1;
            }
        }
        for (i = n - 2; i >= 0; --i) {
            if (ratings[i] > ratings[i + 1] && candy[i] <= candy[i + 1]) {
                candy[i] = candy[i + 1] + 1;
            }
        }
        result = 0;
        for (i = 0; i < n; ++i) {
            result += candy[i];
        }
        candy.clear();
        
        return result;
    }
};