【leetcode】Candy（hard) 自己做出来了 但别人的更好

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?

 

注意，像 6 5 5 4 这样的 可以分 2 1 2 1 就是数字相同的不需要糖果数相同

我的思路，分别用两个vector存储递增和递减所需要的糖果，最终结果取两个的最大值

如 权重    6 6 1 5 4 4 3 7 4 2 2 2 5 4 3 5

找递增     1 1 1 2 1 1 1 2 1 1 1 1 2 1 1 2   从前向后找，初始都是1，遇到递增的就加上他前面查找的数字

找递减     1 2 1 2 1 2 1 3 2 1 1 1 3 2 1 1   从后向前找，初始都是1，遇到递增的就加上他前面查找的数字

最终        1 2 1 2 1 2 1 3 2 1 1 1 3 2 1 2

int candy(vector<int> &ratings) {

        int ans = 0;

        vector<int> candysUp(ratings.size(), 1);

        vector<int> candysDown(ratings.size(), 1);

        for(int i = 1; i < ratings.size(); i++) //查找递增

        {

            if(ratings[i] > ratings[i - 1])

            {

                candysUp[i] += candysUp[i - 1];

            }

        }

        for(int i = ratings.size() - 2; i >= 0; i--) //查找递减

        {

            if(ratings[i + 1] < ratings[i])

            {

                candysDown[i] += candysDown[i + 1];

            }

        }



        for(int i = 0; i < ratings.size(); i++)

        {

            ans += max(candysUp[i], candysDown[i]);

        }

        return ans;

    }

 

大神只循环一遍的思路：

其实整体思想跟上面一样，但是上面需要循环很多次是因为递增和递减分别处理。因为递减时不知道最大的数应该加几。

大神的思路是递增的就像上面那样加，但是递减的，先都加1，如果后面仍是递减的，再把之前少加的给加回来（如前面有nSeqLen个数字少加了1，就把答案直接多加一个nSeqLen）。

    //大神循环一遍的代码

    int candy2(vector<int> &ratings) {

    int nCandyCnt = 0;///Total candies

    int nSeqLen = 0;  /// Continuous ratings descending sequence length

    int nPreCanCnt = 1; /// Previous child's candy count

    int nMaxCntInSeq = nPreCanCnt;

    if(ratings.begin() != ratings.end())

    {

        nCandyCnt++;//Counting the first child's candy.

        for(vector<int>::iterator i = ratings.begin()+1; i!= ratings.end(); i++)

        {

            // if r[k]>r[k+1]>r[k+2]...>r[k+n],r[k+n]<=r[k+n+1],

            // r[i] needs n-(i-k)+(Pre's) candies(k<i<k+n)

            // But if possible, we can allocate one candy to the child,

            // and with the sequence extends, add the child's candy by one

            // until the child's candy reaches that of the prev's.

            // Then increase the pre's candy as well.



            // if r[k] < r[k+1], r[k+1] needs one more candy than r[k]

            if(*i < *(i-1))

            {

                //Now we are in a sequence

                nSeqLen++;

                if(nMaxCntInSeq == nSeqLen)

                {

                    //The first child in the sequence has the same candy as the prev

                    //The prev should be included in the sequence.

                    nSeqLen++;

                }

                nCandyCnt+= nSeqLen;

                nPreCanCnt = 1;

            }

            else

            {

                if(*i > *(i-1))

                { 

                    nPreCanCnt++;

                }

                else

                {

                    nPreCanCnt = 1;

                }

                nCandyCnt += nPreCanCnt;

                nSeqLen = 0;

                nMaxCntInSeq = nPreCanCnt;

            }   

        }

    }

    return nCandyCnt;

}