cultivation_db.yaml

# =============================================================================
# LeetCode Hero - Cultivation Progress Database
# =============================================================================
# This database tracks your mastery level and progress on LeetCode problems
# for technical interview preparation, particularly focused on Google-style
# algorithmic challenges.
#
# STATUS DEFINITIONS:
# -------------------
# L1_FORGOT    (忘) - Problem completely forgotten, requires re-learning from scratch
# L2_STRUGGLE  (解) - Can solve but with difficulty, not interview-ready yet
# L3_MASTERED  (定) - Can solve within 20 minutes, bug-free, handling all edge cases
#
# FIELD DESCRIPTIONS:
# -------------------
# id:                  LeetCode problem number
# title:               Official problem title from LeetCode
# link:                Relative path to your solution folder
# leetcode-difficulty: Official difficulty (easy/medium/hard)
# topics:              Algorithm/data structure tags for categorization
# status:              Your current mastery level (L1_FORGOT/L2_STRUGGLE/L3_MASTERED)
# refinement_focus:    Specific areas to improve or key insights to remember
#
# TOPIC TAGS:
# -----------
# Common tags include: hashtable, hashset, array, linked-list, stack, queue,
# binary-search, two-pointer, sliding-window, dp, backtracking, graph, tree,
# sorting, string, math, greedy, neetcode150
#
# ENTRY TEMPLATE:
# ---------------
#  - id:
#    title: ""
#    link: "./"
#    leetcode-difficulty:
#    topics:
#    status:
#    refinement_focus: ""
#
# =============================================================================

