Skip to content

contest_review.md

Latest commit

 

History

History
138 lines (107 loc) · 9.3 KB

contest_review.md

File metadata and controls

138 lines (107 loc) · 9.3 KB
Raw

🏁 LeetCode Contest Review

🔸 Biweekly Contest 164 (2025-08-30)

  • Solved: 1 / 4
  • Score: 3
  • Rank: 14524
  • Status: ✅ 5th contest

📘 Summary

# Title Status Notes
3663 Find The Least Frequent Digit ✅ Counting digits
3664 Two-Letter Card Game ❌ Count cards by categories and use greedy pairing with leftovers (both, left, right)
3665 Twisted Mirror Path Count ❌ To revisit
3666 Minimum Operations To Equalize Binary String ❌ To revisit

🧠 Lessons Learned

  • Two Letter Card Game (3664): count cards in three categories (both-x, left-x, right-x), compute the maximum pairs from left-x and right-x using a greedy interPair strategy, then use both-x cards to cover leftovers and form additional pairs, maximizing the total score.

⚠️ Note: Problems 3665 and 3666 are both relatively challenging and involve advanced techniques:

  • Problem 3665 requires multi-state dynamic programming, directional simulation with consecutive reflections, and boundary-aware path counting.
  • Problem 3666 requires combinatorial bit manipulation, subset selection strategies, and parity-based feasibility analysis. Given the current focus on consolidating core algorithmic skills, I have decided to temporarily set these problems aside. I plan to revisit them later after strengthening stateful DP, simulation, and combinatorial techniques.

🔸 Biweekly Contest 163 (2025-08-16)

  • Solved: 0 / 4
  • Score: 0
  • Rank: 18361
  • Status: ✅ 4th contest

📘 Summary

# Title Status Notes
3648 Minimum Sensors To Cover Grid ❌ Coverage square side = 2k+1; ceil-div in both dims
3649 Number Of Perfect Pairs ❌ Sort + two pointers on absolute values / Count pairs satisfying y ≤ 2x
3650 Minimum Cost Path With Edge Reversals ❌ Model each edge as two directed edges (original cost and 2× cost for reversal) and solve with Dijkstra
3651 Minimum Cost Path With Teleportations ❌ To revisit (2D grid shortest path with at most k teleportations; involves multi-dimensional DP / BFS / Dijkstra)

🧠 Lessons Learned

  • Transform coverage by Chebyshev distance (3648): each sensor covers a (2k+1) × (2k+1) square, so the problem reduces to ceil-dividing n and m by (2k+1) and multiplying → direct O(1) formula.
  • Simplify the mathematical condition(3649): complex min/max constraints can be reduced to a simple inequality on a sorted array, then efficiently count pairs using two pointers.
  • Minimum Cost Path With Edge Reversals (3650): model each edge as two directed edges (original cost and 2× cost for reversal), then use Dijkstra to find the shortest path → handles edge reversals naturally in O((V+E) log V) time.
  • During the contest, I started with Q2 and implemented a brute-force solution first, hoping to optimize it before attempting other problems.
  • This strategy backfired: I couldn't optimize Q2 in time and ran out of time for the other questions, resulting in no problems solved.
  • Reflection: next time, consider quickly securing easier problems first before tackling harder ones.

⚠️ Note: Problem 3651 involves advanced techniques such as multi-dimensional DP, stateful BFS/Dijkstra, and conditional teleportation optimizations.
This problem is relatively challenging and goes beyond standard grid/DP practice.
Given the current focus on consolidating core algorithmic skills, I have decided to temporarily set this problem aside.
I plan to revisit it later after strengthening multi-state DP and shortest-path techniques.

🔸 Biweekly Contest 162 (2025-08-02)

  • Solved: 2 / 4
  • Score: 7
  • Rank: 14445
  • Status: ✅ 3th contest

📘 Summary

