135. Candy

原网址为https://leetcode.com/problems/candy/description/

一、题目

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?

二、代码

class Solution {
public:
    int candy(vector<int>& ratings) {
        int size = ratings.size();
        vector<pair<int, int> > indexAndRatings(size);
        vector<int> nums(size, 0);
        for (int i = 0; i < size; i++) {
            indexAndRatings[i].first = i;
            indexAndRatings[i].second = ratings[i];
        }
        
        sort(indexAndRatings);
        int sum = 0;
        for (int i = 0; i < size; i++) {
            nums[indexAndRatings[i].first] = max(nums, ratings, indexAndRatings[i]);
            sum += nums[indexAndRatings[i].first];
        }
        return sum;
    }
    
    void sort(vector<pair<int, int> >& indexAndRatings) {
        mergeSort(indexAndRatings, 0, indexAndRatings.size() - 1);
    }
    
    void mergeSort(vector<pair<int, int> >& indexAndRatings, int start, int end) {
        if (start >= end) return;
        int medium = (start + end) / 2;
        mergeSort(indexAndRatings, start, medium);
        mergeSort(indexAndRatings, medium + 1, end);
        
        int i = start;
        int j = medium + 1;
        
        vector<pair<int, int> > tmp;
        
        while (i <= medium && j <= end) {
            if (indexAndRatings[i].second <= indexAndRatings[j].second) {
                tmp.push_back(indexAndRatings[i++]);
            } else {
                tmp.push_back(indexAndRatings[j++]);
            }
        }
        
        while (i <= medium) {
            tmp.push_back(indexAndRatings[i++]);
        }
        
        while (j <= end) {
            tmp.push_back(indexAndRatings[j++]);
        }
        
        for (int i = start; i <= end; i++) {
            indexAndRatings[i] = tmp[i - start];
        }
    }
    
    int max(vector<int>& nums, vector<int>& ratings, pair<int, int> iap) {
        int left = iap.first - 1 ;
        int right = iap.first + 1;
        
        if (nums.size() == 1) return 1;
        if (iap.first == 0) {
            if (nums[right] != 0) {
                if (iap.second == ratings[right]) return 1;
                else return nums[right] + 1;
            } else return 1;
        }
        
        if (iap.first == nums.size() - 1) {
            if (nums[left] != 0) {
                if (iap.second == ratings[left]) return 1;
                else return nums[left] + 1;
            } else return 1;
        }
        
        if (nums[left] != 0 && nums[right] != 0) {
            int max;
            int maxIndex;
            if (iap.second == ratings[left] && iap.second == ratings[right]) return 1;
            if (iap.second == ratings[left] && iap.second > ratings[right]) {
                 return nums[right] + 1;
            }
            if (iap.second > ratings[left] && iap.second == ratings[right]) {
                return nums[left] + 1;
            }
            else {
                if (nums[left] > nums[right]) return nums[left] + 1;
                else return nums[right] + 1;
            }
        }
        
        if (nums[left] != 0) {
            if (iap.second == ratings[left]) return 1;
            else return nums[left] + 1;
        }
        
        if (nums[right] != 0) {
            if (iap.second == ratings[right]) return 1;
            else return nums[right] + 1;
        }
        
        return 1;
    }
};