to: 添加注释

Author: yi-ge

src/array/adding_two_negabinary_numbers.cpp

@@ -1,9 +1,33 @@
 // 负二进制数相加
-// https://leetcode-cn.com/problems/adding-two-negabinary-numbers
+// https://leetcode.cn/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/beautiful_arrangement_ii.cpp

@@ -8,7 +8,7 @@
 class Solution {
 public:
   vector<int> constructArray(int n, int k) {
-    int interval = k; // 相邻元素的差值
+    int interval = k; // interval 为相邻元素的差值
     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.com/problems/best-time-to-buy-and-sell-stock/
+// https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/
 // INLINE  ../../images/array/best_time_to_buy_and_sell_stock.jpeg
 #include <headers.hpp>
 

src/array/check_distances_between_same_letters.cpp

@@ -5,6 +5,11 @@
 
 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();

src/array/find_the_kth_smallest_sum_of_a_matrix_with_sorted_rows.cpp

@@ -1,5 +1,5 @@
 // 有序矩阵中的第 k 个最小数组和
-// https://leetcode-cn.com/problems/find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows
+// https://leetcode.cn/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,5 +1,5 @@
 // 字符串中的第一个唯一字符
-// https://leetcode-cn.com/problems/first-unique-character-in-a-string/
+// https://leetcode.cn/problems/first-unique-character-in-a-string/
 // INLINE  ../../images/array/first_unique_character_in_a_string.jpeg
 #include <headers.hpp>
 

src/array/longest_arithmetic_subsequence.cpp

@@ -1,19 +1,21 @@
 // 最长等差数列
-// https://leetcode-cn/problems/longest-arithmetic-subsequence
+// https://leetcode.cn/problems/longest-arithmetic-subsequence
 // INLINE  ../../images/array/longest_arithmetic_subsequence.jpeg
 #include <headers.hpp>
 
 class Solution {
 public:
   int longestArithSeqLength(vector<int> &nums) {
-    int ans = 2; // 最小长度为2
+    int ans = 2;         // 最小长度为2
     int n = nums.size(); // 数组大小
-    vector<unordered_map<int, int>> dp(n); // 定义dp，dp[i][d]表示以i为结尾，差值为d的最长等差数列长度
-    for (int i = 0; i < n; i++) { // 枚举结尾
+    vector<unordered_map<int, int>> dp(
+        n); // 定义dp，dp[i][d]表示以i为结尾，差值为d的最长等差数列长度
+    for (int i = 0; i < n; i++) {       // 枚举结尾
       for (int j = i + 1; j < n; j++) { // 枚举倒数第二个数
-        int d = nums[j] - nums[i]; // 求差值
+        int d = nums[j] - nums[i];      // 求差值
         if (dp[i].count(d)) { // 如果存在以i为结尾，差值为d的等差数列
-          dp[j][d] = dp[i][d] + 1; // 那么以j为结尾，差值为d的等差数列长度为dp[i][d]+1
+          dp[j][d] =
+              dp[i][d] + 1; // 那么以j为结尾，差值为d的等差数列长度为dp[i][d]+1
         } else {
           dp[j][d] = 2; // 否则，以j为结尾，差值为d的等差数列长度为2
         }

src/array/mean_of_array_after_removing_some_elements.cpp

@@ -1,16 +1,16 @@
 // 删除某些元素后的数组均值
-// https://leetcode-cn.com/problems/mean-of-array-after-removing-some-elements/
+// https://leetcode.cn/problems/mean-of-array-after-removing-some-elements/
 // INLINE  ../../images/array/mean_of_array_after_removing_some_elements.jpeg
 #include <headers.hpp>
 #include <numeric>
 
 class Solution {
 public:
   double trimMean(vector<int> &arr) {
-    int len = arr.size(); // 数组长度
+    int len = arr.size();         // 数组长度
     sort(arr.begin(), arr.end()); // 对数组进行排序
-    double res =
-        accumulate(arr.begin() + len / 20, arr.begin() + 0.95 * len, 0); // 去掉前后各5%的元素后，求剩余元素的和
+    double res = accumulate(arr.begin() + len / 20, arr.begin() + 0.95 * len,
+                            0); // 去掉前后各5%的元素后，求剩余元素的和
     return res / (len * 0.9); // 求剩余元素的平均值
   }
 };

src/array/pascals_triangle.cpp

@@ -1,18 +1,23 @@
 // 杨辉三角
-// https://leetcode-cn.com/problems/pascals-triangle
+// https://leetcode.cn/problems/pascals-triangle
 // INLINE  ../../images/array/pascals_triangle.jpeg
 
 #include <headers.hpp>
 
 class Solution {
 public:
   vector<vector<int>> generate(int numRows) {
-    vector<vector<int>> ret(numRows); // 创建一个二维vector，其中第一维长度为numRows，第二维长度为i+1
+    vector<vector<int>> ret(
+        numRows); // 创建一个二维vector，其中第一维长度为numRows，第二维长度为i+1
     for (int i = 0; i < numRows; ++i) { // 循环numRows次，每次处理一行
-      ret[i].resize(i + 1); // 第i行的长度为i+1
+      ret[i].resize(i + 1);             // 第i行的长度为i+1
       ret[i][0] = ret[i][i] = 1; // 第i行的第一个和最后一个元素都是1
       for (int j = 1; j < i; ++j) { // 处理第i行的第1~i-1个元素
-        ret[i][j] = ret[i - 1][j] + ret[i - 1][j - 1]; // 第i行第j个元素等于第i-1行第j个元素和第i-1行第j-1个元素之和
+        ret[i][j] =
+            ret[i - 1][j] +
+            ret[i - 1]
+               [j -
+                1]; // 第i行第j个元素等于第i-1行第j个元素和第i-1行第j-1个元素之和
       }
     }
     return ret; // 返回二维vector

src/array/rank_transform_of_an_array.cpp

@@ -1,26 +1,22 @@
 // 数组序号转换
-// https://leetcode-cn/problems/rank-transform-of-an-array
+// https://leetcode.cn/problems/rank-transform-of-an-array
 // INLINE  ../../images/array/rank_transform_of_an_array.jpeg
 #include <headers.hpp>
 
-class Solution
-{
+class Solution {
 public:
-  vector<int> arrayRankTransform(vector<int> &arr)
-  {
-    vector<int> sArr = arr; // 复制原数组
+  vector<int> arrayRankTransform(vector<int> &arr) {
+    vector<int> sArr = arr;         // 复制原数组
     sort(sArr.begin(), sArr.end()); // 对复制数组进行排序
-    unordered_map<int, int> ranks; // 记录每个元素的排名
-    vector<int> ans(arr.size()); // 存储排名后的结果
-    for (auto &a : sArr)
-    {
+    unordered_map<int, int> ranks;  // 记录每个元素的排名
+    vector<int> ans(arr.size());    // 存储排名后的结果
+    for (auto &a : sArr) {
       if (!ranks.count(a)) // 如果该元素还未出现过
       {
         ranks[a] = ranks.size() + 1; // 给它一个排名
       }
     }
-    for (int i = 0; i < arr.size(); i++)
-    {
+    for (int i = 0; i < arr.size(); i++) {
       ans[i] = ranks[arr[i]]; // 获取原数组每个元素的排名
     }
     return ans; // 返回排名后的结果

src/array/special_array_with_x_elements_greater_than_or_equal_x.cpp

@@ -1,5 +1,5 @@
 // 特殊数组的特征值
-// https://leetcode-cn/problems/special-array-with-x-elements-greater-than-or-equal-x
+// https://leetcode.cn/problems/special-array-with-x-elements-greater-than-or-equal-x
 // INLINE
 // ../../images/array/special_array_with_x_elements_greater_than_or_equal_x.jpeg
 // 解题思路：本地画图模拟
@@ -11,9 +11,10 @@ class Solution {
     sort(nums.begin(), nums.end()); // 先将数组排序
     int n = nums.size();
     for (int i = 0; i < n; i++) { // 遍历数组
-      int res = n - i; // 计算特征值
-      if (nums[i] >= res && (i - 1 < 0 || nums[i - 1] < res)) { // 判断是否符合条件
-        return res; // 返回特征值
+      int res = n - i;            // 计算特征值
+      if (nums[i] >= res &&
+          (i - 1 < 0 || nums[i - 1] < res)) { // 判断是否符合条件
+        return res;                           // 返回特征值
       }
     }
     return -1; // 找不到符合条件的特征值，返回-1