力扣135. 分发糖果

 

题目：【https://leetcode.cn/problems/candy/description/?envType=study-plan-v2&envId=top-interview-150】

 

想了一个办法，依次向后遍历，遇到下降（不包含相等）的情况，就将其置为1，并且开始第二层循环，从当前位置向前，依次往前加一，最差情况下时间复杂度接近n的平方，不是最优解

 1 class Solution {
 2 public:
 3     int candy(vector<int>& ratings) {
 4         int n = ratings.size();
 5         vector<int> cache(n);
 6 
 7         int ret = 1;
 8         cache[0] = 1;
 9         for (int i = 1; i < n; ++i) {
10             int l = ratings[i - 1], r = ratings[i];
11             if (l < r) {
12                 cache[i] = cache[i - 1] + 1; ret += cache[i];
13                 continue;
14             }
15 
16             cache[i] = 1; ret += cache[i];
17             for (int j = i; j >= 1; --j) {
18                 int l = ratings[j - 1], r = ratings[j];
19                 if (l > r && cache[j - 1] <= cache[j]) {
20                     cache[j - 1]++; ret++;
21                 } else {
22                     break;
23                 }
24             }
25         }
26 
27         return ret;
28     }
29 };

 

时间复杂度优化一下，优化至n，代码如下，优化思路是直接根据下降数量count来直接决定需要向前填补的+1数量，这样就不用再cache数组中向前依次+1了。

 1 class Solution {
 2 public:
 3     int candy(vector<int>& ratings) {
 4         int n = ratings.size();
 5         vector<int> cache(n);
 6 
 7         int count = 0;
 8         int f;
 9         int ret = 1;
10         cache[0] = 1;
11         for (int i = 1; i < n; ++i) {
12             int l = ratings[i - 1], r = ratings[i];
13             if (l < r) {
14                 count = 0;
15                 cache[i] = cache[i - 1] + 1; ret += cache[i];
16                 continue;
17             } else if (l == r) {
18                 count = 0;
19                 cache[i] = 1; ret++;
20                 continue;
21             }
22 
23             cache[i] = 1; ret++;
24             count++;
25             if (1 == count)
26                 f = cache[i - 1];
27 
28             ret += count < f ? count - 1 : count;
29         }
30 
31         return ret;
32     }
33 };

 

空间复杂度方面优化一下，优化至n，不过还不是最终形态，空间优化可以通过cache数组操作很容易发现一个问题，就是仅仅需要保存一个【首次开始降低的candy数量】和一个【cache数组的i - 1】，其它并不需要。

 1 class Solution {
 2 public:
 3     int candy(vector<int>& ratings) {
 4         int n = ratings.size();
 5         // vector<int> cache(n);
 6 
 7         int count = 0;
 8         int f;
 9         int ret = 1;
10         int p = 1;//cache[0] = 1;
11         int c = 1;
12         for (int i = 1; i < n; ++i) {
13             int l = ratings[i - 1], r = ratings[i];
14             if (l < r) {
15                 count = 0;
16                 c = p + 1; ret += c;// cache[i] = cache[i - 1] + 1; ret += cache[i];
17                 p = c; c = 1;
18                 continue;
19             } else if (l == r) {
20                 count = 0;
21                 /* c = 1; */ ret++;// cache[i] = 1; ret++;
22                 p = c; c = 1;
23                 continue;
24             }
25 
26             /* c = 1; */ ret++;// cache[i] = 1; ret++;
27             count++;
28             if (1 == count)
29                 f = p;// f = cache[i - 1];
30 
31             ret += count < f ? count - 1 : count;
32             p = c; c = 1;
33         }
34 
35         return ret;
36     }
37 };

 

最后简化逻辑，将时间空间都优化成On

 1 class Solution {
 2 public:
 3     int candy(vector<int>& ratings) {
 4         int n = ratings.size();
 5 
 6         int count = 0;
 7         int f;
 8         int ret = 1;
 9         int p = 1;
10         for (int i = 1; i < n; ++i) {
11             int l = ratings[i - 1], r = ratings[i];
12             if (l < r) {
13                 count = 0;
14                 p++;
15                 ret += p;
16                 continue;
17             } else if (l == r) {
18                 count = 0;
19                 ret++;
20                 p = 1;
21                 continue;
22             }
23 
24             count++; if (1 == count) f = p;
25 
26             ret += count < f ? count : count + 1;
27             p = 1;
28         }
29 
30         return ret;
31     }
32 };

 

posted @ 2025-05-28 15:01  J&YANG  阅读(11)  评论(0)    收藏  举报