problems:
  - id: 1
    title: "Two Sum"
    link: "./problems/001_two_sum/"
    leetcode-difficulty: easy
    topics: [hashtable, array, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Use hashmap
      [2025-12-12]: I use sorted with pair, and two pointer
      [2026-04-03]: 100%.

  - id: 2
    title: "Add Two Numbers"
    link: "./problems/002_add_two_numbers/"
    leetcode-difficulty: medium
    topics: [linked-list, indirect-pointer, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Indirect-pointer and sum/carry handling
      [2025-12-12]: Sum/carry is correctly handled, but indirect pointer usage is incorrect. The resultHead and indirect-pointer declarations are poorly structured. Also, (*indirect) = new ListNode(val); is unclear. I incorrectly wrote indirect = &(new ListNode());
      [2026-03-27]: almost correct. &(new ListNode()) still happened

  - id: 3
    title: "Longest Substring Without Repeating Characters"
    link: "./problems/003_longest_substring_without_repeating_characters/"
    leetcode-difficulty: medium
    topics: [hashtable, sliding-window, string, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: 通常這種題目 While 的使用是關鍵
      [2025-12-12]: re-learn using std::vector<int> last_seen(128, -1)
      [2026-04-01]: 90% 10min. Structure correct. Wrong using `c - 'a'`, minus a is not needed. Also didn't come-up with the DP solution.
      [2026-04-02]: 30% 10min. Fatal condition error in if.
      [2026-04-03]: 70%. DP, Problem reading issue last_seen(128) not 26.

  - id: 5
    title: "Longest Palindromic Substring"
    link: "./problems/005_longest_palindromic_substring/"
    leetcode-difficulty: medium
    topics: [1d-dp, iteration, dp, manachers-algorithm, string, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Expand, DP, or Manacher's algorithm

  - id: 6
    title: "Zigzag Conversion"
    link: "./problems/006_zigzag_conversion/"
    leetcode-difficulty: medium
    topics: [vector, string]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Updown traverse and push to vector

  - id: 7
    title: "Reverse Integer"
    link: "./problems/007_reverse_integer/"
    leetcode-difficulty: medium
    topics: [bitops, integer, signed, boundary, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: The key is boundary + minus

  - id: 8
    title: "String to Integer"
    link: "./problems/008_string_to_integer/"
    leetcode-difficulty: medium
    topics: [parsing, stoi, boundary, signed, overflow]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: boundary + minus

  - id: 9
    title: "Palindrome Number"
    link: "./problems/009_palindrome_number/"
    leetcode-difficulty: easy
    topics: [iteration]
    status: L3_MASTERED
    refinement_focus: |
      [2026-01-06]: std::to_string while
      [2026-01-06]: Count: 2

  - id: 11
    title: "Container With Most Water"
    link: "./problems/011_container_with_most_water/"
    leetcode-difficulty: medium
    topics: [two-pointer, array, greedy, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: find the smallest of the two sides, and move the pointer
      [2025-12-12]: one-shot

  - id: 12
    title: "Integer to Roman"
    link: "./problems/012_integer_to_roman/"
    leetcode-difficulty: medium
    topics: [array]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Transform roman to (value, string) pair and decode greedy

  - id: 13
    title: "Roman to Integer"
    link: "./problems/013_roman_to_integer/"
    leetcode-difficulty: easy
    topics: [array]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-01-07]: Need to peek next, to know current is + or -

  - id: 14
    title: "Longest Common Prefix"
    link: "./problems/014_longest_common_prefix/"
    leetcode-difficulty: easy
    topics: [array]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: The clean solution is to take the first string as golden
      [2025-12-12]: misplaced inner and outer for-loop
      [2026-04-11]: 100% 4min. PASSED BUT NO HIRE. bound issue.
      [2026-04-12]: 100% 7min. Not passed first time. `s.substr(start, len)`

  - id: 15
    title: "3 Sum"
    link: "./problems/015_3sum/"
    leetcode-difficulty: medium
    topics: [two-pointer, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Duplicates handling is tricky

  - id: 16
    title: "3 Sum Closest"
    link: "./problems/016_3sum_closest/"
    leetcode-difficulty: medium
    topics: [two-pointer, array, sorting]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Same as 015_3Sum, but need to track closest value

  - id: 17
    title: "Letter Combinations of a Phone Number"
    link: "./problems/017_letter_combinations_of_a_phone_number/"
    leetcode-difficulty: medium
    topics: [hashtable, backtracking, string, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Write a good helper pure function

  - id: 18
    title: "4 Sum"
    link: "./problems/018_4sum/"
    leetcode-difficulty: medium
    topics: [k-sum, two-pointer, array, sorting]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: generalizing k-sum function

  - id: 19
    title: "Remove Nth Node From End of List"
    link: "./problems/019_remove_nth_node_from_end_of_list/"
    leetcode-difficulty: medium
    topics: [fast-and-slow-pointer, linked-list, indirect-pointer, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Indirect-pointer and fast/slow pointer
      [2026-04-13]: 30%. Removal node assiged wrong, didn't delete memory.

  - id: 20
    title: "Valid Parentheses"
    link: "./problems/020_valid_parentheses/"
    leetcode-difficulty: easy
    topics: [stack, string, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: I know the stack solution, but I cannot execute it fluently and elegantly
      [2026-04-06]: 90%. Typo. More to improve: use switch-stmt.
      [2026-04-07]: 100% 10min.
      [2026-04-14]: 100% 5min. Return value and pop() not set correctly in first shot.

  - id: 21
    title: "Merge Two Sorted Lists"
    link: "./problems/021_merge_two_sorted_lists/"
    leetcode-difficulty: easy
    topics: [linked-list, indirect-pointer, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2026-03-25]: Normal dummy node is okay. But I forget indirect-pointer usage. Always use `ListNode *result;` then `ListNode **indirect = &result;`
      [2026-03-25]: One-shot using indirect pointer. But a little uncertain when doing it in a sprint.
      [2026-03-26]: One-shot.

  - id: 22
    title: "Generate Parentheses"
    link: "./problems/022_generate_parentheses/"
    leetcode-difficulty: medium
    topics: [stack, backtracking, string, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: I know the core idea, implement has some flaws.
      [2026-04-06]: 0%. Practiced.
      [2026-04-07]: 100% 7min.

  - id: 23
    title: "Merge k Sorted Lists"
    link: "./problems/023_merge_k_sorted_lists/"
    leetcode-difficulty: hard
    topics: [linked-list, heap, priority-queue, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Not really hard, but I need to review how to initialize a priority queue and also prevent adding nullptr to the queue. There are also one way to use merge sort to merge k lists.
      [2026-04-01] 60% 13min. Structure correct. Should save ListNode* not index. Should not use default construtor for pq or nullptr will sneak in.
      [2026-04-02] 50% 10min. Maybe not very focused or in good statue. `cmp` forget to `left->val`, forget adding *. A lot of minor mistakes occurs.
      [2026-04-03] 100% 8min.

  - id: 24
    title: "Swap Nodes in Pairs"
    link: "./problems/024_swap_nodes_in_pairs/"
    leetcode-difficulty: medium
    topics: [linked-list, indirect-pointer, recursion]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-03-25]: While loop or helper recursion
      [2026-03-26]: not fully correct

  - id: 25
    title: "Reverse Nodes in k-Group"
    link: "./problems/025_reverse_nodes_in_k-group/"
    leetcode-difficulty: hard
    topics: [linked-list, indirect-pointer, recursion, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |

  - id: 26
    title: "Remove Duplicates from Sorted Array"
    link: "./problems/026_remove_duplicates_from_sorted_array/"
    leetcode-difficulty: easy
    topics: [array, two-pointer]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-01-26]: Initially attempted using erase() backwards (influenced by LISP/Racket), but the two-pointer approach is the correct O(N) solution.

  - id: 27
    title: "Remove Element"
    link: "./problems/027_remove_element/"
    leetcode-difficulty: easy
    topics: [array, two-pointer]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Simple, but made mistakes in return value and casting. Also learned std::remove()

  - id: 28
    title: "Implement strStr()"
    link: "./problems/028_find_the_index_of_the_first_occurrence_in_a_string/"
    leetcode-difficulty: easy
    topics: [string, kmp-algorithm]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: std::string::find() and verbose explain KMP algorithm

  - id: 33
    title: "Search in Rotated Sorted Array"
    link: "./problems/033_search_in_rotated_sorted_array/"
    leetcode-difficulty: medium
    topics: [binary-search, array, sorting, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]:
          (1) we should check whether is left sorted or right sorted (monotonic)
          (2) we should be very careful about the boundary conditions if there are only 2 elements left
      [2026-04-06]: 30%. `while (l <= r)` + `<=`.
      [2026-04-07]: 100% 6min.

  - id: 34
    title: "Find First and Last Position of Element in Sorted Array"
    link: "./problems/034_find_first_and_last_position_of_element_in_sorted_array/"
    leetcode-difficulty: medium
    topics: [binary-search, array, sorting]
    status: L2_STRUGGLE
    refinement_focus:
      [2025-12-12]: lower_bound and upper_bound
      [2026-04-04]: 95% 10min. Using std algorithm. Learned std::distance().

  - id: 35
    title: "Search Insert Position"
    link: "./problems/035_search_insert_position/"
    leetcode-difficulty: easy
    topics: [binary-search, array, sorting]
    status: L3_MASTERED
    refinement_focus:
      [2025-12-12]: Basic lower_bound
      [2026-04-04]: 100%.

  - id: 36
    title: "Valid Sudoku"
    link: "./problems/036_valid_sudoku/"
    leetcode-difficulty: medium
    topics: [array, hashset, matrix, simulation, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: HashSet

  - id: 42
    title: "Trapping Rain Water"
    link: "./problems/042_trapping_rain_water/"
    leetcode-difficulty: hard
    topics: [two-pointer, monotonic-stack, array, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: next-greater-element or two-pointer

  - id: 48
    title: "Rotate Image"
    link: "./problems/048_rotate_image/"
    leetcode-difficulty: medium
    topics: [math-and-geometry, matrix, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Transpose + Reverse

  - id: 49
    title: "Group Anagrams"
    link: "./problems/049_group_anagrams/"
    leetcode-difficulty: medium
    topics: [hashtable, string, sorting, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Sorting
      [2026-04-14]: Don't think of hashmap.

  - id: 53
    title: "Maximum Subarray"
    link: "./problems/053_maximum_subarray/"
    leetcode-difficulty: medium
    topics: [greedy, dp, array, neetcode150, kadane-algorithm]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: One shot Kadane's algorithm after praticing LeetCode #152.
      [2026-04-11]: Re-learned.
      [2026-04-14]: 100% 5min.

  - id: 56
    title: "Merge Intervals"
    link: "./problems/056_merge_intervals/"
    leetcode-difficulty: medium
    topics: [intervals, array, sorting, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Sorting + Iterate and Merge
      [2026-04-12]: 100%. Slightly ugly with the syntax and didn't use std::move.

  - id: 57
    title: "Insert Interval"
    link: "./problems/057_insert_interval/"
    leetcode-difficulty: medium
    topics: [intervals, array, sorting, neetcode150]
    status: L2_STRUGGLE
    refinement_focus:
      [2026-01-19]: Copy before insertion, merge overlaps, then append the rest
      [2026-04-29]: 60%. Using `sel` and `inserted` to handle next insert/merge. Finally correct, but there are really a lot of edge cases to be aware.

  - id: 61
    title: "Rotate List"
    link: "./problems/061_rotate_list/"
    leetcode-difficulty: medium
    topics: [linked-list, two-pointer, indirect-pointer]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Make the list circular first. There are optimizations like if k == length, do nothing

  - id: 66
    title: "Plus One"
    link: "./problems/066_plus_one/"
    leetcode-difficulty: easy
    topics: [array, math-and-geometry, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: (Pass 15) But the simplest way is to use vector::insert to insert 1 at the beginning if there is a carry at the end.

  - id: 70
    title: "Climbing Stairs"
    link: "./problems/070_climbing_stairs/"
    leetcode-difficulty: easy
    topics: [1d-dp, dp, math-and-geometry, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Fibonacci, bottom-up DP, top-down DP, or even math
      [2026-04-11]: 100% 4min.

  - id: 74
    title: "Search a 2D Matrix"
    link: "./problems/074_search_a_2d_matrix/"
    leetcode-difficulty: medium
    topics: [binary-search, matrix, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-04]: 90%. GetColRow should be {index / num_cols, index % num_cols}.

  - id: 76
    title: "Minimum Window Substring"
    link: "./problems/076_minimum_window_substring/"
    leetcode-difficulty: hard
    topics: [hashtable, sliding-window, string, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Brute force but got TLE. Then used sliding window. I don't know when to use sliding window or brute force. The note is written in the #3719 solution.
      [2025-12-12]: I can implement the solution using a map counter, but this is not very elegant. The best solution is to use a vector as a dictionary, plus using a total count variable to track all characters in t. Expand and shrink the window based on the total count.
      [2026-04-01]: 95% 21min. Forget incr left and naming issue.
      [2026-04-02]: 95% 15min. `left - right + 1`.

  - id: 80
    title: "Remove Duplicates from Sorted Array II"
    link: "./problems/080_remove_duplicates_from_sorted_array_ii/"
    leetcode-difficulty: medium
    topics: [array, two-pointer]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-01-26]: passed with duplicate count, but there are better ways to do it.

  - id: 81
    title: "Search in Rotated Sorted Array II"
    link: "./problems/081_search_in_rotated_sorted_array_ii/"
    leetcode-difficulty: medium
    topics: [binary-search, array]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-07]: 0%. Learning.
          case compare (nums !! mid) (nums !! right) of
            LT -> -- right sorted
            GT -> -- left sorted
            EQ -> -- right--
      [2026-04-11]: 100 5min.

  - id: 83
    title: "Remove Duplicates from Sorted List"
    link: "./problems/083_remove_duplicates_from_sorted_list/"
    leetcode-difficulty: easy
    topics: [linked-list, two-pointer]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-15]: 80% 10min. Missing `continue` cause dereferce nullptr.

  - id: 84
    title: "Largest Rectangle in Histogram"
    link: "./problems/084_largest_rectangle_in_histogram/"
    leetcode-difficulty: hard
    topics: [stack, array, monotonic-stack, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: (Fail 15 + 45) The key is to find the nearest smaller element on both sides for each bar. Use monotonic stack to achieve O(n) time complexity.
      [2026-04-10]: 0%. Relearned.
      [2026-04-11]: 30%. Wrong while using 2 pass.

  - id: 91
    title: "Decode Ways"
    link: "./problems/091_decode_ways/"
    leetcode-difficulty: medium
    topics: [1d-dp, dp, string, backtracking, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: dp[i] means ways to decode s[0..i-1]. Also, we need to handle 1 digit and 2 digit separately

  - id: 92
    title: "Reverse Linked List II"
    link: "./problems/092_reverse_linked_list_ii/"
    leetcode-difficulty: medium
    topics: [linked-list]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Use dummy node or indirect pointer!

  - id: 94
    title: "Binary Tree Inorder Traversal"
    link: "./problems/094_binary_tree_inorder_traversal/"
    leetcode-difficulty: easy
    topics: [tree, dfs]
    status: L3_MASTERED
    refinement_focus:
      [2026-03-26]: Just finish after #230 so it is a one shot. But I still recommend to practice more.
      [2026-03-26]: one-shot using recursion

  - id: 96
    title: "Unique Binary Search Trees"
    link: "./problems/096_unique_binary_search_trees/"
    leetcode-difficulty: medium
    topics: [dp, math-and-geometry]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: dp[n] means number of unique BST that can be built with n nodes. dp[n] = sum of dp[i-1]*dp[n-i] for i in [1..n]. Catalan number

  - id: 98
    title: "Validate Binary Search Tree"
    link: "./problems/098_validate_binary_search_tree/"
    leetcode-difficulty: medium
    topics: [tree, dfs, binary-tree, neetcode150]
    status: L1_FORGOT
    refinement_focus: |
      [2025-12-12]: I only validate all nodes (node->val vs node->left->val) recursively. But actually we need to pass down the valid range (min, max) from root to leaf.

  - id: 100
    title: "Same Tree"
    link: "./problems/100_same_tree/"
    leetcode-difficulty: easy
    topics: [tree, dfs, bfs, neetcode150]
    status: L3_MASTERED
    refinement_focus:
      [2026-03-26]: One-shot.
      [2026-03-26]: Almost. Not checking the null pointer.

  - id: 101
    title: "Symmetric Tree"
    link: "./problems/101_symmetric_tree/"
    leetcode-difficulty: easy
    topics: [tree, dfs]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-03-26]: Almost. Arm's length Recursion (bad)

  - id: 102
    title: "Binary Tree Level Order Traversal"
    link: "./problems/102_binary_tree_level_order_traversal/"
    leetcode-difficulty: medium
    topics: [tree, traversal, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Use nullptr in a queue to mark level end. But I forget to check if the current queue is empty which means we are done. So it causes infinite loop.
      [2026-04-02]: 100% 10min.

  - id: 104
    title: "Maximum Depth of Binary Tree"
    link: "./problems/104_maximum_depth_of_binary_tree/"
    leetcode-difficulty: easy
    topics: [tree, dfs, bfs, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]:
      [2026-03-27]: one-shot.
      [2026-04-15]: 100% 2min.

  - id: 105
    title: "Construct Binary Tree from Preorder and Inorder Traversal"
    link: "./problems/105_construct_binary_tree_from_preorder_and_inorder_traversal/"
    leetcode-difficulty: medium
    topics: [tree, dfs, recursion, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: I know the idea, but I cannot implement it fluently. The key is to correctly manage the indices of preorder and inorder arrays. Forgot to check if the current subtree is empty (preStart > preEnd || inStart > inEnd)

  - id: 110
    title: "Balanced Binary Tree"
    link: "./problems/110_balanced_binary_tree/"
    leetcode-difficulty: easy
    topics: [tree, dfs, bfs, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Reviewed the definition of balanced binary tree. Implementation is smooth, but I forgot to (add 1) when calculating height.

  - id: 111
    title: "Minimum Depth of Binary Tree"
    link: "./problems/111_minimum_depth_of_binary_tree/"
    leetcode-difficulty: easy
    topics: [tree, bfs, dfs]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-15]: 100% 10min. Using DFS. The optimal is BFS, and I placed wrong the swap(curr_level, next_level), should be in end of for-loop.

  - id: 112
    title: "Path Sum"
    link: "./problems/112_path_sum/"
    leetcode-difficulty: easy
    topics: [tree, dfs]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-03-26]: Check only at leaf, not nullptr.
      [2026-04-17]: Passed. Noted that "leaf" means check "if (curr && !curr->left && !curr->right)"

  - id: 124
    title: "Binary Tree Maximum Path Sum"
    link: "./problems/124_binary_tree_maximum_path_sum/"
    leetcode-difficulty: hard
    topics: [tree, dfs, binary-tree, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-01-13]: I have a clear understanding of the code structure, i.e., need a helper function that returns two values as an accumulator. There are two parts that I did not handle correctly. First, if there is only one negative value node, my base case will cause the max path to be 0. So the base case should return INT_MIN. Second, if a node has one negative child path and one positive child path, we need to discard the negative one, i.e., use std::max(0, lPathToLeaf). In sum, this needs more practice.
      [2026-01-13]: basically correct, but I need to be more careful about the base case. We should return {INT_MIN, 0} instead of {0, 0}
      [2026-04-21]: Didn't apply Kadane-Algorithm in root, left, right. So value is wrong.

  - id: 125
    title: "Valid Palindrome"
    link: "./problems/125_valid_palindrome/"
    leetcode-difficulty: easy
    topics: [two-pointer, string, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: isalnum() and tolower()
      [2026-04-03]: 50%. Not reading problem carefully & didn't add correct `l < r` check in inner while loop.
      [2026-04-04]: 80%. The error is init right = 0, left = s.size() - 1. Very stupid.
      [2026-04-05]: 55%. s[left] & ++left, --right.
      [2026-04-06]: 100%. Good! `std::tolower(static_cast<unsigned char>(c))`

  - id: 128
    title: "Longest Consecutive Sequence"
    link: "./problems/128_longest_consecutive_sequence/"
    leetcode-difficulty: medium
    topics: [hashset, array, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: sort is O(n log n), use HashSet to achieve O(n). Check only sequence starters
      [2026-04-12]: 30%. I used a hashmap, but will back to O(n^2) if the sequence is not friendly.

  - id: 130
    title: "Surrounded Regions"
    link: "./problems/130_surrounded_regions/"
    leetcode-difficulty: medium
    topics: [graph, dfs, array, matrix, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: one-shot.
      [2026-04-06]: 100% 10min.

  - id: 136
    title: "Single Number"
    link: "./problems/136_single_number/"
    leetcode-difficulty: easy
    topics: [bitops, array, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2026-03-24]: XOR

  - id: 137
    title: "Single Number II"
    link: "./problems/137_single_number_ii/"
    leetcode-difficulty: medium
    topics: [bitops, array]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: two solutions. FSM (best) and bit count modulo 3 (also good)
      [2026-03-29]: FSM don't understand. bit count sum not inited to zero.

  - id: 138
    title: "Copy List with Random Pointer"
    link: "./problems/138_copy_list_with_random_pointer/"
    leetcode-difficulty: medium
    topics: [linked-list, hashtable, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: One-shot with HashMap.
      [2025-12-12]: Did not even comprehend the problem correctly and only implemented basic deep copy.

  - id: 139
    title: "Word Break"
    link: "./problems/139_word_break/"
    leetcode-difficulty: medium
    topics: [1d-dp, dp, string, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Not absolutely sure I can get this right during interview, but I know the idea. dp[i] means s[i..end] can be segmented. Need a helper function isPrefix and a recursive function with memo

  - id: 141
    title: "Linked List Cycle"
    link: "./problems/141_linked_list_cycle/"
    leetcode-difficulty: easy
    topics: [linked-list, two-pointer, fast-and-slow-pointer, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2026-03-25]: I know the fast/slow pointer idea, but I cannot implement it fluently. The key is to check if fast and fast->next are nullptr directly in the while loop condition.
      [2026-03-25]: One-shot
      [2026-06-12]: Should check if after moving pointers, or it will be always true.

  - id: 143
    title: "Reorder List"
    link: "./problems/143_reorder_list/"
    leetcode-difficulty: medium
    topics:
      [linked-list, two-pointer, fast-and-slow-pointer, reverse, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-03-25]: I know the big picture. But failed at finding the mid node. I used `while (fast && fast->next)` which makes slow point to the second middle node in even-length list. So when merging, the first half is longer than the second half by one node, which causes problem.
      [2026-03-25]: Fuck-up (1) middle point. (2) merging next missing because set to nullptr. (2) Not checking the input condition.

  - id: 144
    title: "Binary Tree Preorder Traversal"
    link: "./problems/144_binary_tree_preorder_traversal/"
    leetcode-difficulty: easy
    topics: [tree, dfs]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-03-26]: Easier than inorder or Postorder iterative solution. But I still have problems with the structure of while loop. I need to practice more.

  - id: 145
    title: "Binary Tree Postorder Traversal"
    link: "./problems/145_binary_tree_postorder_traversal/"
    leetcode-difficulty: easy
    topics: [tree, dfs]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-03-26]: This is definitely hard if you want to use iterative solution but you didn't come up the `std::reverse` trick.
      [2026-03-26]: I use lambda for helper

  - id: 146
    title: "LRU Cache"
    link: "./problems/146_lru_cache/"
    leetcode-difficulty: medium
    topics: [design, linked-list, hashtable, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-01-15]: Always practice. Use std::list + std::unordered_map. please understand why use list
      [2026-02-08]: failed the second time, the reason is `iterator usage`, `splice` and reusing the last node.
      [2026-02-08]: failed.
      [2026-04-28]: Super hard to write vector version. The problem is detach funtion is hard to take care of prev or next is -1.
      [2026-04-29]: 95% 15min. Forgot to add back to map after splice.

  - id: 150
    title: "Evaluate Reverse Polish Notation"
    link: "./problems/150_evaluate_reverse_polish_notation/"
    leetcode-difficulty: medium
    topics: [stack, array, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Edge case are tricky, but the idea is straightforward. Always think when the input is invalid

  - id: 152
    title: "Maximum Product Subarray"
    link: "./problems/152_maximum_product_subarray/"
    leetcode-difficulty: medium
    topics: [1d-dp, dp, array, neetcode150, kadane-algorithm]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: The dp logic is not straightforward. The key is to remember three conditions: positive, negative, zero. Using DP to find max positive and min negative
      [2025-12-12]: The dp logic is smooth. The problem is the initial value of globalMax, localMax, and localMin, I didn't init it to nums[0] in the first place can cause overflow. After fixing, I use ranged based for, so index 0 is calculated twice which is not acceptable.
      [2026-04-11]: 100% 12min.

  - id: 153
    title: "Find Minimum in Rotated Sorted Array"
    link: "./problems/153_find_minimum_in_rotated_sorted_array/"
    leetcode-difficulty: medium
    topics: [binary-search, array, sorting, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Used `while (left <= right)` and got AC, but Gemini suggested `while (left < right)` as it is less error-prone. Learned the binary search decision-making process. Plan to redo this.
      [2026-04-05]: 100% 5min.

  - id: 155
    title: "Min Stack"
    link: "./problems/155_min_stack/"
    leetcode-difficulty: medium
    topics: [stack, design, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Don't understand the problem
      [2025-12-12]: I know the key is to maintain two stacks, and I think through the logic, and slowly implement the code correctly. But cannot do it in a flash.
      [2026-04-14]: 100% 10min. One-shot.
      [2026-04-17]: 100% 5min. One-shot.
      [2026-04-24]: 100% 5min. One-shot and remembered to add const to member function this time.

  - id: 162
    title: "Find Peak Element"
    link: "./problems/162_find_peak_element/"
    leetcode-difficulty: medium
    topics: [binary-search, array]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Easy solution after doing LC33, LC153, LC704 in a row.
      [2026-04-06]: 100% 5min.

  - id: 167
    title: "Two Sum II - Input Array Is Sorted"
    link: "./problems/167_two_sum_ii_input_array_is_sorted/"
    leetcode-difficulty: medium
    topics: [two-pointer, array, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: trivial two-pointer.
      [2026-04-03]: 70%. Seems trivial but fucked up left, right and 1-indexed.
      [2026-04-05]: 100% 5min.

  - id: 190
    title: "Reverse Bits"
    link: "./problems/190_reverse_bits/"
    leetcode-difficulty: easy
    topics: [bitops, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: I know the sequential bit manipulation. But there are two more ways that I cannot think of. Also, not familiar with `(x >> ?) | (x << x)` syntax and Immediately Invoked Function Expression.

  - id: 191
    title: "Number of 1 Bits"
    link: "./problems/191_number_of_1_bits/"
    leetcode-difficulty: easy
    topics: [bitops, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: use __builtin_popcount or Brian Kernighan algorithm
      [2025-04-22]: 100% 3min.

  - id: 198
    title: "House Robber"
    link: "./problems/198_house_robber/"
    leetcode-difficulty: medium
    topics: [1d-dp, dp, array, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: dp[i] means max amount can be robbed from house[0..i]. dp[i] = max(dp[i-1], dp[i-2]+nums[i]). Use foldl to optimize space
      [2026-04-10]: 10%. Wrong definition, wrong transition function.
      [2026-04-12]: 100% 4min.

  - id: 199
    title: "Binary Tree Right Side View"
    link: "./problems/199_binary_tree_right_side_view/"
    leetcode-difficulty: medium
    topics: [tree, bfs, dfs, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Almost one shot. Only forgot to check the root node is nullptr.

  - id: 200
    title: "Number of Islands"
    link: "./problems/200_number_of_islands/"
    leetcode-difficulty: medium
    topics: [graph, array, dfs, matrix, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: One-shot, but ugly. Key is `constexpr dirs[4][2]` and use `auto dfs = [&](auto &&dfs, int r, int c) -> void`.
      [2026-03-29]: One-shot.

  - id: 203
    title: "Remove Linked List Elements"
    link: "./problems/203_remove_linked_list_elements/"
    leetcode-difficulty: easy
    topics: [linked-list, iteration]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-18]: 99% 3min. One shot with indirect pointer.

  - id: 206
    title: "Reverse Linked List"
    link: "./problems/206_reverse_linked_list/"
    leetcode-difficulty: easy
    topics: [linked-list, iteration, recursion, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Every time I do this, I feel very frustrated. I know the idea.
        - Iterative: use 3 pointers prev, curr, next. But I cannot implement correctly.
        - Recursive: In Haskell, this is easy `reverse (x:xs) = (reverse xs) ++ [x]`, but I cannot implement it in C++. It is `head->next->next = head; head->next = nullptr; return newHead;`...

      [2025-12-12]: I use iterative. It is almost an one-shot. Only return I should return prev instead of curr.
      [2026-04-13]: 100% 2min.

  - id: 207
    title: "Course Schedule"
    link: "./problems/207_course_schedule/"
    leetcode-difficulty: medium
    topics: [graph, bfs, dfs, topological-sort, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: BFS or DFS coloring to detect cycle. Or use Kahn's algorithm to do topological sort.
      [2025-12-12]: I use enum-class to define colors. And get it almost right
      [2026-03-27]: half correct. the states should be recusive and set Visising, recursive, Visited.
      [2026-03-28]: One-shot;

  - id: 209
    title: "Minimum Size Subarray Sum"
    link: "./problems/209_minimum_size_subarray_sum/"
    leetcode-difficulty: medium
    topics: [sliding-window, array]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: One-shot.
      [2026-03-30]: 90% 8min. Boundary check and return value check (INT_MAX).
      [2026-03-31]: 95% 6min. Didn't read the problem again. If invalid should return 0, not -1.

  - id: 210
    title: "Course Schedule II"
    link: "./problems/210_course_schedule_ii/"
    leetcode-difficulty: medium
    topics: [graph, bfs, dfs, topological-sort, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: First time, now forget how to trace the path
      [2025-12-12]: Second time re-learn. Khan's algorithm is easy to implement. The error I made is indeg[course] == 0, I wrote indeg[course] != 0.
      [2026-03-27]: Alomost. Indegree wrong and loop detection should just check `ans.size() == numCourses`
      [2026-03-28]: One-shot.

  - id: 211
    title: "Design Add and Search Words Data Structure"
    link: "./problems/211_design_add_and_search_words_data_structure/"
    leetcode-difficulty: medium
    topics: [trie, backtracking, design, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: When doing first time seeing Trie, need to re-learn. The key is the struct (data)
      [2025-12-12]: Second time re-learn, I found myself forgetting the important details, like using `std::unique_ptr`. Also, remember to use `auto it = map.emplace(...).first`. Emplace returns a pair<iterator, bool>. We can add (void) infront of emplace if we don't care about the return value.

  - id: 213
    title: "House Robber II"
    link: "./problems/213_house_robber_ii/"
    leetcode-difficulty: medium
    topics: [1d-dp, dp, circular, array, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Arranged in circle. Two cases: rob house[0..n-2] or house[1..n-1]

  - id: 215
    title: "Kth Largest Element in an Array"
    link: "./problems/215_kth_largest_element_in_an_array/"
    leetcode-difficulty: medium
    topics: [heap, array, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2026-01-23]: One-shot.

  - id: 217
    title: "Contains Duplicate"
    link: "./problems/217_contains_duplicate/"
    leetcode-difficulty: easy
    topics: [hashset, array, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: HashSet
      [2026-04-15]: 100% 3min.

  - id: 219
    title: "Contains Duplicate II"
    link: "./problems/219_contains_duplicate_ii/"
    leetcode-difficulty: easy
    topics: [hashset, array, sliding-window, dp]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-02] 80% 8min. Range issue & `++left` But real solution should use DP.

  - id: 220
    title: "Contains Duplicate III"
    link: "./problems/220_contains_duplicate_iii/"
    leetcode-difficulty: hard
    topics: [hashset, array, sliding-window, binary-search]
    status: L1_FORGOT
    refinement_focus: |
      [2026-04-03] Failed.
      [2026-04-11] 0% 20min. Know lower_bound. We only check indexDiff from past.

  - id: 222
    title: "Count Complete Tree Nodes"
    link: "./problems/222_count_complete_tree_nodes/"
    leetcode-difficulty: medium
    topics: [tree, binary-search, dfs]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-07] 0%. Just learned the trick. Go to left most and right most to find the height.
      [2026-04-10] 100% 5min.

  - id: 226
    title: "Invert Binary Tree"
    link: "./problems/226_invert_binary_tree/"
    leetcode-difficulty: easy
    topics: [tree, dfs, bfs, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2026-03-26]: One-shot.
      [2026-03-26]: One-shot.

  - id: 230
    title: "Kth Smallest Element in a BST"
    link: "./problems/230_kth_smallest_element_in_a_bst/"
    leetcode-difficulty: medium
    topics: [tree, dfs, binary-search-tree, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: I know the concept, but implementation has a lot of problems.
        - Recursive solution: I didn't make k and result function arguments as references. I was thinking to put result as return value, but it is not a good idea.
        - Iterative solution: The structure of while loop is totally wrong. I need to practice more.

      [2025-12-12]: I know the big structure but I have problems with the iterative solution. The key is using `while (curr || !stack.empty())` as the main iterating method, and we should not prevent curr from being null. In fact, we want to see curr is null so that we use pop to backtrack, then go to the right child.
      [2026-03-29]: One-shot with recursive solution. Iterative not learned yet.

  - id: 232
    title: "Implement Queue using Stacks"
    link: "./problems/232_implement_queue_using_stacks/"
    leetcode-difficulty: easy
    topics: [stack, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-14]: Peek answer, wrong with the helper function.

  - id: 234
    title: "Palindrome Linked List"
    link: "./problems/234_palindrome_linked_list/"
    leetcode-difficulty: easy
    topics: [linked-list, fast-slow-pointer, stack]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-19]: Concept is correct, made tons of mistake implementing.

  - id: 235
    title: "Lowest Common Ancestor of a Binary Search Tree"
    link: "./problems/235_lowest_common_ancestor_of_a_binary_search_tree/"
    leetcode-difficulty: medium
    topics: [tree, dfs, binary-search-tree, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: I didn't write the code correctly in a sprint. But I reframe the question and solve it correctly.

  - id: 236
    title: "Lowest Common Ancestor of a Binary Tree"
    link: "./problems/236_lowest_common_ancestor_of_a_binary_tree/"
    leetcode-difficulty: medium
    topics: [tree, dfs, binary-tree]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: My solution is to trace all path to p, and trace all path to q. Then iterate the longest two vector. But the best solution is to use recursive found or not.
      [2026-03-27]: Not fluent.
      [2026-03-28]: One-shot in 5 lines.

  - id: 238
    title: "Product of Array Except Self"
    link: "./problems/238_product_of_array_except_self/"
    leetcode-difficulty: medium
    topics: [array, prefix-sum, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Prefix and Suffix product arrays, or use output array as prefix product array to save space
      [2026-04-12]: 50%. Correct in explicit prefix-suffix-sum. Failed in inplace.
      [2026-04-13]: 100% 10min. Not one-shot, problem with the set sequence.

  - id: 239
    title: "Sliding Window Maximum"
    link: "./problems/239_sliding_window_maximum/"
    leetcode-difficulty: hard
    topics: [monotonic-queue, array, sliding-window, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: WTF
      [2025-12-12]: I can quickly write the whole solution. But there are 2 problems. First, indices are wrong. Second, I caused overflow by not checking (idx >= k) when calculating std::size_t. Be extra cautious when using unsigned types.
      [2026-04-14]: Huge WTF. Learned again. (1). Deque. (2). Fixed window, use const int left in for-loop.

  - id: 242
    title: "Valid Anagram"
    link: "./problems/242_valid_anagram/"
    leetcode-difficulty: easy
    topics: [hashtable, string, sorting, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-15]: 15min 2 solutions. Passed but missing check length in the front.

  - id: 252
    title: "Meeting Rooms"
    link: "./problems/252_meeting_rooms/"
    leetcode-difficulty: easy
    topics: [intervals, greedy, sorting, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Sort by start time. Then iterate to check.

  - id: 253
    title: "Meeting Rooms II"
    link: "./problems/253_meeting_rooms_ii/"
    leetcode-difficulty: medium
    topics: [intervals, greedy, sorting, priority-queue, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-01-19]: Hint: Priority Queue.
      [2026-04-28]: 100%.

  - id: 257
    title: "Binary Tree Paths"
    link: "./problems/257_binary_tree_paths/"
    leetcode-difficulty: easy
    topics: [tree, dfs, binary-tree]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-17]: 40%. Got the wrong answer twice. The first failure occurred because I allowed the DFS to accept a `nullptr` and returned the path, which incorrectly printed all nodes instead of just leaf paths. The second failure happened when I incorrectly returned immediately after adding a valid leaf path to the result, without popping the last element off the path string first.

  - id: 260
    title: "Single Number III"
    link: "./problems/260_single_number_iii/"
    leetcode-difficulty: medium
    topics: [bitops, array, math-and-geometry]
    status: L1_FORGOT
    refinement_focus: |
      [2025-12-12]: Hint: XOR properties, and partition
      [2026-03-29]: almost correct. UB in (-int).
          Should `~static_cast<int>(n) + 1`

  - id: 268
    title: "Missing Number"
    link: "./problems/268_missing_number/"
    leetcode-difficulty: easy
    topics: [array, math-and-geometry, bitops, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Peek the solution. The key is to use XOR properties.
      [2026-04-13]: 100% 5min.

  - id: 278
    title: "First Bad Version"
    link: "./problems/278_first_bad_version/"
    leetcode-difficulty: easy
    topics: [binary-search]
    status: L3_MASTERED
    refinement_focus:
      [2025-12-12]:
        Just standard [start, end) binary search to change the predicate
      [2026-04-04]: 100% 6min.

  - id: 283
    title: "Move Zeroes"
    link: "./problems/283_move_zeroes/"
    leetcode-difficulty: easy
    topics: [array, two-pointers]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-15]: 100% 10min. Didn't increment ++slow. Learn std::fill.

  - id: 287
    title: "Find the Duplicate Number"
    link: "./problems/287_find_the_duplicate_number/"
    leetcode-difficulty: medium
    topics: [two-pointer, linked-list, array, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: For simple map solution, I can implement it fluently. For the two-pointer solution, this is not intuitive at all. The key is to treat the array as a linked list, and the duplicate number is the entry point of the cycle. Then use Floyd's Tortoise and Hare algorithm to find the entry point.

  - id: 297
    title: "Serialize and Deserialize Binary Tree"
    link: "./problems/297_serialize_and_deserialize_binary_tree/"
    leetcode-difficulty: hard
    topics: [tree, bfs, dfs, binary-tree, design, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Core tree logic (BFS traversal) was fine. My main friction point was implementing the string tokenizer from scratch quickly. Need to internalize the `stringstream` + `getline` pattern. Also, remember to handle the trailing comma from serialize.

  - id: 300
    title: "Longest Increasing Subsequence"
    link: "./problems/300_longest_increasing_subsequence/"
    leetcode-difficulty: medium
    topics: [1d-dp, dp, binary-search, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: DP O(n^2) or Binary Search O(n log n). Binary search is never practiced. dp[i] means from nums[0..i], the longest increasing subsequence that ends with nums[i]
      [2026-04-11]: 0%. DP Relearned.

  - id: 303
    title: "Range Sum Query - Immutable"
    link: "./problems/303_range_sum_query_immutable/"
    leetcode-difficulty: easy
    topics: [prefix-sum, array, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-17]: 100% 5min.

  - id: 310
    title: "Minimum Height Trees"
    link: "./problems/310_minimum_height_trees/"
    leetcode-difficulty: medium
    topics: [graph, bfs, tree]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Peel off the leaves layer by layer until 1 or 2 nodes left
      [2025-12-12]: I struggled with this.

  - id: 322
    title: "Coin Change"
    link: "./problems/322_coin_change/"
    leetcode-difficulty: medium
    topics: [1d-dp, dp, bfs, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: dp[i] means the minimum coins to make amount i
      [2026-04-11]: Relearned. DFS, Top-Down, Botton-Up.
      [2026-04-12]: 95% 14min.
        Correct, but not smooth. Issue in init value not set.
        Learned to swap two for-loops and set INF.

  - id: 338
    title: "Counting Bits"
    link: "./problems/338_counting_bits/"
    leetcode-difficulty: easy
    topics: [dp, bitops, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: I used matrix count to count bits, but it is O(n^2). The soultion is to use DP `dp[i] = dp[i >> 1] + (i & 1)`.
      [2026-04-13]: 0%. Wrong interpretation of the problem.

  - id: 347
    title: "Top K Frequent Elements"
    link: "./problems/347_top_k_frequent_elements/"
    leetcode-difficulty: medium
    topics: [array, hashtable, heap, bucket-sort, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Use HashMap to count frequency, then use Min-Heap or Bucket Sort to get top K. Bucket sort is optimal O(n), but I forget how to implement it
      [2025-12-12]: std::priority queue
      [2025-12-12]: almost correct using heap, write bucket sort. (remember bucket 0 should be empty)
      [2026-04-13]: 100%. Not one-shot. pq.emplace(num, count) args should be reversed.

  - id: 371
    title: "Sum of Two Integers"
    link: "./problems/371_sum_of_two_integers"
    leetcode-difficulty: medium
    topics: [bitops, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: RCA & parallel RCA. (maybe need review)

  - id: 389
    title: "Find the Difference"
    link: "./problems/389_find_the_difference"
    leetcode-difficulty: easy
    topics: [bitops, hashmap]
    status: L2_STRUGGLE
      [2026-04-29]: 100%. Minor mistake using hashmap, but strong should think of xor.

  - id: 392
    title: "Is Subsequence"
    link: "./problems/392_is_subsequence"
    leetcode-difficulty: easy
    topics: [two-pointer]
    status: L1_FORGOT
      [2026-06-12]: 0%. Frustrated.

  - id: 394
    title: "Decode String"
    link: "./problems/394_decode_string/"
    leetcode-difficulty: medium
    topics: [stack, string, recursion]
    status: L1_FORGOT
    refinement_focus: |
      [2026-01-27]: Should not be hard but I froze.
      [2026-04-28]: 30%. Eventully figured out, using lambda clojure.

  - id: 399
    title: "Evaluate Division"
    link: "./problems/399_evaluate_division/"
    leetcode-difficulty: medium
    topics: [graph, dfs, bfs]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-01-26]: Understand the concept, but creating the correct graph is using unordered_map<string, unordered_map<string, double>>. Not trying to write string to int conversion then find the map. Also, bfs needs careful handling of the visited set.

  - id: 416
    title: "Partition Equal Subset Sum"
    link: "./problems/416_partition_equal_subset_sum/"
    leetcode-difficulty: medium
    topics: [1d-dp, dp, knapsack, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: The first time I need to learn from the answer and learn knapsack. dp[i][j] means using nums[0..i], can we fill a knapsack of capacity j. dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]]"

      [2025-12-12]: Fast implement. Forget to set dp[0] = true. Forget std::accumulate need to add accumulator 0 and include numeric. Should be L2~L3. But I set to L2. Lets practice later.

  - id: 410
    title: "Split Array Largest Sum"
    link: "./problems/410_split_array_largest_sum/"
    leetcode-difficulty: hard
    topics: [binary-search, greedy]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-28]: 94%. Missing `=` in validate lambda.

  - id: 435
    title: "Non-overlapping Intervals"
    link: "./problems/435_non_overlapping_intervals/"
    leetcode-difficulty: medium
    topics: [intervals, greedy, sorting, neetcode150]
    status: L1_FORGOT
    refinement_focus: |
      [2025-12-12]: Greedy. Sort by end time. Then iterate and merge overlaps."
      [2026-04-12]: 60% 14min. Should record `prev_end = min(prev_end, curr[1])`.
      [2026-04-29]: Failed! Should sort by end time.

  - id: 438
    title: "Find All Anagrams in a String"
    link: "./problems/438_find_all_anagrams_in_a_string/"
    leetcode-difficulty: medium
    topics: [string, sliding-window, hashtable]
    status: L1_FORGOT
    refinement_focus: |
      [2026-04-01]: 30% 16min. Structure correct. Wrong range, wrong logic, wrong index.
      [2026-04-02]: 0% directly failed.
      [2026-04-05]: 100% 7min.

  - id: 448
    title: "Find All Numbers Disappeared in an Array"
    link: "./problems/448_find_all_numbers_disappeared_in_an_array/"
    leetcode-difficulty: easy
    topics: [array, hashmap]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-01]: Forget to (n + 1) in vector constructor.

  - id: 461
    title: "Hamming Distance"
    link: "./problems/461_hamming_distance/"
    leetcode-difficulty: easy
    topics: [bit-manipulation, math-and-geometry]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-09]: 100% 4min. Interview.

  - id: 477
    title: "Total Hamming Distance"
    link: "./problems/477_total_hamming_distance/"
    leetcode-difficulty: medium
    topics: [bit-manipulation, math-and-geometry]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-09]: 100% 4min. Interview. Faster way is `count_1 * count_0`.

  - id: 496
    title: "Next Greater Element I"
    link: "./problems/496_next_greater_element_i/"
    leetcode-difficulty: easy
    topics: [monotonic-stack, hashtable, array]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Monotonic stack.
      [2026-04-09]: 70%. The problem ask for value, I saved for index.

  - id: 503
    title: "Next Greater Element II"
    link: "./problems/503_next_greater_element_ii/"
    leetcode-difficulty: medium
    topics: [monotonic-stack, array, circular]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Monotonic stack. Circular array can be simulated by iterating 2 times
      [2026-04-09]: 90%.

  - id: 509
    title: "Fibonacci Number"
    link: "./problems/509_fibonacci_number/"
    leetcode-difficulty: easy
    topics: [dp, recursion]
    status: L3_MASTERED
    refinement_focus: |
      [2026-01-07]: Recursion with memo or bottom-up DP

  - id: 543
    title: "Diameter of Binary Tree"
    link: "./problems/543_diameter_of_binary_tree/"
    leetcode-difficulty: easy
    topics: [tree, bfs, binary-tree, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Recursion or FOLD

  - id: 547
    title: "Number of Provinces"
    link: "./problems/547_number_of_provinces/"
    leetcode-difficulty: medium
    topics: [union-find]
    status: L2_STRUGGLE
    refinement_focus:
      [2026-01-17]: One-shot union find, but recommended to practice more

  - id: 567
    title: "Permutation in String"
    link: "./problems/567_permutation_in_string/"
    leetcode-difficulty: medium
    topics: [sliding-window, hashtable, array, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-02]: 100% 10min. But just finished 438, so it is fresh in my mind.

  - id: 572
    title: "Subtree of Another Tree"
    link: "./problems/572_subtree_of_another_tree/"
    leetcode-difficulty: easy
    topics: [tree, dfs, bfs, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Recursive and helper is same function can solve the problem. But I think what if we can use KMF algorithm way like structure?
      [2026-04-17]: 90%. Peek and serialized, recursive call forget to add output buffer.

  - id: 617
    title: "Merge Two Binary Trees"
    link: "./problems/617_merge_two_binary_trees/"
    leetcode-difficulty: easy
    topics: [tree, dfs, bfs, binary-tree, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-17]: 90%. Handled value null, but forget to handle node null.

  - id: 622
    title: "Design Circular Queue"
    link: "./problems/622_design_circular_queue/"
    leetcode-difficulty: medium
    topics: [design, queue, array]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-17]: 100%. The helper function can be changed to `getPrev` and `getNext`.

  - id: 637
    title: "Average of Levels in Binary Tree"
    link: "./problems/637_average_of_levels_in_binary_tree/"
    leetcode-difficulty: easy
    topics: [tree, bfs, binary-tree]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-15] 100% 7min. Typo. Queue `q.front()`. Practiced double buffer technique.

  - id: 643
    title: "Maximum Average Subarray I"
    link: "./problems/643_maximum_average_subarray_i/"
    leetcode-difficulty: easy
    topics: [sliding-window, array]
    status: L3_MASTERED
    refinement_focus: |
      [2026-03-31]: Failed.
      [2026-04-01]: 30%. Problem is the valid state without `if`. sum_max init value is wrong.
      [2026-04-02]: 95% 5min. Missing `++left`.
      [2026-04-14]: 99% 5min. `glob_max` should init to NINF.
      [2026-04-15]: 96% 5min. Should `glob_max / k`, but `glob_max/ n`.

  - id: 647
    title: "Palindromic Substrings"
    link: "./problems/647_palindromic_substrings/"
    leetcode-difficulty: medium
    topics: [1d-dp, dp, string, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Very similar to 005_Longest_Palindromic_Substring. There are three ways: Expand, 2D-dp, or 1D-dp build up layer by layer

  - id: 653
    title: "Two Sum IV - Input is a BST"
    link: "./problems/653_two_sum_iv_input_is_a_bst/"
    leetcode-difficulty: easy
    topics: [tree, bst, dfs, two-pointer, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-03]: 90%. Wrong traversal order.

  - id: 684
    title: "Redundant Connection"
    link: "./problems/684_redundant_connection/"
    leetcode-difficulty: medium
    topics: [graph, union-find, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: text book union find
      [2026-03-27]: review template. for unite the return value should be bool

  - id: 704
    title: "Binary Search"
    link: "./problems/704_binary_search/"
    leetcode-difficulty: easy
    topics: [binary-search, array, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Standard binary search template
      [2025-12-12]: I use `while(lo < hi)` at the first try
          - `while(lo < hi)` is for finding boundary
          - `while(lo <= hi)` is for exact match
      [2026-04-04]: 100%.

  - id: 743
    title: "Network Delay Time"
    link: "./problems/743_network_delay_time/"
    leetcode-difficulty: medium
    topics: [advanced-graph, graph, bfs, dijkstra, neetcode150]
    status: L1_FORGOT
    refinement_focus: |
      [2026-03-30]: implement dijkstrs's first time with guildance
      [2026-03-30]: 90%, 18min. Wrong in `max_element`
      [2026-04-01]: 100% 18min.
      [2026-04-14]: 20%. Failed.

  - id: 744
    title: "Find Smallest Letter Greater Than Target"
    link: "./problems/744_find_smallest_letter_greater_than_target/"
    leetcode-difficulty: easy
    topics: [binary-search, array]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-15]: 100% 6min. One-shot.

  - id: 746
    title: "Min Cost Climbing Stairs"
    link: "./problems/746_min_cost_climbing_stairs/"
    leetcode-difficulty: easy
    topics: [1d-dp, dp, array, neetcode150]
    status: L3_MASTERED
    refinement_focus: |
      [2026-01-07]: dp[i] means min cost to reach step i. dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2])

  - id: 844
    title: "Backspace String Compare"
    link: "./problems/844_backspace_string_compare/"
    leetcode-difficulty: easy
    topics: [string, stack, two-pointer]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-17]: 30%. I don't think this is an easy problem. Initially, I wasn't sure how to approach it, so I tried iterating backwards, counting consecutive '#' characters and decreasing the index accordingly. However, this failed on corner cases like "1#22#2##" because it incorrectly skipped the '#'. I then switched to a stack-based approach but mistakenly placed the boundary check in the wrong 'if' condition, which caused additional bugs. Finally solved the problem. (Also, I think the 'if' statements should be replaced with a 'switch' to explicitly indicate we are pattern matching).

  - id: 852
    title: "Peak Index in a Mountain Array"
    link: "./problems/852_peak_index_in_a_mountain_array/"
    leetcode-difficulty: medium
    topics: [binary-search, array]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Binary search to find the first location where arr[i] > arr[i+1]
      [2025-12-12]: I thought I can aced it... AC, but has flaws. I used while (lo <= hi) and use double way check which is not needed.
      [2026-04-05]: 100% 5min. But just read the template. Need more practice.

  - id: 875
    title: "Koko Eating Bananas"
    link: "./problems/875_koko_eating_bananas/"
    leetcode-difficulty: medium
    topics: [binary-search, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-27]: 70%. Wrong in hi should use `max_element` to piles. Also, get `ceil(a/b)`is `(a+b-1)/b`. Please noted that this is the typical template.

  - id: 876
    title: "Middle of the Linked List"
    link: "./problems/876_middle_of_the_linked_list"
    leetcode-difficulty: easy
    topics: [linked-list]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-03-25]: while-loop issue.

  - id: 977
    title: "Squares of a Sorted Array"
    link: "./problems/977_squares_of_a_sorted_array/"
    leetcode-difficulty: easy
    topics: [array, two-pointers, sorting]
    status: L3_MASTERED
    refinement_focus: |
      [2026-04-15]: 99% 10min. Almost. (-INT_MIN cause underflow)

  - id: 978
    title: "Longest Turbulent Subarray"
    link: "./problems/978_longest_turbulent_subarray/"
    leetcode-difficulty: medium
    topics: [array, dp, sliding-window]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: TODO.

  - id: 994
    title: "Rotting Oranges"
    link: "./problems/994_rotting_oranges/"
    leetcode-difficulty: medium
    topics: [graph, array, bfs, matrix, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: I used simulation with a queue to store the oranges that are going to rot, then update the grid. But this is slow. I should use *multi-source BFS* to speed up the simulation. (level order traversal one example for multi-source BFS)
          From SICP's view, the *multi-source BFS* is
          #+begin_src racket
          (define (expand frontier grid seen)
            ;; returns next-frontier and updated seen
          )
          #+end_src
          - process =expand= stays the same, initial state is kept changing
          - initial state is the set of all rotten oranges
      [2026-03-29]: 40%. Wrong structure. Should "Verify, Mutate, Push" in BFS
      [2026-03-30]: 70%. Wrong `minutes_elapsed`
      [2026-03-31]: 80%. Forget level order count.
      [2026-04-01]: 95%. Minor typos.

  - id: 1011
    title: "Capacity To Ship Packages Within D Days"
    link: "./problems/1011_capacity_to_ship_packages_within_d_days/"
    leetcode-difficulty: medium
    topics: [binary-search]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-27]: 95% 10min. The lo, hi init value is wrong and naming is slightly bad.

  - id: 1117
    title: "Building H2O"
    link: "./problems/1117_building_h2o/"
    leetcode-difficulty: medium
    topics: [concurrency, semaphore, threading]
    status: L1_FORGOT
    refinement_focus: |
      [2026-04-21]: Learning. Fun.

  - id: 1188
    title: "Design Bounded Blocking Queue"
    link: "./problems/1188_design_bounded_blocking_queue/"
    leetcode-difficulty: medium
    topics: [design, concurrency, queue]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-20]: Learning. Fun.
      [2026-04-24]: 95% 10min. Did 2 solutions, basic queue, and circular buffer. Mistake is made in predicate. If !prediate will stuck in while loop.

  - id: 1448
    title: "Count Good Nodes in Binary Tree"
    link: "./problems/1448_count_good_nodes_in_binary_tree/"
    leetcode-difficulty: medium
    topics: [tree, dfs, binary-tree, neetcode150]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Very fun. I thought of using mono-stack, but it is not necessary. Just pass down the max value from root to leaf.

  - id: 1631
    title: "Path With Minimum Effort"
    link: "./problems/1631_path_with_minimum_effort/"
    leetcode-difficulty: medium
    topics: [graph, DSU, dijkstra]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-03-30]: 90%, DSU. minor typos. might take a little to much time.

  - id: 2022
    title: "2022. Convert 1D Array Into 2D Array"
    link: "./problems/2022_convert_1d_array_into_2d_array/"
    leetcode-difficulty: easy
    topics: [array, matrix]
    status: L2_STRUGGLE
    refinement_focus: |
      [2026-04-18]: Initially thought I could just `reinterpret_cast` the 1D array into a 2D array, but C++ uses `std::vector<std::vector<int>>` which is not contiguous in memory. Because of this, I needed to construct it manually. At first, I pre-allocated the vector and assigned values using `ans[row][col]`, but this was slow due to an unnecessary default initialization followed by assignments. The correct, more efficient approach is to construct the inner vectors directly using `emplace_back` with iterator ranges.

  - id: 3613
    title: "Minimize Maximum Component Cost"
    link: "./problems/3613_minimize_maximum_component_cost/"
    leetcode-difficulty: hard
    topics: [array, greedy, math-and-geometry]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: meet in interview. DSU + Kruskal's algorithm.

  - id: 3634
    title: "Minimum Removals to Balance Array"
    link: "./problems/3634_minimum_removals_to_balance_array/"
    leetcode-difficulty: medium
    topics: [array, sorting, two-pointer, sliding-window]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: I first use greedy left right pointer at each end to find. But the problem is actually a sliding window problem.

  - id: 3701
    title: "Compute Alternating Sum"
    link: "./problems/3701_compute_alternating_sum/"
    leetcode-difficulty: easy
    topics: [array, leetcode-contest]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Trivial

  - id: 3702
    title: "Longest Subsequence With Non-Zero Bitwise XOR"
    link: "./problems/3702_longest_subsequence_with_nonzero_bitwise_xor/"
    leetcode-difficulty: medium
    topics: [bitops, leetcode-contest]
    status: L1_FORGOT
    refinement_focus: |
      [2025-12-12]: There are only 3 cases, but I thought we can only solve it by DP.

  - id: 3703
    title: "Remove K-Balanced Substrings"
    link: "./problems/3703_remove_k-balanced_substrings/"
    leetcode-difficulty: medium
    topics: [string, leetcode-contest]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Didn't finish during contest. Use vector<pair<char, int>> to store (char, count) pairs. Then simulate the removal of k-balanced substrings.

  - id: 3712
    title: "Sum of Elements With Frequency Divisible by K"
    link: "./problems/3712_sum_of_elements_with_frequency_divisible_by_k/"
    leetcode-difficulty: easy
    topics: [hashtable, array, leetcode-contest]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Trivial

  - id: 3713
    title: "Longest Balanced Substring I"
    link: "./problems/3713_longest_balanced_substring_i/"
    leetcode-difficulty: medium
    topics: [string, brute-force, leetcode-contest]
    status: L1_FORGOT
    refinement_focus: |
      [2025-12-12]: Didn't finish during contest. I don't even identify this as a brute-force problem.

  - id: 3718
    title: Smallest Missing Multiple of K
    link: "./problems/3718_smallest_missing_multiple_of_k/"
    leetcode-difficulty: easy
    topics: [math-and-geometry, hashtable, iteration, leetcode-contest]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: The return value might be tricky when the largest value is K's multiple.

  - id: 3719
    title: "Longest Balanced Subarray i"
    link: "./problems/3719_longest_balanced_subarray_i/"
    leetcode-difficulty: medium
    topics: [array, hashset, two-pointer, sliding-window, enumeration]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Starting, when I read the problem, I missed the "distinct" keyword. So I thought of using frequency map to track counts of each number in the window and try to use prefix sum to optimize. But it is too complicated. After realizing "distinct", I can use two-pointer sliding window to solve it easily.

  - id: 3720
    title: "3720. Lexicographically Smallest Permutation Greater Than Target"
    link: "./problems/3720_lexicographically_smallest_permutation_greater_than_target/"
    leetcode-difficulty: medium
    topics: [string, greedy, sorting, counting, hashtable]
    status: L1_FORGOT
    refinement_focus: |
      [2025-12-12]: Although I know the basic idea, I cannot correctly implement the greedy algorithm. Even struggled for the whole afternoon. I got very frustrated and tired, and even cannot understand the solution from Gemini.

  - id: 3726
    title: "Remove Zeros in Decimal Representation"
    link: "./problems/3726_remove_zeros_in_decimal_representation/"
    leetcode-difficulty: easy
    topics: [string, weekly-contest]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Simple std::to_string and std::stoll

  - id: 3727
    title: "Maximum Alternating Sum of Squares"
    link: "./problems/3727_maximum_alternating_sum_of_squares/"
    leetcode-difficulty: medium
    topics: [greedy, sorting, weekly-contest]
    status: L3_MASTERED
    refinement_focus: |
      [2025-12-12]: Greedy

  - id: 3728
    title: "Stable Subarrays With Equal Boundary and Interior Sum"
    link: "./problems/3728_stable_subarrays_with_equal_boundary_and_interior_sum/"
    leetcode-difficulty: medium
    topics: [prefix-sum, subarray, weekly-contest]
    status: L2_STRUGGLE
    refinement_focus: |
      [2025-12-12]: Tried brute-force first, TLE. Then, prefix-sum, TLE. Then, prefix-sum + hash-map for same l,r value, TLE. Gemini's solution is not very intuitive. It keeps track of prefix-sum and index in a hash-map, so that we can find all possible pairs for every r.