Leetcode_candy

最新推荐文章于 2023-03-26 19:41:14 发布

fibo_nacci

最新推荐文章于 2023-03-26 19:41:14 发布

阅读量538

点赞数

分类专栏： python Leetcode c++

本文链接：https://blog.csdn.net/flyupliu/article/details/23335725

版权

Leetcode 同时被 3 个专栏收录

155 篇文章 0 订阅

订阅专栏

c++

62 篇文章 0 订阅

订阅专栏

python

52 篇文章 0 订阅

订阅专栏

地址：http://oj.leetcode.com/problems/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?

思路：两次遍历，一次从头到尾，一次从尾到头，O(N)时间复杂度。

用分治法在第二十个case时wa了，case太多又无法自测。把wa的分治法代码贴出来，有哪位大哥大姐能看出错误请留个言啊。。。

参考代码：

class Solution {
public:
    int candy(vector<int> &ratings) {
        if(ratings.empty())
            return 0;
        vector<int>vec(ratings.size(), 1);
        for(int i = 0; i<ratings.size()-1; ++i)
        {
            if(ratings[i]<ratings[i+1])
            {
                vec[i+1] = vec[i]+1;
            }
        }
        for(int i = ratings.size()-2; i>=0; --i)
        {
            if(ratings[i]>ratings[i+1])
            {
                vec[i] = max(vec[i], vec[i+1]+1);
            }
        }
        return accumulate(vec.begin(), vec.end(), 0);
    }
};

分治法 WA 代码：

class Solution {
public:
    void dispatch(vector< int>&ratings, vector< int>&vec, int st, int ed)
    {
        if(st < ed - 1)
        {
            int mid = (st+ed)/2;
            dispatch(ratings, vec, st, mid);
            dispatch(ratings, vec, mid+1, ed);
            if(ratings[mid]<ratings[mid+1])
            {
                if(vec[mid]>=vec[mid+1])
                {
                    vec[mid+1] = vec[mid]+1;
                    int i = mid+1;
                    while(i<ed && ratings[i]<ratings[i+1])
                    {
                        vec[i+1] = vec[i]+1;
                        ++i;
                    }
                }
            }
            else if(ratings[mid]>ratings[mid+1])
            {
                if(vec[mid]<=vec[mid+1])
                {
                    vec[mid] = vec[mid+1]+1;
                    int i = mid;
                    while(i>st && ratings[i]<ratings[i-1])
                    {
                        vec[i-1] = vec[i]+1;
                        --i;
                    }
                }
            }
        }
        else if(st==ed)
            vec[st] = 1;
        else
        {
            if(ratings[st]<ratings[ed])
            {
                vec[st] = 1;
                vec[ed] = 2;
            }
            else if(ratings[st]>ratings[ed])
            {
                vec[st] = 2;
                vec[ed] = 1;
            }
            else
                vec[st] = vec[ed] = 1;
        }
    }
    int candy(vector< int> &ratings) {
        if(ratings.empty())
            return 0;
        vector< int>vec(ratings.size(), 0);
        dispatch(ratings, vec, 0, ratings.size()-1);
        int ans = accumulate(vec.begin(), vec.end(), 0);
        return ans;
    }
};

 
 
  
  //SECOND TRIAL, almost the same
 
 
 
 
  
  class 
  
  Solution 
  
  {
 
 
 
 
  
  public
  
  :
 
 
 
 
  
      
  
  int 
  
  candy
  
  (
  
  vector
  
  <
  
  int
  
  > 
  
  &
  
  ratings
  
  ) 
  
  {
 
 
 
 
  
          
  
  if
  
  (
  
  ratings
  
  .
  
  empty
  
  ())
 
 
 
 
  
              
  
  return 
  
  0
  
  ;
 
 
 
 
  
          
  
  vector
  
  <
  
  int
  
  >
  
  vec
  
  (
  
  ratings
  
  .
  
  size
  
  (), 
  
  0
  
  );
 
 
 
 
  
          
  
  vec
  
  [
  
  0
  
  ] 
  
  = 
  
  vec
  
  [
  
  vec
  
  .
  
  size
  
  ()
  
  -
  
  1
  
  ] 
  
  = 
  
  1
  
  ;
 
 
 
 
  
          
  
  for
  
  (
  
  int 
  
  i
  
  =
  
  0
  
  ; 
  
  i
  
  <
  
  ratings
  
  .
  
  size
  
  ()
  
  -
  
  1
  
  ; 
  
  ++
  
  i
  
  )
 
 
 
 
  
              
  
  if
  
  (
  
  ratings
  
  [
  
  i
  
  ]
  
  <
  
  ratings
  
  [
  
  i
  
  +
  
  1
  
  ])
 
 
 
 
  
                  
  
  vec
  
  [
  
  i
  
  +
  
  1
  
  ] 
  
  = 
  
  vec
  
  [
  
  i
  
  ]
  
  +
  
  1
  
  ;
 
 
 
 
  
              
  
  else
 
 
 
 
  
                  
  
  vec
  
  [
  
  i
  
  +
  
  1
  
  ] 
  
  = 
  
  1
  
  ;
 
 
 
 
  
          
  
  for
  
  (
  
  int 
  
  i
  
  =
  
  ratings
  
  .
  
  size
  
  ()
  
  -
  
  2
  
  ; 
  
  i
  
  >=
  
  0
  
  ; 
  
  --
  
  i
  
  )
 
 
 
 
  
              
  
  if
  
  (
  
  ratings
  
  [
  
  i
  
  ]
  
  >
  
  ratings
  
  [
  
  i
  
  +
  
  1
  
  ])
 
 
 
 
  
                  
  
  vec
  
  [
  
  i
  
  ] 
  
  = 
  
  max
  
  (
  
  vec
  
  [
  
  i
  
  ], 
  
  1
  
  +
  
  vec
  
  [
  
  i
  
  +
  
  1
  
  ]);
 
 
 
 
  
  

 
 
 
 
  
          
  
  return 
  
  accumulate
  
  (
  
  vec
  
  .
  
  begin
  
  (), 
  
  vec
  
  .
  
  end
  
  (), 
  
  0
  
  );
 
 
 
 
  
      
  
  }
 
 
 
 
  
  };

