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>

src/array/first_unique_character_in_a_string.cpp

@@ -1,23 +1,26 @@
 // 字符串中的第一个唯一字符
-// https://leetcode.cn/problems/first-unique-character-in-a-string/
+// https://leetcode-cn.com/problems/first-unique-character-in-a-string/
 // INLINE  ../../images/array/first_unique_character_in_a_string.jpeg
 #include <headers.hpp>
 
 class Solution {
 public:
   int firstUniqChar(string s) {
+    // 统计每个字符出现的频率
     unordered_map<int, int> frequency;
     for (auto ch : s) {
       frequency[ch]++;
     }
 
+    // 遍历字符串，找到第一个出现频率为1的字符
     for (int i = 0; i < s.length(); i++) {
       if (frequency[s[i]] == 1) {
-        // return s[i];
+        // 返回该字符的索引
         return i;
       }
     }
 
+    // 如果没有找到出现频率为1的字符，返回-1
     return -1;
   }
 };

src/array/flip_columns_for_maximum_number_of_equal_rows.cpp

@@ -6,21 +6,21 @@
 class Solution {
 public:
   int maxEqualRowsAfterFlips(vector<vector<int>> &matrix) {
-    int m = matrix.size(), n = matrix[0].size();
-    vector<int> flip(n);
-    int ans = 0;
-    for (int i = 0; i < m; i++) {
-      int cnt = 0;
-      for (int j = 0; j < n; j++) {
-        flip[j] = 1 - matrix[i][j];
+    int m = matrix.size(), n = matrix[0].size(); // 获取行列数
+    vector<int> flip(n); // 定义一个大小为n的vector，用来存储翻转后的列
+    int ans = 0; // 初始化答案
+    for (int i = 0; i < m; i++) { // 遍历每一行
+      int cnt = 0; // 初始化计数器
+      for (int j = 0; j < n; j++) { // 遍历每一列
+        flip[j] = 1 - matrix[i][j]; // 计算翻转后的列
       }
-      for (int k = 0; k < m; k++) {
-        if (matrix[k] == matrix[i] || matrix[k] == flip) {
-          cnt++;
+      for (int k = 0; k < m; k++) { // 再次遍历每一行
+        if (matrix[k] == matrix[i] || matrix[k] == flip) { // 如果该行和当前行相同，或者和当前行翻转后相同
+          cnt++; // 计数器加1
         }
       }
-      ans = max(ans, cnt);
+      ans = max(ans, cnt); // 更新答案
     }
-    return ans;
+    return ans; // 返回最终答案
   }
 };

src/array/length_of_longest_fibonacci_subsequence.cpp

@@ -2,40 +2,37 @@
 // https://leetcode.cn/problems/length-of-longest-fibonacci-subsequence
 // INLINE  ../../images/array/length_of_longest_fibonacci_subsequence.jpeg
 // 解题思路：见代码，常规暴力法优化查找时间。
+
 #include <headers.hpp>
 
-class Solution
-{
+class Solution {
 public:
-  int lenLongestFibSubseq(vector<int> &arr)
-  {
+  int lenLongestFibSubseq(vector<int> &arr) {
     int maxLen = 0;
     // 以空间换时间。因为序列已经排好序，因此把所有数值放到Map降低第三个数查找的时间复杂度。
-    unordered_set<int> set; // 如果用二分查找则第三个数是O(log n)，用Set则为O(1)。
+    unordered_set<int>
+        set; // 如果用二分查找则第三个数是O(log n)，用Set则为O(1)。
     int len = arr.size();
-    for (int i = 0; i < len; i++)
-    {
+    for (int i = 0; i < len; i++) {
       set.emplace(arr[i]);
     }
-    for (int i = 0; i < len - 2; i++)
-    {
-      for (int j = i + 1; j < len - 1; j++)
-      {
-        int first = arr[i];
-        int second = arr[j];
-        int third = first + second;
-        int currentLen = 2; // 按题目规定，长度至少为3，如果前两个数已经确定，则长度至少为2。
-        while (set.find(third) != set.end())
-        {
-          currentLen++;
-          first = second;
-          second = third;
-          third = first + second;
+    for (int i = 0; i < len - 2; i++) {
+      for (int j = i + 1; j < len - 1; j++) {
+        int first = arr[i];         // 第一个数
+        int second = arr[j];        // 第二个数
+        int third = first + second; // 第三个数
+        int currentLen =
+            2; // 按题目规定，长度至少为3，如果前两个数已经确定，则长度至少为2。
+        while (set.find(third) != set.end()) { // 第三个数在序列中
+          currentLen++;                        // 长度加1
+          first = second;                      // 第一个数变为第二个数
+          second = third;                      // 第二个数变为第三个数
+          third = first + second; // 第三个数变为新的第一个数加第二个数的和
         }
-        maxLen = max(currentLen, maxLen);
+        maxLen = max(currentLen, maxLen); // 更新最长长度
       }
     }
-
-    return maxLen >= 3 ? maxLen : 0; // 按题目规定，长度至少为3，如果一个不存在，返回0。
+    return maxLen >= 3 ? maxLen
+                       : 0; // 按题目规定，长度至少为3，如果一个不存在，返回0。
   }
 };