https://leettube.dev 2026-10-07T21:20:09.316Z weekly 1 https://leettube.dev/about monthly 0.5 https://leettube.dev/worlds/warm-up 2026-10-07T21:20:09.316Z weekly 0.9 https://leettube.dev/worlds/arrays 2026-10-07T21:20:09.316Z weekly 0.9 https://leettube.dev/worlds/trees 2026-10-07T21:20:09.316Z weekly 0.9 https://leettube.dev/worlds/backtracking 2026-10-07T21:20:09.316Z weekly 0.9 https://leettube.dev/worlds/dynamic-programming 2026-10-07T21:20:09.316Z weekly 0.9 https://leettube.dev/worlds/graphs 2026-10-07T21:20:09.316Z weekly 0.9 https://leettube.dev/worlds/greedy 2026-10-07T21:20:09.316Z weekly 0.9 https://leettube.dev/worlds/bits-and-math 2026-10-07T21:20:09.316Z weekly 0.9 https://leettube.dev/worlds/design 2026-10-07T21:20:09.316Z weekly 0.9 https://leettube.dev/topics 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/dynamic-programming 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/backtracking 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/greedy 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/tree-recursion 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/bit-manipulation 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/design 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/two-pointers 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/hash-map 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/heap 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/binary-search 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/breadth-first-search 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/linked-list 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/fast-and-slow-pointers 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/grid-search 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/shortest-path 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/depth-first-search 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/math 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/carry 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/hash-set 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/matrix 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/monotonic-stack 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/prefix-sums 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/sliding-window 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/stack 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/topological-sort 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/topics/trie 2026-10-07T21:20:09.316Z weekly 0.7 https://leettube.dev/watch/intro-warm-up Warm-up tutorial https://leettube.dev/posters/intro-warm-up.webp Before the first stage: how the work grows as the input grows, and the hash map, which answers "have I seen this?" in one hop. https://leettube.dev/api/video/intro-warm-up/video.mp4 45 2026-10-07T21:16:54.768Z 2026-10-07T21:16:54.768Z monthly 0.8 https://leettube.dev/watch/two-sum Two Sum (LeetCode 1) https://leettube.dev/posters/two-sum.webp Find the two numbers that add up to the target. Walk once, and for each number look up the partner you need in a map of what you've seen. https://leettube.dev/api/video/two-sum/video.mp4 64 2026-10-07T21:19:51.401Z 2026-10-07T21:19:51.401Z monthly 0.8 https://leettube.dev/watch/valid-parentheses Valid Parentheses (LeetCode 20) https://leettube.dev/posters/valid-parentheses.webp Check that every bracket is closed by the right type, in the right order. Push each opener, and match each closer against the top of the stack. https://leettube.dev/api/video/valid-parentheses/video.mp4 96 2026-10-07T21:19:58.805Z 2026-10-07T21:19:58.805Z monthly 0.8 https://leettube.dev/watch/binary-search Binary Search (LeetCode 704) https://leettube.dev/posters/binary-search.webp Find a target in a sorted list. Check the middle and throw away the half that can't hold it, so each step halves the search. https://leettube.dev/api/video/binary-search/video.mp4 99 2026-10-07T21:15:09.509Z 2026-10-07T21:15:09.509Z monthly 0.8 https://leettube.dev/watch/linked-list-cycle Linked List Cycle (LeetCode 141) https://leettube.dev/posters/linked-list-cycle.webp Does the list loop back on itself? Send a tortoise and a hare down it: if there's a cycle, the faster runner must catch the slower one. https://leettube.dev/api/video/linked-list-cycle/video.mp4 85 2026-10-07T21:17:20.167Z 2026-10-07T21:17:20.167Z monthly 0.8 https://leettube.dev/watch/intersection-of-two-linked-lists Intersection of Two Linked Lists (LeetCode 160) https://leettube.dev/posters/intersection-of-two-linked-lists.webp Find the node where two lists join: walk each list, switch to the other head at the end, and both runners meet at the join. https://leettube.dev/api/video/intersection-of-two-linked-lists/video.mp4 98 2026-10-07T21:16:42.399Z 2026-10-07T21:16:42.399Z monthly 0.8 https://leettube.dev/watch/find-the-duplicate-number Find the Duplicate Number (LeetCode 287) https://leettube.dev/posters/find-the-duplicate-number.webp n + 1 numbers in 1..n, one repeated. Treat each value as a pointer to an index: the duplicate starts a cycle, and fast and slow runners find it. https://leettube.dev/api/video/find-the-duplicate-number/video.mp4 97 2026-10-07T21:16:19.988Z 2026-10-07T21:16:19.988Z monthly 0.8 https://leettube.dev/watch/reverse-linked-list Reverse Linked List (LeetCode 206) https://leettube.dev/posters/reverse-linked-list.webp Turn every arrow of a linked list around in place. Keep three pointers: save next, flip current back to previous, step forward. https://leettube.dev/api/video/reverse-linked-list/video.mp4 96 2026-10-07T21:19:04.603Z 2026-10-07T21:19:04.603Z monthly 0.8 https://leettube.dev/watch/merge-two-sorted-lists Merge Two Sorted Lists (LeetCode 21) https://leettube.dev/posters/merge-two-sorted-lists.webp Splice two sorted lists into one. Keep a tail pointer behind a dummy head and always take the smaller front node. https://leettube.dev/api/video/merge-two-sorted-lists/video.mp4 86 2026-10-07T21:17:49.557Z 2026-10-07T21:17:49.557Z monthly 0.8 https://leettube.dev/watch/reorder-list Reorder List (LeetCode 143) https://leettube.dev/posters/reorder-list.webp Weave a linked list first, last, second, second to last. Find the middle with slow and fast pointers, reverse the back half, then merge. https://leettube.dev/api/video/reorder-list/video.mp4 98 2026-10-07T21:18:57.687Z 2026-10-07T21:18:57.687Z monthly 0.8 https://leettube.dev/watch/palindrome-linked-list Palindrome Linked List (LeetCode 234) https://leettube.dev/posters/palindrome-linked-list.webp Does a linked list read the same both ways? Find the middle with fast and slow runners, reverse the back half, then compare the halves node by node. https://leettube.dev/api/video/palindrome-linked-list/video.mp4 98 2026-10-07T21:18:20.521Z 2026-10-07T21:18:20.521Z monthly 0.8 https://leettube.dev/watch/remove-nth-node-from-end-of-list Remove Nth Node From End of List (LeetCode 19) https://leettube.dev/posters/remove-nth-node-from-end-of-list.webp Remove the nth node from the end in one pass: start a fast runner n steps ahead, move both until it falls off, then unlink the next node. https://leettube.dev/api/video/remove-nth-node-from-end-of-list/video.mp4 98 2026-10-07T21:18:55.933Z 2026-10-07T21:18:55.933Z monthly 0.8 https://leettube.dev/watch/add-two-numbers Add Two Numbers (LeetCode 2) https://leettube.dev/posters/add-two-numbers.webp Two numbers stored as reversed linked lists: walk both at once, add digit by digit like on paper, and carry the 1 into the next node. https://leettube.dev/api/video/add-two-numbers/video.mp4 98 2026-10-07T21:14:58.738Z 2026-10-07T21:14:58.738Z monthly 0.8 https://leettube.dev/watch/contains-duplicate Contains Duplicate (LeetCode 217) https://leettube.dev/posters/contains-duplicate.webp Does any number show up twice? Walk the list once with a set of values you've already seen, and stop the moment one repeats. https://leettube.dev/api/video/contains-duplicate/video.mp4 82 2026-10-07T21:15:43.799Z 2026-10-07T21:15:43.799Z monthly 0.8 https://leettube.dev/watch/remove-duplicates-from-sorted-array Remove Duplicates from Sorted Array (LeetCode 26) https://leettube.dev/posters/remove-duplicates-from-sorted-array.webp Squeeze the duplicates out of a sorted array in place: a read pointer scans ahead while a write pointer keeps each new value. https://leettube.dev/api/video/remove-duplicates-from-sorted-array/video.mp4 98 2026-10-07T21:18:52.607Z 2026-10-07T21:18:52.607Z monthly 0.8 https://leettube.dev/watch/merge-sorted-array Merge Sorted Array (LeetCode 88) https://leettube.dev/posters/merge-sorted-array.webp Merge two sorted arrays into the first one in place: fill from the back, always placing the larger tail, so nothing gets overwritten. https://leettube.dev/api/video/merge-sorted-array/video.mp4 98 2026-10-07T21:17:45.392Z 2026-10-07T21:17:45.392Z monthly 0.8 https://leettube.dev/watch/valid-anagram Valid Anagram (LeetCode 242) https://leettube.dev/posters/valid-anagram.webp Check if two words use exactly the same letters. Count up for every letter in one, count down for the other, and see if every tally hits zero. https://leettube.dev/api/video/valid-anagram/video.mp4 89 2026-10-07T21:19:54.965Z 2026-10-07T21:19:54.965Z monthly 0.8 https://leettube.dev/watch/ransom-note Ransom Note (LeetCode 383) https://leettube.dev/posters/ransom-note.webp Can the note be cut from the magazine? Count every magazine letter, then spend one per note letter and fail the moment a count runs out. https://leettube.dev/api/video/ransom-note/video.mp4 99 2026-10-07T21:18:45.548Z 2026-10-07T21:18:45.548Z monthly 0.8 https://leettube.dev/watch/isomorphic-strings Isomorphic Strings (LeetCode 205) https://leettube.dev/posters/isomorphic-strings.webp Can each letter of s turn into one letter of t, with no two sharing? A two-way codebook settles it in a single pass. https://leettube.dev/api/video/isomorphic-strings/video.mp4 99 2026-10-07T21:16:59.042Z 2026-10-07T21:16:59.042Z monthly 0.8 https://leettube.dev/watch/valid-palindrome Valid Palindrome (LeetCode 125) https://leettube.dev/posters/valid-palindrome.webp Check if a phrase reads the same both ways, ignoring case and punctuation. Walk in from both ends, skip the junk, and compare letters. https://leettube.dev/api/video/valid-palindrome/video.mp4 93 2026-10-07T21:19:57.357Z 2026-10-07T21:19:57.357Z monthly 0.8 https://leettube.dev/watch/roman-to-integer Roman to Integer (LeetCode 13) https://leettube.dev/posters/roman-to-integer.webp Turn a Roman numeral into a number. Look up each letter's value and add it, unless the next letter is bigger, then subtract it. https://leettube.dev/api/video/roman-to-integer/video.mp4 109 2026-10-07T21:19:06.342Z 2026-10-07T21:19:06.342Z monthly 0.8 https://leettube.dev/watch/intro-arrays Arrays tutorial https://leettube.dev/posters/intro-arrays.webp Walk the array once with a little state instead of restarting everywhere: two pointers closing in from the ends, or a window that grows on the right and shrinks on the left. https://leettube.dev/api/video/intro-arrays/video.mp4 43 2026-10-07T21:16:43.793Z 2026-10-07T21:16:43.793Z monthly 0.8 https://leettube.dev/watch/best-time-to-buy-stock Best Time to Buy and Sell Stock (LeetCode 121) https://leettube.dev/posters/best-time-to-buy-stock.webp Buy one day, sell on a later day, for the biggest profit. Walk the prices once, remembering the cheapest day so far. https://leettube.dev/api/video/best-time-to-buy-stock/video.mp4 92 2026-10-07T21:15:05.008Z 2026-10-07T21:15:05.008Z monthly 0.8 https://leettube.dev/watch/merge-intervals Merge Intervals (LeetCode 56) https://leettube.dev/posters/merge-intervals.webp Merge every overlapping interval. Sort by start, then either extend the last merged interval or start a new one. https://leettube.dev/api/video/merge-intervals/video.mp4 99 2026-10-07T21:17:42.274Z 2026-10-07T21:17:42.274Z monthly 0.8 https://leettube.dev/watch/group-anagrams Group Anagrams (LeetCode 49) https://leettube.dev/posters/group-anagrams.webp Group words that are anagrams of each other. Sort each word's letters into a key, then file every word under its key in a hash map. https://leettube.dev/api/video/group-anagrams/video.mp4 94 2026-10-07T21:16:27.415Z 2026-10-07T21:16:27.415Z monthly 0.8 https://leettube.dev/watch/top-k-frequent Top K Frequent (LeetCode 347) https://leettube.dev/posters/top-k-frequent.webp Find the k values that appear most often. Tally them in a map, then keep a k-spot leaderboard in a min-heap instead of sorting everything. https://leettube.dev/api/video/top-k-frequent/video.mp4 92 2026-10-07T21:19:47.096Z 2026-10-07T21:19:47.096Z monthly 0.8 https://leettube.dev/watch/longest-consecutive-sequence Longest Consecutive Sequence (LeetCode 128) https://leettube.dev/posters/longest-consecutive-sequence.webp Find the longest run of consecutive numbers in an unsorted list. Put them in a set, and only count up from numbers with no left neighbour. https://leettube.dev/api/video/longest-consecutive-sequence/video.mp4 95 2026-10-07T21:17:23.431Z 2026-10-07T21:17:23.431Z monthly 0.8 https://leettube.dev/watch/longest-substring Longest Substring (LeetCode 3) https://leettube.dev/posters/longest-substring.webp Find the longest run of characters with no repeats. Slide a window along the string, and when a letter repeats, jump the left edge past its last copy. https://leettube.dev/api/video/longest-substring/video.mp4 95 2026-10-07T21:17:28.215Z 2026-10-07T21:17:28.215Z monthly 0.8 https://leettube.dev/watch/minimum-window-substring Minimum Window Substring (LeetCode 76) https://leettube.dev/posters/minimum-window-substring.webp Find the shortest stretch of s holding every letter of t. Grow the window right until it's complete, then shrink from the left while it stays so. https://leettube.dev/api/video/minimum-window-substring/video.mp4 102 2026-10-07T21:17:58.196Z 2026-10-07T21:17:58.196Z monthly 0.8 https://leettube.dev/watch/sliding-window-maximum Sliding Window Maximum (LeetCode 239) https://leettube.dev/posters/sliding-window-maximum.webp Report the biggest number in every window of k as it slides. Keep a deque of shrinking values, so the front is always the max. https://leettube.dev/api/video/sliding-window-maximum/video.mp4 97 2026-10-07T21:19:22.049Z 2026-10-07T21:19:22.049Z monthly 0.8 https://leettube.dev/watch/subarray-sum-equals-k Subarray Sum Equals K (LeetCode 560) https://leettube.dev/posters/subarray-sum-equals-k.webp Count the stretches of numbers that add up to k, negatives included. Keep a running total and a tally of totals seen, and look up the one that's k behind. https://leettube.dev/api/video/subarray-sum-equals-k/video.mp4 95 2026-10-07T21:19:29.626Z 2026-10-07T21:19:29.626Z monthly 0.8 https://leettube.dev/watch/product-except-self Product of Array Except Self (LeetCode 238) https://leettube.dev/posters/product-except-self.webp Each spot gets the product of every other number, without division. Multiply everything to its left by everything to its right in two passes. https://leettube.dev/api/video/product-except-self/video.mp4 102 2026-10-07T21:18:43.211Z 2026-10-07T21:18:43.211Z monthly 0.8 https://leettube.dev/watch/first-missing-positive First Missing Positive (LeetCode 41) https://leettube.dev/posters/first-missing-positive.webp Find the smallest missing positive in O(n) time and O(1) space: swap each value into its own seat, then the first wrong seat is the answer. https://leettube.dev/api/video/first-missing-positive/video.mp4 97 2026-10-07T21:16:21.774Z 2026-10-07T21:16:21.774Z monthly 0.8 https://leettube.dev/watch/3sum 3Sum (LeetCode 15) https://leettube.dev/posters/3sum.webp Find every triple that sums to zero, with no repeats. Sort, fix one number, then close in from both ends with two pointers. https://leettube.dev/api/video/3sum/video.mp4 105 2026-10-07T21:14:57.258Z 2026-10-07T21:14:57.258Z monthly 0.8 https://leettube.dev/watch/container-with-most-water Container With Most Water (LeetCode 11) https://leettube.dev/posters/container-with-most-water.webp Pick two walls that hold the most water. Start at both ends and always move the shorter wall inward, since it caps the area. https://leettube.dev/api/video/container-with-most-water/video.mp4 102 2026-10-07T21:15:42.148Z 2026-10-07T21:15:42.148Z monthly 0.8 https://leettube.dev/watch/sort-colors Sort Colors (LeetCode 75) https://leettube.dev/posters/sort-colors.webp Sort an array of 0s, 1s and 2s in one pass: three pointers sweep zeros to the front and twos to the back, leaving ones in the middle. https://leettube.dev/api/video/sort-colors/video.mp4 103 2026-10-07T21:19:25.565Z 2026-10-07T21:19:25.565Z monthly 0.8 https://leettube.dev/watch/evaluate-reverse-polish-notation Evaluate Reverse Polish Notation (LeetCode 150) https://leettube.dev/posters/evaluate-reverse-polish-notation.webp Work out an expression written with operators after their numbers. Push each number on a stack; each operator pops two and pushes the result. https://leettube.dev/api/video/evaluate-reverse-polish-notation/video.mp4 116 2026-10-07T21:16:16.341Z 2026-10-07T21:16:16.341Z monthly 0.8 https://leettube.dev/watch/daily-temperatures Daily Temperatures (LeetCode 739) https://leettube.dev/posters/daily-temperatures.webp For each day, count the wait until a warmer one. Keep a stack of days still waiting; a warm day pops every colder day below it. https://leettube.dev/api/video/daily-temperatures/video.mp4 108 2026-10-07T21:15:55.845Z 2026-10-07T21:15:55.845Z monthly 0.8 https://leettube.dev/watch/trapping-rain-water Trapping Rain Water (LeetCode 42) https://leettube.dev/posters/trapping-rain-water.webp How much rain pools between the bars? Walk in from both ends, always moving the side with the lower wall, whose water is already decided. https://leettube.dev/api/video/trapping-rain-water/video.mp4 95 2026-10-07T21:19:48.795Z 2026-10-07T21:19:48.795Z monthly 0.8 https://leettube.dev/watch/largest-rectangle Largest Rectangle in Histogram (LeetCode 84) https://leettube.dev/posters/largest-rectangle.webp The biggest rectangle under a histogram. Keep a stack of rising bars, and when a shorter bar arrives, pop and measure each taller one. https://leettube.dev/api/video/largest-rectangle/video.mp4 95 2026-10-07T21:17:09.193Z 2026-10-07T21:17:09.193Z monthly 0.8 https://leettube.dev/watch/search-a-2d-matrix Search a 2D Matrix (LeetCode 74) https://leettube.dev/posters/search-a-2d-matrix.webp Each row is sorted and starts above the last row's end, so the grid is one sorted list in disguise: binary search it with row and column math. https://leettube.dev/api/video/search-a-2d-matrix/video.mp4 112 2026-10-07T21:19:13.457Z 2026-10-07T21:19:13.457Z monthly 0.8 https://leettube.dev/watch/search-in-rotated-sorted-array Search in Rotated Sorted Array (LeetCode 33) https://leettube.dev/posters/search-in-rotated-sorted-array.webp A sorted list was rotated, yet binary search still works: one half is always in order, so check if the target sits there and drop the other. https://leettube.dev/api/video/search-in-rotated-sorted-array/video.mp4 95 2026-10-07T21:19:14.918Z 2026-10-07T21:19:14.918Z monthly 0.8 https://leettube.dev/watch/median-of-two-sorted-arrays Median of Two Sorted Arrays (LeetCode 4) https://leettube.dev/posters/median-of-two-sorted-arrays.webp Find the median of two sorted arrays in log time. Binary search a cut in the shorter one so the two left parts together hold the smaller half. https://leettube.dev/api/video/median-of-two-sorted-arrays/video.mp4 104 2026-10-07T21:17:40.761Z 2026-10-07T21:17:40.761Z monthly 0.8 https://leettube.dev/watch/intro-trees Trees tutorial https://leettube.dev/posters/intro-trees.webp Trust each child to answer, then combine the answers at the node. A missing child is the base case, and three lines of code solve most tree problems. https://leettube.dev/api/video/intro-trees/video.mp4 45 2026-10-07T21:16:53.225Z 2026-10-07T21:16:53.225Z monthly 0.8 https://leettube.dev/watch/invert-binary-tree Invert Binary Tree (LeetCode 226) https://leettube.dev/posters/invert-binary-tree.webp Mirror a binary tree. Swap a node's two children, then do the same to each child, all the way down. https://leettube.dev/api/video/invert-binary-tree/video.mp4 88 2026-10-07T21:16:56.090Z 2026-10-07T21:16:56.090Z monthly 0.8 https://leettube.dev/watch/maximum-depth Maximum Depth of Binary Tree (LeetCode 104) https://leettube.dev/posters/maximum-depth.webp How deep does a binary tree go? Ask each child for its depth, take the bigger one and add one for yourself. https://leettube.dev/api/video/maximum-depth/video.mp4 89 2026-10-07T21:17:35.313Z 2026-10-07T21:17:35.313Z monthly 0.8 https://leettube.dev/watch/same-tree Same Tree (LeetCode 100) https://leettube.dev/posters/same-tree.webp Are two binary trees identical? Compare the two roots, then trust recursion to compare the left pair and the right pair. A mismatch anywhere ends it. https://leettube.dev/api/video/same-tree/video.mp4 102 2026-10-07T21:19:11.610Z 2026-10-07T21:19:11.610Z monthly 0.8 https://leettube.dev/watch/symmetric-tree Symmetric Tree (LeetCode 101) https://leettube.dev/posters/symmetric-tree.webp Is a binary tree its own mirror? Compare the left and right subtrees in pairs: outer with outer, inner with inner, all the way down. https://leettube.dev/api/video/symmetric-tree/video.mp4 95 2026-10-07T21:19:42.823Z 2026-10-07T21:19:42.823Z monthly 0.8 https://leettube.dev/watch/diameter-of-binary-tree Diameter of Binary Tree (LeetCode 543) https://leettube.dev/posters/diameter-of-binary-tree.webp Find the longest path between any two nodes. Each node asks its children for their heights, and the path bending through it is left plus right. https://leettube.dev/api/video/diameter-of-binary-tree/video.mp4 100 2026-10-07T21:16:09.938Z 2026-10-07T21:16:09.938Z monthly 0.8 https://leettube.dev/watch/balanced-binary-tree Balanced Binary Tree (LeetCode 110) https://leettube.dev/posters/balanced-binary-tree.webp Is every node's left and right height within one? Return each subtree's height from the bottom up, and a -1 the moment any node is lopsided. https://leettube.dev/api/video/balanced-binary-tree/video.mp4 99 2026-10-07T21:15:00.079Z 2026-10-07T21:15:00.079Z monthly 0.8 https://leettube.dev/watch/subtree-of-another-tree Subtree of Another Tree (LeetCode 572) https://leettube.dev/posters/subtree-of-another-tree.webp Check if one binary tree appears inside another. Try every node as a starting point and run a same-tree check from there. https://leettube.dev/api/video/subtree-of-another-tree/video.mp4 99 2026-10-07T21:19:34.230Z 2026-10-07T21:19:34.230Z monthly 0.8 https://leettube.dev/watch/level-order-traversal Level Order Traversal (LeetCode 102) https://leettube.dev/posters/level-order-traversal.webp Read a binary tree one level at a time. Keep a queue, and each round empty exactly the nodes that were in it when the round began. https://leettube.dev/api/video/level-order-traversal/video.mp4 90 2026-10-07T21:17:14.505Z 2026-10-07T21:17:14.505Z monthly 0.8 https://leettube.dev/watch/binary-tree-right-side-view Binary Tree Right Side View (LeetCode 199) https://leettube.dev/posters/binary-tree-right-side-view.webp List the nodes you'd see standing to the right of a binary tree. Walk it level by level and keep the last node on each level. https://leettube.dev/api/video/binary-tree-right-side-view/video.mp4 93 2026-10-07T21:15:15.437Z 2026-10-07T21:15:15.437Z monthly 0.8 https://leettube.dev/watch/validate-bst Validate BST (LeetCode 98) https://leettube.dev/posters/validate-bst.webp Is this a valid binary search tree? Checking each parent and child isn't enough; pass down the lowest and highest values each subtree is allowed. https://leettube.dev/api/video/validate-bst/video.mp4 98 2026-10-07T21:20:02.225Z 2026-10-07T21:20:02.225Z monthly 0.8 https://leettube.dev/watch/convert-sorted-array-to-binary-search-tree Convert Sorted Array to Binary Search Tree (LeetCode 108) https://leettube.dev/posters/convert-sorted-array-to-binary-search-tree.webp Turn a sorted array into a height-balanced BST. The middle value becomes the root, and each half recursively builds its own subtree. https://leettube.dev/api/video/convert-sorted-array-to-binary-search-tree/video.mp4 97 2026-10-07T21:15:45.191Z 2026-10-07T21:15:45.191Z monthly 0.8 https://leettube.dev/watch/kth-smallest-in-bst Kth Smallest Element in a BST (LeetCode 230) https://leettube.dev/posters/kth-smallest-in-bst.webp Find the kth smallest value in a BST. An inorder walk visits values in sorted order, so stop at the kth node you reach. https://leettube.dev/api/video/kth-smallest-in-bst/video.mp4 98 2026-10-07T21:17:07.837Z 2026-10-07T21:17:07.837Z monthly 0.8 https://leettube.dev/watch/lowest-common-ancestor Lowest Common Ancestor (LeetCode 236) https://leettube.dev/posters/lowest-common-ancestor.webp Find the deepest node above two targets in one pass: each node reports what it found, and the node where both sides answer wins. https://leettube.dev/api/video/lowest-common-ancestor/video.mp4 94 2026-10-07T21:17:31.968Z 2026-10-07T21:17:31.968Z monthly 0.8 https://leettube.dev/watch/construct-binary-tree-from-preorder-and-inorder Construct Binary Tree from Preorder and Inorder Traversal (LeetCode 105) https://leettube.dev/posters/construct-binary-tree-from-preorder-and-inorder.webp Rebuild a tree from two traversals. Preorder names each root; its spot in inorder splits the left and right subtrees. https://leettube.dev/api/video/construct-binary-tree-from-preorder-and-inorder/video.mp4 107 2026-10-07T21:15:40.737Z 2026-10-07T21:15:40.737Z monthly 0.8 https://leettube.dev/watch/implement-trie Implement Trie (LeetCode 208) https://leettube.dev/posters/implement-trie.webp Insert words, search them and check prefixes. A tree of letters lets words that share a prefix share a path. https://leettube.dev/api/video/implement-trie/video.mp4 93 2026-10-07T21:16:38.269Z 2026-10-07T21:16:38.269Z monthly 0.8 https://leettube.dev/watch/binary-tree-maximum-path-sum Binary Tree Maximum Path Sum (LeetCode 124) https://leettube.dev/posters/binary-tree-maximum-path-sum.webp Find the best path anywhere in a tree. Each node reports its best one-sided branch upward and checks the path that bends through it. https://leettube.dev/api/video/binary-tree-maximum-path-sum/video.mp4 103 2026-10-07T21:15:13.256Z 2026-10-07T21:15:13.256Z monthly 0.8 https://leettube.dev/watch/binary-tree-cameras Binary Tree Cameras (LeetCode 968) https://leettube.dev/posters/binary-tree-cameras.webp Fewest cameras to watch every node: work up from the leaves with three states, put a camera on any parent of an unwatched child. https://leettube.dev/api/video/binary-tree-cameras/video.mp4 97 2026-10-07T21:15:11.114Z 2026-10-07T21:15:11.114Z monthly 0.8 https://leettube.dev/watch/serialize-and-deserialize-binary-tree Serialize and Deserialize Binary Tree (LeetCode 297) https://leettube.dev/posters/serialize-and-deserialize-binary-tree.webp Turn a binary tree into a string and back. Write it in preorder with a marker for every missing child, then read it back the same way. https://leettube.dev/api/video/serialize-and-deserialize-binary-tree/video.mp4 103 2026-10-07T21:19:16.323Z 2026-10-07T21:19:16.323Z monthly 0.8 https://leettube.dev/watch/intro-backtracking Backtracking tutorial https://leettube.dev/posters/intro-backtracking.webp Build an answer one choice at a time and undo the ones that lead nowhere: choose, recurse, then un-choose so the next choice starts clean. https://leettube.dev/api/video/intro-backtracking/video.mp4 45 2026-10-07T21:16:45.049Z 2026-10-07T21:16:45.049Z monthly 0.8 https://leettube.dev/watch/subsets Subsets (LeetCode 78) https://leettube.dev/posters/subsets.webp List every subset of a set of distinct numbers, empty one included. For each number, branch on taking it or leaving it. https://leettube.dev/api/video/subsets/video.mp4 97 2026-10-07T21:19:32.631Z 2026-10-07T21:19:32.631Z monthly 0.8 https://leettube.dev/watch/subsets-ii Subsets II (LeetCode 90) https://leettube.dev/posters/subsets-ii.webp List every subset of a list that has duplicates, with no repeats. Sort first, then skip a value already tried at the same depth. https://leettube.dev/api/video/subsets-ii/video.mp4 100 2026-10-07T21:19:31.143Z 2026-10-07T21:19:31.143Z monthly 0.8 https://leettube.dev/watch/combinations Combinations (LeetCode 77) https://leettube.dev/posters/combinations.webp Every way to choose k numbers from 1 to n. Pick the next number only from those after the last pick, recurse, then undo the pick and try the next. https://leettube.dev/api/video/combinations/video.mp4 102 2026-10-07T21:15:39.281Z 2026-10-07T21:15:39.281Z monthly 0.8 https://leettube.dev/watch/generate-parentheses Generate Parentheses (LeetCode 22) https://leettube.dev/posters/generate-parentheses.webp List every balanced string of n pairs of parentheses. Add an opener while you have one left, and a closer only when it has a match. https://leettube.dev/api/video/generate-parentheses/video.mp4 99 2026-10-07T21:16:26.040Z 2026-10-07T21:16:26.040Z monthly 0.8 https://leettube.dev/watch/letter-combinations Letter Combinations (LeetCode 17) https://leettube.dev/posters/letter-combinations.webp Spell every word a phone number could make. Fill one position at a time from its key, recurse for the rest, then pop and try the next letter. https://leettube.dev/api/video/letter-combinations/video.mp4 100 2026-10-07T21:17:12.903Z 2026-10-07T21:17:12.903Z monthly 0.8 https://leettube.dev/watch/permutations Permutations (LeetCode 46) https://leettube.dev/posters/permutations.webp List every order of a set of numbers. Fill one seat at a time with a number you haven't used, recurse, then take it back and try the next. https://leettube.dev/api/video/permutations/video.mp4 96 2026-10-07T21:18:38.058Z 2026-10-07T21:18:38.058Z monthly 0.8 https://leettube.dev/watch/permutations-ii Permutations II (LeetCode 47) https://leettube.dev/posters/permutations-ii.webp Every distinct ordering of numbers that may repeat. Sort first, then skip a copy whenever its twin to the left is still unused in this branch. https://leettube.dev/api/video/permutations-ii/video.mp4 104 2026-10-07T21:18:36.438Z 2026-10-07T21:18:36.438Z monthly 0.8 https://leettube.dev/watch/combination-sum Combination Sum (LeetCode 39) https://leettube.dev/posters/combination-sum.webp Find every combination that adds up to the target, reusing numbers as often as you like. Recurse with a start index so each combination appears once. https://leettube.dev/api/video/combination-sum/video.mp4 102 2026-10-07T21:15:37.930Z 2026-10-07T21:15:37.930Z monthly 0.8 https://leettube.dev/watch/combination-sum-ii Combination Sum II (LeetCode 40) https://leettube.dev/posters/combination-sum-ii.webp Find every combination that sums to a target, using each number once. Sort, skip repeats at the same depth, and stop once numbers get too big. https://leettube.dev/api/video/combination-sum-ii/video.mp4 112 2026-10-07T21:15:34.893Z 2026-10-07T21:15:34.893Z monthly 0.8 https://leettube.dev/watch/combination-sum-iii Combination Sum III (LeetCode 216) https://leettube.dev/posters/combination-sum-iii.webp Every set of k distinct digits from 1 to 9 that sums to n: pick in increasing order, track what's left, and stop once a digit is too big. https://leettube.dev/api/video/combination-sum-iii/video.mp4 95 2026-10-07T21:15:36.460Z 2026-10-07T21:15:36.460Z monthly 0.8 https://leettube.dev/watch/partition-to-k-equal-sum-subsets Partition to K Equal Sum Subsets (LeetCode 698) https://leettube.dev/posters/partition-to-k-equal-sum-subsets.webp Split numbers into k groups with equal sums: find the target, place the biggest numbers first, and skip buckets that repeat a sum. https://leettube.dev/api/video/partition-to-k-equal-sum-subsets/video.mp4 99 2026-10-07T21:18:30.357Z 2026-10-07T21:18:30.357Z monthly 0.8 https://leettube.dev/watch/palindrome-partitioning Palindrome Partitioning (LeetCode 131) https://leettube.dev/posters/palindrome-partitioning.webp Split a string into palindromes every possible way. Cut off a palindrome prefix, recurse on the rest, then undo the cut and try a longer one. https://leettube.dev/api/video/palindrome-partitioning/video.mp4 105 2026-10-07T21:18:24.102Z 2026-10-07T21:18:24.102Z monthly 0.8 https://leettube.dev/watch/restore-ip-addresses Restore IP Addresses (LeetCode 93) https://leettube.dev/posters/restore-ip-addresses.webp Split a digit string into four valid IP parts: try a 1, 2 or 3 digit chunk, recurse, and back up when a part tops 255 or has a leading zero. https://leettube.dev/api/video/restore-ip-addresses/video.mp4 101 2026-10-07T21:18:59.506Z 2026-10-07T21:18:59.506Z monthly 0.8 https://leettube.dev/watch/word-search Word Search (LeetCode 79) https://leettube.dev/posters/word-search.webp Can you spell a word through neighbouring letters in a grid? Try each path, mark the cells you use, and unmark them when you back out. https://leettube.dev/api/video/word-search/video.mp4 103 2026-10-07T21:20:09.316Z 2026-10-07T21:20:09.316Z monthly 0.8 https://leettube.dev/watch/word-search-ii Word Search II (LeetCode 212) https://leettube.dev/posters/word-search-ii.webp Find every word from a list on a letter grid. Build a trie of the words and walk the board once, following only paths the trie allows. https://leettube.dev/api/video/word-search-ii/video.mp4 98 2026-10-07T21:20:07.671Z 2026-10-07T21:20:07.671Z monthly 0.8 https://leettube.dev/watch/n-queens N-Queens (LeetCode 51) https://leettube.dev/posters/n-queens.webp Place n queens so none can attack another. Go row by row, track the columns and both diagonals in use, and back up at dead ends. https://leettube.dev/api/video/n-queens/video.mp4 100 2026-10-07T21:18:05.456Z 2026-10-07T21:18:05.456Z monthly 0.8 https://leettube.dev/watch/n-queens-ii N-Queens II (LeetCode 52) https://leettube.dev/posters/n-queens-ii.webp Count the ways to place n queens with no attacks: one queen per row, three sets for columns and diagonals, undo and try the next. https://leettube.dev/api/video/n-queens-ii/video.mp4 96 2026-10-07T21:18:03.944Z 2026-10-07T21:18:03.944Z monthly 0.8 https://leettube.dev/watch/sudoku-solver Sudoku Solver (LeetCode 37) https://leettube.dev/posters/sudoku-solver.webp Fill a Sudoku grid so every row, column and box holds 1 to 9. Try a digit, keep going while it fits, and undo it when you hit a dead end. https://leettube.dev/api/video/sudoku-solver/video.mp4 101 2026-10-07T21:19:36.415Z 2026-10-07T21:19:36.415Z monthly 0.8 https://leettube.dev/watch/intro-dynamic-programming Dynamic programming tutorial https://leettube.dev/posters/intro-dynamic-programming.webp Never solve the same problem twice. Save each answer as you recurse, or fill a table from the smallest case up. https://leettube.dev/api/video/intro-dynamic-programming/video.mp4 44 2026-10-07T21:16:48.481Z 2026-10-07T21:16:48.481Z monthly 0.8 https://leettube.dev/watch/climbing-stairs Climbing Stairs (LeetCode 70) https://leettube.dev/posters/climbing-stairs.webp Count the ways up a staircase taking one or two steps at a time. Each stair's count is the sum of the two below it, so climb once and keep just two numbers. https://leettube.dev/api/video/climbing-stairs/video.mp4 85 2026-10-07T21:15:28.438Z 2026-10-07T21:15:28.438Z monthly 0.8 https://leettube.dev/watch/house-robber House Robber (LeetCode 198) https://leettube.dev/posters/house-robber.webp Rob the most cash from a row of houses without hitting two neighbours. Carry the best haul so far, one house at a time. https://leettube.dev/api/video/house-robber/video.mp4 85 2026-10-07T21:16:35.140Z 2026-10-07T21:16:35.140Z monthly 0.8 https://leettube.dev/watch/house-robber-ii House Robber II (LeetCode 213) https://leettube.dev/posters/house-robber-ii.webp Rob houses in a circle without hitting two neighbours. The first and last touch, so run House Robber twice: once without each end. https://leettube.dev/api/video/house-robber-ii/video.mp4 95 2026-10-07T21:16:33.486Z 2026-10-07T21:16:33.486Z monthly 0.8 https://leettube.dev/watch/maximum-product-subarray Maximum Product Subarray (LeetCode 152) https://leettube.dev/posters/maximum-product-subarray.webp Largest product of a contiguous run: track the high and the low at each step, because a negative number swaps them. https://leettube.dev/api/video/maximum-product-subarray/video.mp4 101 2026-10-07T21:17:36.856Z 2026-10-07T21:17:36.856Z monthly 0.8 https://leettube.dev/watch/best-time-to-buy-and-sell-stock-with-cooldown Best Time to Buy and Sell Stock with Cooldown (LeetCode 309) https://leettube.dev/posters/best-time-to-buy-and-sell-stock-with-cooldown.webp Max profit when every sale forces a one-day rest: track three states each day (holding, just sold, resting) and step them forward together. https://leettube.dev/api/video/best-time-to-buy-and-sell-stock-with-cooldown/video.mp4 102 2026-10-07T21:15:01.842Z 2026-10-07T21:15:01.842Z monthly 0.8 https://leettube.dev/watch/best-time-to-buy-and-sell-stock-with-transaction-fee Best Time to Buy and Sell Stock with Transaction Fee (LeetCode 714) https://leettube.dev/posters/best-time-to-buy-and-sell-stock-with-transaction-fee.webp Trade as often as you like, but every sale costs a fee. Track two states, cash and holding, and update both each day in one pass. https://leettube.dev/api/video/best-time-to-buy-and-sell-stock-with-transaction-fee/video.mp4 106 2026-10-07T21:15:03.387Z 2026-10-07T21:15:03.387Z monthly 0.8 https://leettube.dev/watch/decode-ways Decode Ways (LeetCode 91) https://leettube.dev/posters/decode-ways.webp Count the ways a string of digits can decode into letters. Each digit can stand alone or pair with the one before it, like climbing stairs. https://leettube.dev/api/video/decode-ways/video.mp4 100 2026-10-07T21:15:57.433Z 2026-10-07T21:15:57.433Z monthly 0.8 https://leettube.dev/watch/palindromic-substrings Palindromic Substrings (LeetCode 647) https://leettube.dev/posters/palindromic-substrings.webp Count every palindrome hiding in a string. Pick each centre, letter or gap, and expand outward while both ends match, one count per step. https://leettube.dev/api/video/palindromic-substrings/video.mp4 110 2026-10-07T21:18:25.624Z 2026-10-07T21:18:25.624Z monthly 0.8 https://leettube.dev/watch/unique-paths Unique Paths (LeetCode 62) https://leettube.dev/posters/unique-paths.webp Count a robot's routes across a grid moving only right or down. Each cell's count is the cell above plus the cell to the left. https://leettube.dev/api/video/unique-paths/video.mp4 97 2026-10-07T21:19:53.030Z 2026-10-07T21:19:53.030Z monthly 0.8 https://leettube.dev/watch/coin-change Coin Change (LeetCode 322) https://leettube.dev/posters/coin-change.webp The fewest coins that add up to an amount. Greedy fails, so build up from zero, reusing the best answer for each smaller amount. https://leettube.dev/api/video/coin-change/video.mp4 97 2026-10-07T21:15:32.138Z 2026-10-07T21:15:32.138Z monthly 0.8 https://leettube.dev/watch/perfect-squares Perfect Squares (LeetCode 279) https://leettube.dev/posters/perfect-squares.webp Fewest squares that sum to n: build a table up from zero, trying every square that fits. It's Coin Change with squares as coins. https://leettube.dev/api/video/perfect-squares/video.mp4 100 2026-10-07T21:18:34.323Z 2026-10-07T21:18:34.323Z monthly 0.8 https://leettube.dev/watch/partition-equal-subset-sum Partition Equal Subset Sum (LeetCode 416) https://leettube.dev/posters/partition-equal-subset-sum.webp Split the numbers into two equal-sum halves. Track which sums up to half the total are reachable, adding one number at a time, right to left. https://leettube.dev/api/video/partition-equal-subset-sum/video.mp4 101 2026-10-07T21:18:27.058Z 2026-10-07T21:18:27.058Z monthly 0.8 https://leettube.dev/watch/word-break Word Break (LeetCode 139) https://leettube.dev/posters/word-break.webp Can a string be split into dictionary words? Mark each position you can reach, building on earlier marks, until you reach the end. https://leettube.dev/api/video/word-break/video.mp4 97 2026-10-07T21:20:04.115Z 2026-10-07T21:20:04.115Z monthly 0.8 https://leettube.dev/watch/longest-increasing-subsequence Longest Increasing Subsequence (LeetCode 300) https://leettube.dev/posters/longest-increasing-subsequence.webp Find the longest strictly rising run you can pick out of a list, skipping but never reordering. Build the answer for each ending number from the ones before it, then a bonus O(n log n) trick. https://leettube.dev/api/video/longest-increasing-subsequence/video.mp4 100 2026-10-07T21:17:26.700Z 2026-10-07T21:17:26.700Z monthly 0.8 https://leettube.dev/watch/longest-common-subsequence Longest Common Subsequence (LeetCode 1143) https://leettube.dev/posters/longest-common-subsequence.webp Find the longest sequence two strings share in order. Fill a grid: matching letters extend the diagonal, otherwise take the better neighbour. https://leettube.dev/api/video/longest-common-subsequence/video.mp4 103 2026-10-07T21:17:21.632Z 2026-10-07T21:17:21.632Z monthly 0.8 https://leettube.dev/watch/distinct-subsequences Distinct Subsequences (LeetCode 115) https://leettube.dev/posters/distinct-subsequences.webp Count the ways to pick letters of s, in order, that spell t: each letter is skipped or used, and a table adds up both choices. https://leettube.dev/api/video/distinct-subsequences/video.mp4 94 2026-10-07T21:16:12.155Z 2026-10-07T21:16:12.155Z monthly 0.8 https://leettube.dev/watch/maximum-profit-in-job-scheduling Maximum Profit in Job Scheduling (LeetCode 1235) https://leettube.dev/posters/maximum-profit-in-job-scheduling.webp Pick non-overlapping jobs for the most profit: sort by end time, then each job either skips or adds to the best plan a binary search finds. https://leettube.dev/api/video/maximum-profit-in-job-scheduling/video.mp4 101 2026-10-07T21:17:38.314Z 2026-10-07T21:17:38.314Z monthly 0.8 https://leettube.dev/watch/edit-distance Edit Distance (LeetCode 72) https://leettube.dev/posters/edit-distance.webp The fewest inserts, deletes and replaces to turn one word into another. Fill a table where each cell takes the cheapest of three neighbours. https://leettube.dev/api/video/edit-distance/video.mp4 98 2026-10-07T21:16:14.327Z 2026-10-07T21:16:14.327Z monthly 0.8 https://leettube.dev/watch/regular-expression-matching Regular Expression Matching (LeetCode 10) https://leettube.dev/posters/regular-expression-matching.webp Match a string against a pattern with . and *. A grid of smaller answers decides each cell: a star can match zero copies or eat one more character. https://leettube.dev/api/video/regular-expression-matching/video.mp4 100 2026-10-07T21:18:51.052Z 2026-10-07T21:18:51.052Z monthly 0.8 https://leettube.dev/watch/longest-valid-parentheses Longest Valid Parentheses (LeetCode 32) https://leettube.dev/posters/longest-valid-parentheses.webp Find the longest well-formed run of brackets. Each ) extends the valid run ending just before its matching (, so one pass of stored lengths works. https://leettube.dev/api/video/longest-valid-parentheses/video.mp4 95 2026-10-07T21:17:30.065Z 2026-10-07T21:17:30.065Z monthly 0.8 https://leettube.dev/watch/intro-graphs Graphs tutorial https://leettube.dev/posters/intro-graphs.webp Nodes and edges: explore outward from a start with a queue (breadth first) or a stack (depth first), stamping each node so you never loop. https://leettube.dev/api/video/intro-graphs/video.mp4 47 2026-10-07T21:16:50.510Z 2026-10-07T21:16:50.510Z monthly 0.8 https://leettube.dev/watch/number-of-islands Number of Islands (LeetCode 200) https://leettube.dev/posters/number-of-islands.webp Count the islands in a grid of land and water. Scan for land, and sink each island you find so it's only counted once. https://leettube.dev/api/video/number-of-islands/video.mp4 99 2026-10-07T21:18:14.037Z 2026-10-07T21:18:14.037Z monthly 0.8 https://leettube.dev/watch/number-of-provinces Number of Provinces (LeetCode 547) https://leettube.dev/posters/number-of-provinces.webp Count groups of connected cities: pick an unvisited city, flood its whole province with a search, and count how many floods it takes. https://leettube.dev/api/video/number-of-provinces/video.mp4 94 2026-10-07T21:18:15.953Z 2026-10-07T21:18:15.953Z monthly 0.8 https://leettube.dev/watch/is-graph-bipartite Is Graph Bipartite? (LeetCode 785) https://leettube.dev/posters/is-graph-bipartite.webp Can every node get one of two colours so no edge joins a matching pair? Paint each component by BFS and stop at the first clash. https://leettube.dev/api/video/is-graph-bipartite/video.mp4 98 2026-10-07T21:16:57.508Z 2026-10-07T21:16:57.508Z monthly 0.8 https://leettube.dev/watch/rotting-oranges Rotting Oranges (LeetCode 994) https://leettube.dev/posters/rotting-oranges.webp How many minutes until every orange rots? Start a breadth-first search from all the rotten ones at once, one ring per minute. https://leettube.dev/api/video/rotting-oranges/video.mp4 100 2026-10-07T21:19:10.111Z 2026-10-07T21:19:10.111Z monthly 0.8 https://leettube.dev/watch/pacific-atlantic-water-flow Pacific Atlantic Water Flow (LeetCode 417) https://leettube.dev/posters/pacific-atlantic-water-flow.webp Which cells drain to both oceans? Flip the flow: flood uphill from each coastline, then keep the cells both tides reach. https://leettube.dev/api/video/pacific-atlantic-water-flow/video.mp4 93 2026-10-07T21:18:18.771Z 2026-10-07T21:18:18.771Z monthly 0.8 https://leettube.dev/watch/surrounded-regions Surrounded Regions (LeetCode 130) https://leettube.dev/posters/surrounded-regions.webp Capture every region of O cells walled in by X. Flood fill from the border to mark the O cells that escape; the rest get captured. https://leettube.dev/api/video/surrounded-regions/video.mp4 96 2026-10-07T21:19:39.062Z 2026-10-07T21:19:39.062Z monthly 0.8 https://leettube.dev/watch/longest-increasing-path-in-a-matrix Longest Increasing Path in a Matrix (LeetCode 329) https://leettube.dev/posters/longest-increasing-path-in-a-matrix.webp Find the longest strictly rising path in a grid. Depth-first search from each cell, and remember every answer so no cell is ever solved twice. https://leettube.dev/api/video/longest-increasing-path-in-a-matrix/video.mp4 106 2026-10-07T21:17:25.269Z 2026-10-07T21:17:25.269Z monthly 0.8 https://leettube.dev/watch/clone-graph Clone Graph (LeetCode 133) https://leettube.dev/posters/clone-graph.webp Deep-copy a whole graph from one node. Walk it with depth-first search, and keep a map from each original to its copy so cycles are cloned once. https://leettube.dev/api/video/clone-graph/video.mp4 94 2026-10-07T21:15:30.415Z 2026-10-07T21:15:30.415Z monthly 0.8 https://leettube.dev/watch/course-schedule Course Schedule (LeetCode 207) https://leettube.dev/posters/course-schedule.webp Decide whether you can finish every course given its prerequisites. Take courses with no locks left, and see if every course gets taken. https://leettube.dev/api/video/course-schedule/video.mp4 104 2026-10-07T21:15:52.213Z 2026-10-07T21:15:52.213Z monthly 0.8 https://leettube.dev/watch/course-schedule-ii Course Schedule II (LeetCode 210) https://leettube.dev/posters/course-schedule-ii.webp Return a valid order to take every course. Count each course's prerequisites, start with the ones at zero, and unlock the rest as you go. https://leettube.dev/api/video/course-schedule-ii/video.mp4 102 2026-10-07T21:15:48.988Z 2026-10-07T21:15:48.988Z monthly 0.8 https://leettube.dev/watch/network-delay-time Network Delay Time (LeetCode 743) https://leettube.dev/posters/network-delay-time.webp How long until a signal reaches every tower? Dijkstra's algorithm settles the earliest arrival first, using a min-heap. https://leettube.dev/api/video/network-delay-time/video.mp4 96 2026-10-07T21:18:08.326Z 2026-10-07T21:18:08.326Z monthly 0.8 https://leettube.dev/watch/path-with-minimum-effort Path With Minimum Effort (LeetCode 1631) https://leettube.dev/posters/path-with-minimum-effort.webp Cross the height map with the gentlest worst climb: Dijkstra where a path's cost is its biggest single step, not the total. https://leettube.dev/api/video/path-with-minimum-effort/video.mp4 103 2026-10-07T21:18:32.274Z 2026-10-07T21:18:32.274Z monthly 0.8 https://leettube.dev/watch/cheapest-flights-within-k-stops Cheapest Flights Within K Stops (LeetCode 787) https://leettube.dev/posters/cheapest-flights-within-k-stops.webp Find the cheapest fare with at most k stops. Relax every flight once per allowed hop, Bellman-Ford style, keeping last round's prices. https://leettube.dev/api/video/cheapest-flights-within-k-stops/video.mp4 106 2026-10-07T21:15:26.593Z 2026-10-07T21:15:26.593Z monthly 0.8 https://leettube.dev/watch/swim-in-rising-water Swim in Rising Water (LeetCode 778) https://leettube.dev/posters/swim-in-rising-water.webp Water rises one unit a minute; when can you swim from corner to corner? Dijkstra with a min-heap keyed on the tallest cell along the path. https://leettube.dev/api/video/swim-in-rising-water/video.mp4 92 2026-10-07T21:19:41.155Z 2026-10-07T21:19:41.155Z monthly 0.8 https://leettube.dev/watch/reconstruct-itinerary Reconstruct Itinerary (LeetCode 332) https://leettube.dev/posters/reconstruct-itinerary.webp Use every plane ticket once, starting at JFK, in alphabetical order. Depth-first search, then add each airport once its tickets run out. https://leettube.dev/api/video/reconstruct-itinerary/video.mp4 108 2026-10-07T21:18:47.610Z 2026-10-07T21:18:47.610Z monthly 0.8 https://leettube.dev/watch/redundant-connection Redundant Connection (LeetCode 684) https://leettube.dev/posters/redundant-connection.webp A tree got one extra edge that closes a loop. Join nodes with union-find; the first edge whose ends already share a root is the extra one. https://leettube.dev/api/video/redundant-connection/video.mp4 100 2026-10-07T21:18:49.109Z 2026-10-07T21:18:49.109Z monthly 0.8 https://leettube.dev/watch/critical-connections-in-a-network Critical Connections in a Network (LeetCode 1192) https://leettube.dev/posters/critical-connections-in-a-network.webp Find every link whose loss splits a network: one DFS stamps discovery times, carries low links up, and cuts where a child can't reach back. https://leettube.dev/api/video/critical-connections-in-a-network/video.mp4 94 2026-10-07T21:15:54.305Z 2026-10-07T21:15:54.305Z monthly 0.8 https://leettube.dev/watch/min-cost-to-connect-all-points Min Cost to Connect All Points (LeetCode 1584) https://leettube.dev/posters/min-cost-to-connect-all-points.webp Join every point with the least total Manhattan distance. Grow a minimum spanning tree with Prim's algorithm, cheapest link first. https://leettube.dev/api/video/min-cost-to-connect-all-points/video.mp4 95 2026-10-07T21:17:51.342Z 2026-10-07T21:17:51.342Z monthly 0.8 https://leettube.dev/watch/word-ladder Word Ladder (LeetCode 127) https://leettube.dev/posters/word-ladder.webp Change one letter at a time to reach the end word. Treat words as a graph and search breadth first, so the first hit is the shortest. https://leettube.dev/api/video/word-ladder/video.mp4 109 2026-10-07T21:20:06.219Z 2026-10-07T21:20:06.219Z monthly 0.8 https://leettube.dev/watch/intro-greedy Greedy tutorial https://leettube.dev/posters/intro-greedy.webp Take what looks best right now and never go back. It works only when today's best pick can't hurt you later, so learn to spot when it's safe. https://leettube.dev/api/video/intro-greedy/video.mp4 46 2026-10-07T21:16:51.763Z 2026-10-07T21:16:51.763Z monthly 0.8 https://leettube.dev/watch/can-place-flowers Can Place Flowers (LeetCode 605) https://leettube.dev/posters/can-place-flowers.webp Plant a flower wherever both neighbours are empty, scanning left to right. Planting early never hurts, so stop as soon as n fit. https://leettube.dev/api/video/can-place-flowers/video.mp4 95 2026-10-07T21:15:21.353Z 2026-10-07T21:15:21.353Z monthly 0.8 https://leettube.dev/watch/jump-game Jump Game (LeetCode 55) https://leettube.dev/posters/jump-game.webp Can you hop from the first index to the last? Walk once, keeping the farthest spot you can reach; if you ever stand past it, you're stuck. https://leettube.dev/api/video/jump-game/video.mp4 95 2026-10-07T21:17:02.703Z 2026-10-07T21:17:02.703Z monthly 0.8 https://leettube.dev/watch/jump-game-ii Jump Game II (LeetCode 45) https://leettube.dev/posters/jump-game-ii.webp Now count the fewest hops to the end. Treat each jump as a window of reachable spots, and only jump when you walk off its edge. https://leettube.dev/api/video/jump-game-ii/video.mp4 97 2026-10-07T21:17:00.792Z 2026-10-07T21:17:00.792Z monthly 0.8 https://leettube.dev/watch/gas-station Gas Station (LeetCode 134) https://leettube.dev/posters/gas-station.webp Find the station where you can drive the whole loop. If the total gas covers the total cost, an answer exists; whenever the tank goes negative, start again from the next station. https://leettube.dev/api/video/gas-station/video.mp4 104 2026-10-07T21:16:24.388Z 2026-10-07T21:16:24.388Z monthly 0.8 https://leettube.dev/watch/minimum-domino-rotations-for-equal-row Minimum Domino Rotations For Equal Row (LeetCode 1007) https://leettube.dev/posters/minimum-domino-rotations-for-equal-row.webp Fewest flips to make a domino row match: only the first domino's two values can work, so try each and keep the cheaper side. https://leettube.dev/api/video/minimum-domino-rotations-for-equal-row/video.mp4 98 2026-10-07T21:17:54.869Z 2026-10-07T21:17:54.869Z monthly 0.8 https://leettube.dev/watch/course-schedule-iii Course Schedule III (LeetCode 630) https://leettube.dev/posters/course-schedule-iii.webp Take the most courses before their deadlines: sort by deadline, keep a max-heap of durations, and drop the longest when time runs over. https://leettube.dev/api/video/course-schedule-iii/video.mp4 93 2026-10-07T21:15:50.869Z 2026-10-07T21:15:50.869Z monthly 0.8 https://leettube.dev/watch/car-pooling Car Pooling (LeetCode 1094) https://leettube.dev/posters/car-pooling.webp Can one car carry every trip without going over capacity? Mark pickups and drop-offs on a difference array, then sweep the running total. https://leettube.dev/api/video/car-pooling/video.mp4 99 2026-10-07T21:15:24.994Z 2026-10-07T21:15:24.994Z monthly 0.8 https://leettube.dev/watch/candy Candy (LeetCode 135) https://leettube.dev/posters/candy.webp Hand out the fewest candies so higher-rated kids beat their neighbours. Sweep left to right, then right to left, keeping the larger count. https://leettube.dev/api/video/candy/video.mp4 101 2026-10-07T21:15:23.280Z 2026-10-07T21:15:23.280Z monthly 0.8 https://leettube.dev/watch/non-overlapping-intervals Non-overlapping Intervals (LeetCode 435) https://leettube.dev/posters/non-overlapping-intervals.webp Remove the fewest intervals so the rest don't overlap. Sort by end time and keep whatever finishes first; every clash after that gets cut. https://leettube.dev/api/video/non-overlapping-intervals/video.mp4 98 2026-10-07T21:18:09.942Z 2026-10-07T21:18:09.942Z monthly 0.8 https://leettube.dev/watch/minimum-number-of-arrows-to-burst-balloons Minimum Number of Arrows to Burst Balloons (LeetCode 452) https://leettube.dev/posters/minimum-number-of-arrows-to-burst-balloons.webp Sort balloons by where they end and shoot each arrow at the earliest end. It pops every balloon still overlapping it, so you need the fewest. https://leettube.dev/api/video/minimum-number-of-arrows-to-burst-balloons/video.mp4 97 2026-10-07T21:17:56.463Z 2026-10-07T21:17:56.463Z monthly 0.8 https://leettube.dev/watch/partition-labels Partition Labels (LeetCode 763) https://leettube.dev/posters/partition-labels.webp Cut a string into as many pieces as possible with no letter in two pieces. Track where each letter last appears, and cut when you reach it. https://leettube.dev/api/video/partition-labels/video.mp4 92 2026-10-07T21:18:28.857Z 2026-10-07T21:18:28.857Z monthly 0.8 https://leettube.dev/watch/boats-to-save-people Boats to Save People (LeetCode 881) https://leettube.dev/posters/boats-to-save-people.webp Each boat holds two people under a weight limit. Sort, then pair the heaviest with the lightest when they fit; otherwise the heaviest rides alone. https://leettube.dev/api/video/boats-to-save-people/video.mp4 103 2026-10-07T21:15:19.396Z 2026-10-07T21:15:19.396Z monthly 0.8 https://leettube.dev/watch/remove-k-digits Remove K Digits (LeetCode 402) https://leettube.dev/posters/remove-k-digits.webp Delete k digits to make the smallest number. Keep a rising stack and pop any bigger digit before a smaller one while deletions remain. https://leettube.dev/api/video/remove-k-digits/video.mp4 101 2026-10-07T21:18:54.630Z 2026-10-07T21:18:54.630Z monthly 0.8 https://leettube.dev/watch/two-city-scheduling Two City Scheduling (LeetCode 1029) https://leettube.dev/posters/two-city-scheduling.webp Send 2n people to two cities at least cost: book everyone to B, sort by A minus B, and switch the cheapest half to A. https://leettube.dev/api/video/two-city-scheduling/video.mp4 96 2026-10-07T21:19:50.297Z 2026-10-07T21:19:50.297Z monthly 0.8 https://leettube.dev/watch/valid-parenthesis-string Valid Parenthesis String (LeetCode 678) https://leettube.dev/posters/valid-parenthesis-string.webp Check brackets where each star can be open, close or nothing. Track the lowest and highest possible open count instead of choosing. https://leettube.dev/api/video/valid-parenthesis-string/video.mp4 103 2026-10-07T21:20:00.873Z 2026-10-07T21:20:00.873Z monthly 0.8 https://leettube.dev/watch/maximum-subarray Maximum Subarray (LeetCode 53) https://leettube.dev/posters/maximum-subarray.webp Find the stretch of numbers with the biggest sum in one pass: carry a running total, and drop it the moment it goes negative. https://leettube.dev/api/video/maximum-subarray/video.mp4 105 2026-10-07T21:17:39.674Z 2026-10-07T21:17:39.674Z monthly 0.8 https://leettube.dev/watch/hand-of-straights Hand of Straights (LeetCode 846) https://leettube.dev/posters/hand-of-straights.webp Split a hand of cards into runs of consecutive values. Always start a run at the smallest card left, since nothing else can come before it. https://leettube.dev/api/video/hand-of-straights/video.mp4 104 2026-10-07T21:16:30.299Z 2026-10-07T21:16:30.299Z monthly 0.8 https://leettube.dev/watch/task-scheduler Task Scheduler (LeetCode 621) https://leettube.dev/posters/task-scheduler.webp Find the fewest slots to run every task with n idle gaps between repeats. The most frequent task sets a frame; the rest fill its gaps. https://leettube.dev/api/video/task-scheduler/video.mp4 104 2026-10-07T21:19:44.180Z 2026-10-07T21:19:44.180Z monthly 0.8 https://leettube.dev/watch/merge-triplets-to-form-target-triplet Merge Triplets to Form Target Triplet (LeetCode 1899) https://leettube.dev/posters/merge-triplets-to-form-target-triplet.webp Can some triplets merge, by taking maxes, into a target? Skip any triplet that overshoots, then check the safe ones still reach every value. https://leettube.dev/api/video/merge-triplets-to-form-target-triplet/video.mp4 96 2026-10-07T21:17:48.077Z 2026-10-07T21:17:48.077Z monthly 0.8 https://leettube.dev/watch/intro-bits-and-math Bits and math tutorial https://leettube.dev/posters/intro-bits-and-math.webp Every number is a row of lamps, on or off. AND, OR and XOR work on every lamp at once, and x XOR x is zero, so pairs cancel. https://leettube.dev/api/video/intro-bits-and-math/video.mp4 46 2026-10-07T21:16:46.071Z 2026-10-07T21:16:46.071Z monthly 0.8 https://leettube.dev/watch/single-number Single Number (LeetCode 136) https://leettube.dev/posters/single-number.webp Every number appears twice except one. XOR them all together: pairs cancel to zero, and the loner is all that's left. https://leettube.dev/api/video/single-number/video.mp4 98 2026-10-07T21:19:20.557Z 2026-10-07T21:19:20.557Z monthly 0.8 https://leettube.dev/watch/single-number-ii Single Number II (LeetCode 137) https://leettube.dev/posters/single-number-ii.webp Every number appears three times except one. Count each of the 32 bits across the array; a count that isn't a multiple of 3 belongs to it. https://leettube.dev/api/video/single-number-ii/video.mp4 99 2026-10-07T21:19:17.799Z 2026-10-07T21:19:17.799Z monthly 0.8 https://leettube.dev/watch/number-of-1-bits Number of 1 Bits (LeetCode 191) https://leettube.dev/posters/number-of-1-bits.webp Count the ones in a number's binary form. n & (n - 1) clears the lowest one bit, so count how many times you can do it before reaching zero. https://leettube.dev/api/video/number-of-1-bits/video.mp4 102 2026-10-07T21:18:12.187Z 2026-10-07T21:18:12.187Z monthly 0.8 https://leettube.dev/watch/hamming-distance Hamming Distance (LeetCode 461) https://leettube.dev/posters/hamming-distance.webp Count the bit positions where two numbers differ: XOR marks every difference, then clear the lowest set bit until none are left. https://leettube.dev/api/video/hamming-distance/video.mp4 101 2026-10-07T21:16:28.955Z 2026-10-07T21:16:28.955Z monthly 0.8 https://leettube.dev/watch/counting-bits Counting Bits (LeetCode 338) https://leettube.dev/posters/counting-bits.webp Count the ones in every number from 0 to n. Each answer is the count for i shifted right one bit, plus its last bit. https://leettube.dev/api/video/counting-bits/video.mp4 97 2026-10-07T21:15:46.966Z 2026-10-07T21:15:46.966Z monthly 0.8 https://leettube.dev/watch/rotate-image Rotate Image (LeetCode 48) https://leettube.dev/posters/rotate-image.webp Spin a square grid a quarter turn without a second grid: flip it across the diagonal, then mirror each row. https://leettube.dev/api/video/rotate-image/video.mp4 97 2026-10-07T21:19:08.613Z 2026-10-07T21:19:08.613Z monthly 0.8 https://leettube.dev/watch/spiral-matrix Spiral Matrix (LeetCode 54) https://leettube.dev/posters/spiral-matrix.webp Read a grid in spiral order by walking four walls: across the top, down the right, back along the bottom, up the left, then shrink inward. https://leettube.dev/api/video/spiral-matrix/video.mp4 100 2026-10-07T21:19:27.055Z 2026-10-07T21:19:27.055Z monthly 0.8 https://leettube.dev/watch/missing-number Missing Number (LeetCode 268) https://leettube.dev/posters/missing-number.webp One number from 0 to n is gone. Add up what 0 to n should total, subtract what you have, and the gap is the answer. https://leettube.dev/api/video/missing-number/video.mp4 103 2026-10-07T21:17:59.858Z 2026-10-07T21:17:59.858Z monthly 0.8 https://leettube.dev/watch/pow-x-n Pow(x, n) (LeetCode 50) https://leettube.dev/posters/pow-x-n.webp Raise x to the power n in about log n steps: square the base and halve the exponent, setting aside one copy whenever it's odd. https://leettube.dev/api/video/pow-x-n/video.mp4 100 2026-10-07T21:18:41.471Z 2026-10-07T21:18:41.471Z monthly 0.8 https://leettube.dev/watch/sqrtx Sqrt(x) (LeetCode 69) https://leettube.dev/posters/sqrtx.webp Integer square root with no built-ins: binary search the answer, square the middle, and keep the largest value whose square still fits. https://leettube.dev/api/video/sqrtx/video.mp4 103 2026-10-07T21:19:28.378Z 2026-10-07T21:19:28.378Z monthly 0.8 https://leettube.dev/watch/reverse-bits Reverse Bits (LeetCode 190) https://leettube.dev/posters/reverse-bits.webp Flip the order of the 32 bits in a number. Peel the last bit off the input and push it onto the result, 32 times, with shifts. https://leettube.dev/api/video/reverse-bits/video.mp4 96 2026-10-07T21:19:01.331Z 2026-10-07T21:19:01.331Z monthly 0.8 https://leettube.dev/watch/sum-of-two-integers Sum of Two Integers (LeetCode 371) https://leettube.dev/posters/sum-of-two-integers.webp Add two numbers without plus or minus. XOR adds each column, AND shifted left is the carry, and you repeat until the carry is zero. https://leettube.dev/api/video/sum-of-two-integers/video.mp4 105 2026-10-07T21:19:37.608Z 2026-10-07T21:19:37.608Z monthly 0.8 https://leettube.dev/watch/reverse-integer Reverse Integer (LeetCode 7) https://leettube.dev/posters/reverse-integer.webp Reverse the digits of a 32-bit integer. Pop the last digit, push it onto the result, and check for overflow before each push. https://leettube.dev/api/video/reverse-integer/video.mp4 107 2026-10-07T21:19:02.663Z 2026-10-07T21:19:02.663Z monthly 0.8 https://leettube.dev/watch/palindrome-number Palindrome Number (LeetCode 9) https://leettube.dev/posters/palindrome-number.webp Is an integer a palindrome without turning it into a string? Peel digits off the end to rebuild the back half, and stop once it meets the front. https://leettube.dev/api/video/palindrome-number/video.mp4 102 2026-10-07T21:18:22.503Z 2026-10-07T21:18:22.503Z monthly 0.8 https://leettube.dev/watch/happy-number Happy Number (LeetCode 202) https://leettube.dev/posters/happy-number.webp Keep replacing a number with the sum of its digits squared. Either it reaches one or loops, and slow and fast pointers spot the loop. https://leettube.dev/api/video/happy-number/video.mp4 107 2026-10-07T21:16:32.274Z 2026-10-07T21:16:32.274Z monthly 0.8 https://leettube.dev/watch/plus-one Plus One (LeetCode 66) https://leettube.dev/posters/plus-one.webp Add one to a number stored as an array of digits. Start from the right, turn each 9 into 0 and carry, and grow the array if needed. https://leettube.dev/api/video/plus-one/video.mp4 96 2026-10-07T21:18:40.092Z 2026-10-07T21:18:40.092Z monthly 0.8 https://leettube.dev/watch/multiply-strings Multiply Strings (LeetCode 43) https://leettube.dev/posters/multiply-strings.webp Multiply two huge numbers stored as strings, like on paper: each digit pair lands at position i + j + 1, then carry the overflow leftward. https://leettube.dev/api/video/multiply-strings/video.mp4 108 2026-10-07T21:18:02.444Z 2026-10-07T21:18:02.444Z monthly 0.8 https://leettube.dev/watch/bitwise-and-of-numbers-range Bitwise AND of Numbers Range (LeetCode 201) https://leettube.dev/posters/bitwise-and-of-numbers-range.webp AND together every number from left to right. Only the shared leading bits survive, so shift both ends right until they match. https://leettube.dev/api/video/bitwise-and-of-numbers-range/video.mp4 99 2026-10-07T21:15:17.824Z 2026-10-07T21:15:17.824Z monthly 0.8 https://leettube.dev/watch/intro-design Design tutorial https://leettube.dev/posters/intro-design.webp Design problems hand you a blueprint with promised costs. Keep a little extra next to the data, like a map or a second value, so every method runs in constant time. https://leettube.dev/api/video/intro-design/video.mp4 44 2026-10-07T21:16:47.265Z 2026-10-07T21:16:47.265Z monthly 0.8 https://leettube.dev/watch/design-hashset Design HashSet (LeetCode 705) https://leettube.dev/posters/design-hashset.webp Build a set with no built-in hash table: hash each key into one of 769 buckets, and keep a short list in each bucket for collisions. https://leettube.dev/api/video/design-hashset/video.mp4 100 2026-10-07T21:16:05.264Z 2026-10-07T21:16:05.264Z monthly 0.8 https://leettube.dev/watch/design-hashmap Design HashMap (LeetCode 706) https://leettube.dev/posters/design-hashmap.webp Build a hash map with no built-in one: hash each key to a bucket, keep a short list there, and update or remove in place. https://leettube.dev/api/video/design-hashmap/video.mp4 98 2026-10-07T21:16:03.329Z 2026-10-07T21:16:03.329Z monthly 0.8 https://leettube.dev/watch/min-stack Min Stack (LeetCode 155) https://leettube.dev/posters/min-stack.webp A stack that also reports its smallest value in constant time. Store each push next to the minimum at that moment, so popping brings the old minimum back. https://leettube.dev/api/video/min-stack/video.mp4 86 2026-10-07T21:17:52.774Z 2026-10-07T21:17:52.774Z monthly 0.8 https://leettube.dev/watch/implement-queue-using-stacks Implement Queue using Stacks (LeetCode 232) https://leettube.dev/posters/implement-queue-using-stacks.webp Build a first-in, first-out queue from two stacks: push onto one, and pour it into the other only when that runs dry. Each item moves once. https://leettube.dev/api/video/implement-queue-using-stacks/video.mp4 102 2026-10-07T21:16:36.765Z 2026-10-07T21:16:36.765Z monthly 0.8 https://leettube.dev/watch/design-circular-queue Design Circular Queue (LeetCode 622) https://leettube.dev/posters/design-circular-queue.webp Build a fixed-size ring queue: keep a head index and a count, wrap every step with modulo, and each operation is constant time. https://leettube.dev/api/video/design-circular-queue/video.mp4 100 2026-10-07T21:16:01.674Z 2026-10-07T21:16:01.674Z monthly 0.8 https://leettube.dev/watch/snapshot-array Snapshot Array (LeetCode 1146) https://leettube.dev/posters/snapshot-array.webp Take snapshots of a huge array cheaply: each index keeps only its changes, and a binary search finds the value at any snap id. https://leettube.dev/api/video/snapshot-array/video.mp4 106 2026-10-07T21:19:23.838Z 2026-10-07T21:19:23.838Z monthly 0.8 https://leettube.dev/watch/binary-search-tree-iterator Binary Search Tree Iterator (LeetCode 173) https://leettube.dev/posters/binary-search-tree-iterator.webp Walk a BST in sorted order one call at a time. Keep a stack of the left spine; each next() pops a node and pushes its right child's left spine. https://leettube.dev/api/video/binary-search-tree-iterator/video.mp4 102 2026-10-07T21:15:07.067Z 2026-10-07T21:15:07.067Z monthly 0.8 https://leettube.dev/watch/lru-cache LRU Cache (LeetCode 146) https://leettube.dev/posters/lru-cache.webp A fixed-size cache with constant-time get and put that evicts the least recently used key. A hash map finds the node, and a linked list keeps the order. https://leettube.dev/api/video/lru-cache/video.mp4 94 2026-10-07T21:17:33.577Z 2026-10-07T21:17:33.577Z monthly 0.8 https://leettube.dev/watch/lfu-cache LFU Cache (LeetCode 460) https://leettube.dev/posters/lfu-cache.webp A cache that evicts the least frequently used key in O(1): a map from key to node, plus one list per use count and a pointer to the lowest count. https://leettube.dev/api/video/lfu-cache/video.mp4 100 2026-10-07T21:17:17.966Z 2026-10-07T21:17:17.966Z monthly 0.8 https://leettube.dev/watch/insert-delete-getrandom Insert Delete GetRandom O(1) (LeetCode 380) https://leettube.dev/posters/insert-delete-getrandom.webp A set with constant-time insert, remove and random pick. Keep values in a list and their positions in a map, and delete by swapping with the last. https://leettube.dev/api/video/insert-delete-getrandom/video.mp4 91 2026-10-07T21:16:39.792Z 2026-10-07T21:16:39.792Z monthly 0.8 https://leettube.dev/watch/design-add-and-search-words Add and Search Words (LeetCode 211) https://leettube.dev/posters/design-add-and-search-words.webp Store words in a trie and search patterns where a dot matches any letter, branching into every child only when you meet a dot. https://leettube.dev/api/video/design-add-and-search-words/video.mp4 99 2026-10-07T21:15:59.013Z 2026-10-07T21:15:59.013Z monthly 0.8 https://leettube.dev/watch/find-median-from-data-stream Find Median from Data Stream (LeetCode 295) https://leettube.dev/posters/find-median-from-data-stream.webp Keep the running median as numbers stream in. Split them across two heaps, a max-heap for the low half and a min-heap for the high half. https://leettube.dev/api/video/find-median-from-data-stream/video.mp4 96 2026-10-07T21:16:18.295Z 2026-10-07T21:16:18.295Z monthly 0.8 https://leettube.dev/watch/time-based-key-value-store Time Based Key-Value Store (LeetCode 981) https://leettube.dev/posters/time-based-key-value-store.webp Store values per key with timestamps, then fetch the latest value at or before a time. Times arrive sorted, so binary search them. https://leettube.dev/api/video/time-based-key-value-store/video.mp4 99 2026-10-07T21:19:45.568Z 2026-10-07T21:19:45.568Z monthly 0.8 https://leettube.dev/watch/merge-k-sorted-lists Merge k Sorted Lists (LeetCode 23) https://leettube.dev/posters/merge-k-sorted-lists.webp Merge k sorted linked lists into one. The next node is always one of the k heads, so keep them in a min-heap and pop the smallest. https://leettube.dev/api/video/merge-k-sorted-lists/video.mp4 102 2026-10-07T21:17:43.903Z 2026-10-07T21:17:43.903Z monthly 0.8 https://leettube.dev/watch/design-twitter Design Twitter (LeetCode 355) https://leettube.dev/posters/design-twitter.webp Build a tiny Twitter with post, follow and a news feed. Hash maps hold tweets and follows, and a max-heap merges the ten newest. https://leettube.dev/api/video/design-twitter/video.mp4 105 2026-10-07T21:16:06.768Z 2026-10-07T21:16:06.768Z monthly 0.8 https://leettube.dev/watch/kth-largest-element-in-a-stream Kth Largest Element in a Stream (LeetCode 703) https://leettube.dev/posters/kth-largest-element-in-a-stream.webp Track the kth largest number as new ones stream in. Keep only the top k in a min-heap, and its smallest member is always the answer. https://leettube.dev/api/video/kth-largest-element-in-a-stream/video.mp4 88 2026-10-07T21:17:06.357Z 2026-10-07T21:17:06.357Z monthly 0.8 https://leettube.dev/watch/last-stone-weight Last Stone Weight (LeetCode 1046) https://leettube.dev/posters/last-stone-weight.webp Smash the two heaviest stones together until at most one is left. A max-heap hands you the two biggest every turn in log time. https://leettube.dev/api/video/last-stone-weight/video.mp4 101 2026-10-07T21:17:11.133Z 2026-10-07T21:17:11.133Z monthly 0.8 https://leettube.dev/watch/detect-squares Detect Squares (LeetCode 2013) https://leettube.dev/posters/detect-squares.webp Count the axis-aligned squares a query point makes with stored points. Keep point counts in a hash map and scan for diagonal corners. https://leettube.dev/api/video/detect-squares/video.mp4 97 2026-10-07T21:16:08.446Z 2026-10-07T21:16:08.446Z monthly 0.8 https://leettube.dev/watch/k-closest-points-to-origin K Closest Points to Origin (LeetCode 973) https://leettube.dev/posters/k-closest-points-to-origin.webp Find the k points nearest the origin. Keep a max-heap of k seats and bump whoever sits farthest, so the k closest are left at the end. https://leettube.dev/api/video/k-closest-points-to-origin/video.mp4 100 2026-10-07T21:17:04.223Z 2026-10-07T21:17:04.223Z monthly 0.8