to: 添加注释

Author: yi-ge

src/array/adding_two_negabinary_numbers.cpp

@@ -1,33 +1,9 @@
 // 负二进制数相加
-// https://leetcode.cn/problems/adding-two-negabinary-numbers
+// https://leetcode-cn.com/problems/adding-two-negabinary-numbers
 // INLINE  ../../images/array/adding_two_negabinary_numbers.jpeg
 // 参见官方题解
 #include <headers.hpp>
 
-// class Solution {
-// public:
-//   vector<int> addNegabinary(vector<int> &arr1, vector<int> &arr2) {
-//     int i = arr1.size() - 1, j = arr2.size() - 1;
-//     int carry = 0;
-//     vector<int> ans;
-//     while (i >= 0 || j >= 0 || carry) {
-//       int x = carry;
-//       if (i >= 0)
-//         x += arr1[i--];
-//       if (j >= 0)
-//         x += arr2[j--];
-
-//       ans.push_back((x + 2) % 2);
-//       carry = -(x / 2);
-//     }
-//     while (ans.size() > 1 && ans.back() == 0) {
-//       ans.pop_back();
-//     }
-//     reverse(ans.begin(), ans.end());
-//     return ans;
-//   }
-// };
-
 class Solution {
 public:
   vector<int> addNegabinary(vector<int> &arr1, vector<int> &arr2) {

src/array/average_value_of_even_numbers_that_are_divisible_by_three.cpp

@@ -7,16 +7,16 @@
 class Solution {
 public:
   int averageValue(vector<int> &nums) {
-    int sum = 0;
-    int count = 0;
-    for (auto num : nums) {
+    int sum = 0;  // 初始化数值总和为 0
+    int count = 0;  // 初始化符合条件的数值个数为 0
+    for (auto num : nums) {  // 遍历输入数组中的每一个数值
       // 只有两个条件都满足才加入
-      if (num % 2 == 0 && num % 3 == 0) {
-        sum += num;
-        count++;
+      if (num % 2 == 0 && num % 3 == 0) {  // 如果当前数值是偶数且能被 3 整除
+        sum += num;  // 将当前数值加入到数值总和中
+        count++;  // 将符合条件的数值个数加 1
       }
     }
-    // 如果没有找到任何满足条件的数，返回 0
+    // 如果没有找到任何满足条件的数，返回 0，否则返回平均值
     return count == 0 ? 0 : sum / count;
   }
 };

src/array/beautiful_arrangement_ii.cpp

@@ -8,7 +8,7 @@
 class Solution {
 public:
   vector<int> constructArray(int n, int k) {
-    int interval = k; // interval 为相邻元素的差值
+    int interval = k; // 相邻元素的差值
     vector<int> ans;
     ans.push_back(1); // 初始化第一个元素为 1
     for (int i = 1; i <= k; i++) {

src/array/best_time_to_buy_and_sell_stock.cpp

@@ -1,5 +1,5 @@
 // 买卖股票的最佳时机
-// https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/
+// https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/
 // INLINE  ../../images/array/best_time_to_buy_and_sell_stock.jpeg
 #include <headers.hpp>
 
@@ -14,7 +14,9 @@ class Solution {
 
     // 遍历价格数组，更新最大利润和最低价格
     for (int price : prices) {
+      // 更新最大利润，当前价格减去之前的最低价格
       maxProfit = max(maxProfit, price - minPrice);
+      // 更新最低价格，如果当前价格比之前的最低价格还低，则更新为当前价格
       minPrice = min(minPrice, price);
     }
 

src/array/check_distances_between_same_letters.cpp

@@ -5,18 +5,15 @@
 
 class Solution {
 public:
-  // distance 是一个整数数组，其中的元素表示每个字母之间的最大距离。
-  // 如果字符串 s 满足以下条件，则返回 true：
-  // 1. s 的长度为 n，distance 的长度为 m；
-  // 2. s[i] == s[j] 且 |i - j| < distance[s[i] - 'a'] 对于所有的 0 <= i < j < n
-  // 都成立。
   bool checkDistances(string s, vector<int> &distance) {
     int n = s.size();
     int m = distance.size();
     // last[i] 表示字符 i 最后出现的位置。
     vector<int> last(m, -1);
+    // 遍历字符串 s，更新 last 数组
     for (int i = 0; i < n; ++i) {
       int x = s[i] - 'a';
+      // 如果字符 x 已经出现过，检查距离是否符合要求
       if (last[x] != -1 && i - last[x] - 1 != distance[x]) {
         return false;
       }

src/array/cherry_pickup.cpp

@@ -18,34 +18,33 @@ class Solution {
     vector<vector<int>> f(
         n, vector<int>(n, INT_MIN)); // f 表示俩人摘到的樱桃个数之和的最大值
     f[0][0] = grid[0][0];
-    for (int k = 1; k < n * 2 - 1; ++k) // k为两人步数之和，x为向右走的步数，y为向下走的步数。
-                                        // x_1+y_1 = x_2+y_2 = k
-    {
-      for (int x1 = min(k, n - 1); x1 >= max(k - n + 1, 0); --x1) {
-        for (int x2 = min(k, n - 1); x2 >= x1; --x2) {
-          int y1 = k - x1, y2 = k - x2;
-          if (grid[x1][y1] == -1 || grid[x2][y2] == -1) {
-            f[x1][x2] = INT_MIN;
+    for (int k = 1; k < n * 2 - 1; ++k) { // k为两人步数之和，x为向右走的步数，y为向下走的步数。
+                                          // x_1+y_1 = x_2+y_2 = k
+      for (int x1 = min(k, n - 1); x1 >= max(k - n + 1, 0); --x1) { // 枚举第一个人走的位置
+        for (int x2 = min(k, n - 1); x2 >= x1; --x2) { // 枚举第二个人走的位置
+          int y1 = k - x1, y2 = k - x2; // 根据步数和位置，计算出两个人的纵坐标
+          if (grid[x1][y1] == -1 || grid[x2][y2] == -1) { // 如果当前格子是障碍物，则无法通过
+            f[x1][x2] = INT_MIN; // 将当前状态设为无穷小，表示无法达到
             continue;
           }
-          int res = f[x1][x2]; // 都往右
-          if (x1) {
-            res = max(res, f[x1 - 1][x2]); // 往下，往右
+          int res = f[x1][x2]; // 初始化最大值为当前状态
+          if (x1) { // 第一个人可以向下走
+            res = max(res, f[x1 - 1][x2]); // 更新状态，加上向下走的樱桃数
           }
-          if (x2) {
-            res = max(res, f[x1][x2 - 1]); // 往右，往下
+          if (x2) { // 第二个人可以向下走
+            res = max(res, f[x1][x2 - 1]); // 更新状态，加上向下走的樱桃数
           }
-          if (x1 && x2) {
-            res = max(res, f[x1 - 1][x2 - 1]); // 都往下
+          if (x1 && x2) { // 两个人都可以向下走
+            res = max(res, f[x1 - 1][x2 - 1]); // 更新状态，加上向下走的樱桃数
           }
-          res += grid[x1][y1];
+          res += grid[x1][y1]; // 加上当前格子的樱桃数
           if (x2 != x1) { // 避免重复摘同一个樱桃
-            res += grid[x2][y2];
+            res += grid[x2][y2]; // 加上第二个人当前格子的樱桃数
           }
-          f[x1][x2] = res;
+          f[x1][x2] = res; // 更新当前状态
         }
       }
     }
-    return max(f.back().back(), 0);
+    return max(f.back().back(), 0); // 返回俩人摘到的樱桃个数之和的最大值，注意要取0和最大值的较大值
   }
 };

src/array/count_vowel_strings_in_ranges.cpp

@@ -10,29 +10,29 @@ class Solution {
     // 计算元音字符串的前缀和。
     // 使用前缀和可以避免重复的字符串比较。
     int n = words.size();
-    int prefixSums[n + 1];
-    memset(prefixSums, 0, sizeof(prefixSums));
-    for (int i = 0; i < n; i++) {
-      int value = isVowelString(words[i]) ? 1 : 0;
-      prefixSums[i + 1] = prefixSums[i] + value;
+    int prefixSums[n + 1]; // 前缀和数组
+    memset(prefixSums, 0, sizeof(prefixSums)); // 初始化为0
+    for (int i = 0; i < n; i++) { // 遍历字符串数组
+      int value = isVowelString(words[i]) ? 1 : 0; // 判断是否为元音字符串
+      prefixSums[i + 1] = prefixSums[i] + value; // 计算前缀和
     }
 
     // 对于每个查询，返回前缀和的差值。
-    vector<int> ans(queries.size());
-    for (int i = 0; i < queries.size(); i++) {
-      int start = queries[i][0], end = queries[i][1];
-      ans[i] = prefixSums[end + 1] - prefixSums[start];
+    vector<int> ans(queries.size()); // 用于存储查询结果的数组
+    for (int i = 0; i < queries.size(); i++) { // 遍历查询数组
+      int start = queries[i][0], end = queries[i][1]; // 获取查询范围
+      ans[i] = prefixSums[end + 1] - prefixSums[start]; // 计算查询结果
     }
-    return ans;
+    return ans; // 返回查询结果数组
   }
 
   // 检查字符串是否为元音字符串。
   bool isVowelString(const string &word) {
-    return isVowelLetter(word[0]) && isVowelLetter(word.back());
+    return isVowelLetter(word[0]) && isVowelLetter(word.back()); // 判断首尾字母是否为元音字母
   }
 
   // 检查字母是否为元音字母。
   bool isVowelLetter(char c) {
-    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
+    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'; // 判断是否为元音字母
   }
 };

src/array/determine_if_two_events_have_conflict.cpp

@@ -6,7 +6,8 @@
 class Solution {
 public:
   bool haveConflict(vector<string> &event1, vector<string> &event2) {
-    // 事件1开始时间大于等于事件2的结束时间，或者事件1的结束时间小于等于事件2的开始时间，说明没有冲突
+    // 如果事件1的开始时间大于等于事件2的结束时间，或者事件1的结束时间小于等于事件2的开始时间，说明没有冲突
+    // 否则就存在冲突
     return !(event1[1] < event2[0] || event2[1] < event1[0]);
   }
 };

src/array/filling_bookcase_shelves.cpp

@@ -15,10 +15,13 @@ class Solution {
       int height = books[i - 1][1];
       // 首先考虑将第i本书单独放置在一层
       dp[i] = dp[i - 1] + height;
+      // 从i-1本书开始往前遍历，尝试将第j到第i本书一起放置在一层
       for (int j = i - 1; j > 0 && width + books[j - 1][0] <= shelfWidth; j--) {
-        // 将第j到第i本书一起放置在一层
+        // 更新该层的高度为最高的一本书的高度
         height = max(height, books[j - 1][1]);
+        // 更新该层的宽度为放置的所有书的总宽度
         width += books[j - 1][0];
+        // 更新dp[i]为更小的值
         dp[i] = min(dp[i], dp[j - 1] + height);
       }
     }

src/array/find_the_kth_smallest_sum_of_a_matrix_with_sorted_rows.cpp

@@ -1,5 +1,5 @@
 // 有序矩阵中的第 k 个最小数组和
-// https://leetcode.cn/problems/find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows
+// https://leetcode-cn.com/problems/find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows
 // INLINE
 // ../../images/array/find_the_kth_smallest_sum_of_a_matrix_with_sorted_rows.jpeg
 #include <headers.hpp>