vault backup: 2026-06-05 18:15:42

leetcode/note/medium/128_longest_consecutive_sequence.md

@@ -6,8 +6,75 @@ tags:
   - array
   - hash-table
   - union-find
-status: unsolve
-date_solved: 2026-05-26
+status: Solved
+date_solved: 2026-06-05
 leetcode_url: https://leetcode.com/problems/longest-consecutive-sequence/
 review_needed: false
 ---
+
+# 128. Longest Consecutive Sequence
+
+> [!info] **Problem Link**: [LeetCode - Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence/)
+
+## 📝 Problem Description
+
+Given an unsorted array of integers `nums`, return *the length of the longest consecutive elements sequence.*
+
+You must write an algorithm that runs in `O(n)` time.
+
+---
+
+### 📥 Example 1
+> **Input:** `nums = [100,4,200,1,3,2]`
+> **Output:** `4`
+> **Explanation:** The longest consecutive elements sequence is `[1, 2, 3, 4]`. Therefore its length is 4.
+
+### 📥 Example 2
+> **Input:** `nums = [0,3,7,2,5,8,4,6,0,1]`
+> **Output:** `9`
+
+---
+
+## 💡 Approaches & Explanations
+
+### Approach 1: Hash Set — *Optimal*
+To achieve $O(n)$ time complexity, we use a hash set for $O(1)$ lookups. The core idea is to identify the start of each possible sequence. A number `n` is the start of a sequence if `n - 1` is not present in the set.
+
+1. Insert all numbers from `nums` into a hash set.
+2. Iterate through each number `n` in the set:
+   - Check if `n - 1` is in the set.
+   - If `n - 1` is NOT in the set, `n` is the start of a sequence.
+   - From `n`, keep checking for `n + 1`, `n + 2`, ... and increment the current sequence length.
+   - Update the maximum length found so far.
+
+#### 📊 Complexity Analysis
+- **Time Complexity:** $O(N)$ where $N$ is the number of elements. Although there is a nested while loop, each element is visited at most twice (once by the main loop and once by the while loop), resulting in linear time.
+- **Space Complexity:** $O(N)$ to store the elements in the hash set.
+
+---
+
+## 💻 Code Implementations
+
+### Python3
+```python
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        num_set = set(nums)
+        longest = 0
+        
+        for n in num_set:
+            # Check if n is the start of a sequence
+            if (n - 1) not in num_set:
+                length = 1
+                while (n + length) in num_set:
+                    length += 1
+                longest = max(length, longest)
+                
+        return longest
+```
+
+---
+
+## 🧠 Key Takeaways & Lessons
+- **Identifying Sequence Starts:** By checking for the absence of `n - 1`, we ensure that we only start counting from the beginning of a sequence, avoiding redundant work.
+- **Hash Set for Efficiency:** Trading space for time by using a Hash Set allows us to reduce what would be an $O(n^2)$ or $O(n \log n)$ problem into $O(n)$.