typo

Author: WhythZ

_posts/2025-06-13-数组相关算法的浅浅刷题笔记.md

@@ -1224,60 +1224,60 @@ vector<vector<string>> groupAnagrams(vector<string>& strs)
     - 枚举数组中的每个数$x$作为起点，不断尝试匹配$x+n$是否存在，假设最长匹配到了$x+y$，那么以$x$为起点的最长连续序列长度即为$y+1$，不断枚举并更新答案即可
 
 ```cpp
-// bool findNum(vector<int>& nums, int target)
-// {
-//     for (int num : nums)
-//     {
-//         if (num == target)
-//             return true;
-//     }
-//     return false;
-// }
+bool findNum(vector<int>& nums, int target)
+{
+    for (int num : nums)
+    {
+        if (num == target)
+            return true;
+    }
+    return false;
+}
 
-// int longestConsecutive(vector<int>& nums)
-// {
-//     int maxSeq = 0;
-//     for (int num : nums)
-//     {
-//         int it = 1;
-//         int accum = 1;
-//         while (findNum(nums, num + it))
-//         {
-//             accum++;
-//             it++;
-//         }
-//         if (accum > maxSeq)
-//             maxSeq = accum;
-//     }
-//     return maxSeq;
-// }
+int longestConsecutive(vector<int>& nums)
+{
+    int maxSeq = 0;
+    for (int num : nums)
+    {
+        int it = 1;
+        int accum = 1;
+        while (findNum(nums, num + it))
+        {
+            accum++;
+            it++;
+        }
+        if (accum > maxSeq)
+            maxSeq = accum;
+    }
+    return maxSeq;
+}
 ```
 
 - 我们只需首先遍历一次将数放到哈希集合中，就可以优化每次搜索的复杂度了，但此时仍会存在极端测试用例卡超时
 
 ```cpp
-// int longestConsecutive(vector<int>& nums)
-// {
-//     unordered_set<int> ht;
-//     for(int num : nums)
-//         ht.insert(num);
+int longestConsecutive(vector<int>& nums)
+{
+    unordered_set<int> ht;
+    for(int num : nums)
+        ht.insert(num);
 
-//     int maxSeq = 0;
+    int maxSeq = 0;
 
-//     for (int num : nums)
-//     {
-//         int accum = 1;
-//         int it = 1;
-//         while (ht.count(num + it))
-//         {
-//             accum++;
-//             it++;
-//         }
-//         if (accum > maxSeq)
-//             maxSeq = accum;
-//     }
-//     return maxSeq;
-// }
+    for (int num : nums)
+    {
+        int accum = 1;
+        int it = 1;
+        while (ht.count(num + it))
+        {
+            accum++;
+            it++;
+        }
+        if (accum > maxSeq)
+            maxSeq = accum;
+    }
+    return maxSeq;
+}
 ```
 
 - 我们思考继续优化，我们需要遍历每个元素查找其向上的最大连续长度，当我们遍历到每个元素的时候，可以先检测其加上当前的最大长度所得结果值是否存在于数组中，若无则跳过该数，这就省去了对那些对最大长度不可能有贡献的元素的迭代
@@ -1286,67 +1286,67 @@ vector<vector<string>> groupAnagrams(vector<string>& strs)
 
 ```cpp
 //第一个解法
-// int longestConsecutive(vector<int>& nums)
-// {
-//     if (nums.size() == 0)
-//         return 0;
-//
-//     unordered_set<int> ht;
-//     for(int num : nums)
-//         ht.insert(num);
-//
-//     int maxSeq = 1;
-//
-//     for (int num : nums)
-//     {
-//         // int accum = 1;
-//         int accum = maxSeq;
-//
-//         // int it = 1;
-//         int it = maxSeq;
-//
-//         while (ht.count(num + it))
-//         {
-//             accum++;
-//             it++;
-//         }
-//         if (accum > maxSeq)
-//             maxSeq = accum;
-//     }
-//     return maxSeq;
-// }
+int longestConsecutive(vector<int>& nums)
+{
+    if (nums.size() == 0)
+        return 0;
+
+    unordered_set<int> ht;
+    for(int num : nums)
+        ht.insert(num);
+
+    int maxSeq = 1;
+
+    for (int num : nums)
+    {
+        // int accum = 1;
+        int accum = maxSeq;
+
+        // int it = 1;
+        int it = maxSeq;
+
+        while (ht.count(num + it))
+        {
+            accum++;
+            it++;
+        }
+        if (accum > maxSeq)
+            maxSeq = accum;
+    }
+    return maxSeq;
+}
 
 //第二个解法
-// int longestConsecutive(vector<int>& nums)
-// {
-//     if (nums.size() == 0)
-//         return 0;
-//
-//     unordered_set<int> ht;
-//     for(int num : nums)
-//         ht.insert(num);
-//
-//     int maxSeq = 1;
-//
-//     for (int num : nums)
-//     {
-//         int accum = 1;
-//         int it = 1;
-//
-//         //检测当前元素num是否具有更新maxSeq的潜力
-//         if (ht.count(num + maxSeq))
-//         {
-//             while (ht.count(num + it))
-//             {
-//                 accum++;
-//                 it++;
-//             }
-//             if (accum > maxSeq)
-//                 maxSeq = accum;
-//         }
-//     }
-//     return maxSeq;
-// }
+int longestConsecutive(vector<int>& nums)
+{
+    if (nums.size() == 0)
+        return 0;
+
+    unordered_set<int> ht;
+    for(int num : nums)
+        ht.insert(num);
+
+    int maxSeq = 1;
+
+    for (int num : nums)
+    {
+        int accum = 1;
+        int it = 1;
+
+        //检测当前元素num是否具有更新maxSeq的潜力
+        if (ht.count(num + maxSeq))
+        {
+            while (ht.count(num + it))
+            {
+                accum++;
+                it++;
+            }
+            if (accum > maxSeq)
+                maxSeq = accum;
+        }
+    }
+    return maxSeq;
+}
 ```
 
 - 但即便如此还是会超时，我们再次思考优化方法，我们其实可以对有前缀元素的元素直接跳过，每次只从所有连续元素的最开头的元素开始向后遍历，只需要添加一个判断条件即可