LeetCode:Candy

题目地址：here

题目大意：几个小孩站一排，每个小孩有个等级值，现在给小孩发糖，发的时候要遵守2个规则：（1）每个小孩至少一颗糖（2）两个相邻的小孩中，等级大的小孩一定比等级小的小孩糖多，求发糖的数目的最小值。

本文提供两个算法，第一个是我自己做题时用的，第二个是网上看题解时看到的

算法1：该算法采用分治发，把小孩平均分左右两拨，求得两拨小孩的最小值分配方案后，还得看分界线出是否满足规则。我们用L[end]表示左边一拨小孩的右边界，R[start]表示右边一拨小孩的左边界，处理分界线出的情况分以下两种：

（1）如果L[end]等级比R[start]高，但是糖数少或相等，那么就从左边一拨小孩的右边界依次调整糖数以满足规则；

（2）如果L[end]等级比R[start]低，但是糖数多或相等，那么就从右边一拨小孩的左边界依次调整糖数以满足规则；

该算法时间复杂度为O(N*lgN)

算法1代码如下：

class Solution {
public:
    int candy(vector<int> &ratings)
    {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        int *candyNum = new int[ratings.size()];//每个小孩的糖数目
        memset(candyNum,0,sizeof(int)*ratings.size());
        int result = candyRecursive(ratings, 0, ratings.size()-1, candyNum);
        delete []candyNum;
        return result;
    }

    int candyRecursive(vector<int> &ratings, int startloc, int endloc,
                     int candyNum[])
    {
        if(startloc == endloc)
        {
            candyNum[startloc] = 1;
            return 1;
        }
        int middle = (startloc + endloc)/2;
        int rightCandy = candyRecursive(ratings, middle+1, endloc, candyNum);
        int leftCandy = candyRecursive(ratings, startloc, middle, candyNum);
        if(ratings[middle+1] > ratings[middle])
        {
            int tmp = candyNum[middle+1] - candyNum[middle];
            if(tmp <= 0)
            {
                tmp *= -1;
                candyNum[middle+1] += (tmp+1);
                rightCandy += (tmp+1);
                for(int i = middle+2; i <= endloc; i++)
                {
                    if(ratings[i] > ratings[i-1] && candyNum[i] <= candyNum[i-1])
                    {
                        int foo = candyNum[i-1] - candyNum[i] + 1;
                        candyNum[i] += foo;
                        rightCandy += foo;
                    }
                    else break;
                }
            }
        }
        else if(ratings[middle+1] < ratings[middle])
        {
            int tmp = candyNum[middle+1] - candyNum[middle];
            if(tmp >= 0)
            {
                candyNum[middle] += (tmp+1);
                leftCandy += (tmp+1);
                for(int i = middle-1; i >= startloc; i--)
                {
                    if(ratings[i] > ratings[i+1] && candyNum[i] <= candyNum[i+1])
                    {
                        int foo = (candyNum[i+1] - candyNum[i] + 1);
                        candyNum[i] += foo;
                        leftCandy += foo;
                    }
                    else break;
                }
            }
        }
        return leftCandy + rightCandy;
    }
};

算法2：初始化所有小孩糖数目为1，从前往后扫描，如果第i个小孩等级比第i-1个高，那么i的糖数目等于i-1的糖数目+1；从后往前扫描，如果第i个的小孩的等级比i+1个小孩高,但是糖的数目却小或者相等，那么i的糖数目等于i+1的糖数目+1。

该算法时间复杂度为O(N)

算法2代码如下：

class Solution {
public:
    int candy(vector<int> &ratings)
    {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        int *candyNum = new int[ratings.size()];//每个小孩的糖数目
        for(int i = 0; i < ratings.size(); i++)
            candyNum[i] = 1;
        for(int i = 1; i < ratings.size(); i++)
            if(ratings[i] > ratings[i-1])
                candyNum[i] = candyNum[i-1] + 1;
        for(int i = ratings.size()-2; i>=0; i--)
            if(ratings[i] > ratings[i+1] && candyNum[i] <= candyNum[i+1])
                candyNum[i] = candyNum[i+1] + 1;
        int result = 0;
        for(int i = 0; i < ratings.size(); i++)
            result += candyNum[i];
        delete []candyNum;
        return result;
    }
};

 【版权声明】转载请注明出处：http://www.cnblogs.com/TenosDoIt/p/3389479.html