# Title Status Notes
3633 Earlies Finish Time For Land And Water Rides I ✅ Brute-force simulate both orders (land→water / water→land)
3634 Minimum Removals To Balance Array ✅ Sort + sliding window (two pointers)
3635 Earlies Finish Time For Land And Water Rides II ❌ Greedy on earliest finish time in both orders (land→water / water→land)
3636 Threshold Majority Queries ❌ To revisit (Range frequency queries with randomized sampling)

🧠 Lessons Learned

  • Reinforced the idea that brute-force pair enumeration is acceptable for small inputs (3633), but greedy strategies using earliest finish times are essential for scaling to larger inputs (3635).
  • Gained experience distinguishing when full pair comparisons are necessary vs when minimizing over one dimension suffices for correctness and performance.
  • Learned that for ratio-based subarray conditions (3634), sorting combined with a sliding window (two pointers) is a powerful technique for optimizing performance — avoids unnecessary enumeration while guaranteeing correctness.

⚠️ Note: Problem 3636 requires advanced techniques such as Mo’s algorithm, randomized sampling, and complex range frequency queries.
This problem is relatively challenging and involves probabilistic algorithms that are beyond standard interview preparations.
Given the current focus on strengthening core algorithmic skills, I have decided to temporarily set this problem aside.
I plan to revisit it later after consolidating foundational topics and exploring more advanced range query and randomized algorithms.

🔸 Biweekly Contest 161 (2025-07-19)

  • Solved: 2 / 4
  • Score: 8
  • Rank: 8277
  • Status: ✅ Second contest

📘 Summary

# Title Status Notes
3618 Split Array By Prime Indices ✅ Array splitting based on prime indices, optimized with sieve
3619 Count Islands With Total Value Divisible By K ✅ Flood fill via DFS and BFS comparison
3620 Network Recovery Pathways ❌ DAG + Topological DP + Binary Search on edge weights
3621 Number of Integers With Popcount-Depth Equal to K I ❌ To revisit (Digit DP with bitcount-depth constraint)

🧠 Lessons Learned

  • Reinforced the Sieve of Eratosthenes to efficiently handle prime checks in (O(n \log \log n)), avoiding the naive (O(n \sqrt{n})) approach.
  • Practiced grid flood fill (DFS vs BFS), confirming DFS is faster on typical LeetCode constraints due to better cache locality and less queue overhead.
  • Learned DAG shortest path with topological DP, combined with binary search on unique edge weights to optimize feasibility checks to O((V + E) log E).

⚠️ Note: Problem 3621 involves advanced algorithmic concepts such as Digit DP combined with popcount-depth constraints.
Since this topic is relatively niche and not directly aligned with current interview-focused practice, I have decided to temporarily set this problem aside.
I plan to revisit it later when exploring more Hard-level Digit DP problems to strengthen my understanding of advanced counting techniques.

🔸 Biweekly Contest 160 (2025-07-05)

  • Solved: 2 / 4
  • Score: 8
  • Rank: 8096
  • Status: ✅ First-ever contest

📘 Summary

# Title Status Notes
3602 Hexadecimal And Hexatrigesimal Conversion ✅ Base Conversion
3603 Minimum Cost Path With Alternating Directions II ✅ Grid DP with custom movement rule
3604 Minimum Time To Reach Destination In Directed Graph ❌ To revisit (BFS with time constraints)
3605 Minimum Stability Factor Of Array ❌ To revisit (GCD + sliding window)

🧠 Lessons Learned

  • Practice high-base conversion logic and corner case handling
  • Learn how to model cost alternation using dynamic programming on grids
  • Reinforce BFS with time-constrained edge usage and (node, time) state
  • Study how to combine GCD with sliding window and binary search
  • Improve overall graph modeling and state design skills

⚠️ Note: Problems 3604 and 3605 involve advanced algorithmic concepts such as BFS with time constraints and number theory techniques (GCD combined with sliding window and binary search). Due to the current limited familiarity with these topics, I have decided to temporarily set these problems aside. I plan to revisit and solve them after further strengthening my foundational knowledge in graph algorithms and number theory.