python version

 
 
  
  class 
  
  Solution
  
  :
 
 
 
 
  
      
  
  # @param ratings, a list of integer
 
 
 
 
  
      
  
  # @return an integer
 
 
 
 
  
      
  
  def 
  
  candy
  
  (
  
  self
  
  , 
  
  ratings
  
  ):
 
 
 
 
  
          
  
  if 
  
  not 
  
  ratings
  
  :
 
 
 
 
  
              
  
  return 
  
  0
 
 
 
 
  
          
  
  vec 
  
  = 
  
  [
  
  1
  
  ]
  
  *
  
  len
  
  (
  
  ratings
  
  )
 
 
 
 
  
          
  
  for 
  
  i 
  
  in 
  
  range
  
  (
  
  0
  
  , 
  
  len
  
  (
  
  ratings
  
  )
  
  -
  
  1
  
  ):
 
 
 
 
  
              
  
  if 
  
  ratings
  
  [
  
  i
  
  ] 
  
  < 
  
  ratings
  
  [
  
  i
  
  +
  
  1
  
  ]:
 
 
 
 
  
                  
  
  vec
  
  [
  
  i
  
  +
  
  1
  
  ] 
  
  = 
  
  1 
  
  + 
  
  vec
  
  [
  
  i
  
  ]
 
 
 
 
  
          
 
 
 
 
  
          
  
  for 
  
  i 
  
  in 
  
  range
  
  (
  
  len
  
  (
  
  ratings
  
  )
  
  -
  
  2
  
  , 
  
  -
  
  1
  
  , 
  
  -
  
  1
  
  ):
 
 
 
 
  
              
  
  if 
  
  ratings
  
  [
  
  i
  
  ] 
  
  > 
  
  ratings
  
  [
  
  i
  
  +
  
  1
  
  ]:
 
 
 
 
  
                  
  
  vec
  
  [
  
  i
  
  ] 
  
  = 
  
  max
  
  (
  
  vec
  
  [
  
  i
  
  ], 
  
  1
  
  +
  
  vec
  
  [
  
  i
  
  +
  
  1
  
  ])
 
 
 
 
  
          
 
 
 
 
  
          
  
  return 
  
  sum
  
  (
  
  vec
  
  )