https://leettube.dev 2026-10-08T03:04:41.967Z weekly 1 https://leettube.dev/about monthly 0.5 https://leettube.dev/worlds/warm-up 2026-10-08T03:04:41.967Z weekly 0.9 https://leettube.dev/worlds/arrays 2026-10-08T03:04:41.967Z weekly 0.9 https://leettube.dev/worlds/trees 2026-10-08T03:04:41.967Z weekly 0.9 https://leettube.dev/worlds/backtracking 2026-10-08T03:04:41.967Z weekly 0.9 https://leettube.dev/worlds/dynamic-programming 2026-10-08T03:04:41.967Z weekly 0.9 https://leettube.dev/worlds/graphs 2026-10-08T03:04:41.967Z weekly 0.9 https://leettube.dev/worlds/greedy 2026-10-08T03:04:41.967Z weekly 0.9 https://leettube.dev/worlds/bits-and-math 2026-10-08T03:04:41.967Z weekly 0.9 https://leettube.dev/worlds/design 2026-10-08T03:04:41.967Z weekly 0.9 https://leettube.dev/topics 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/dynamic-programming 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/backtracking 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/greedy 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/tree-recursion 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/bit-manipulation 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/two-pointers 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/design 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/binary-search 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/breadth-first-search 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/hash-map 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/heap 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/linked-list 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/fast-and-slow-pointers 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/grid-search 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/shortest-path 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/sliding-window 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/depth-first-search 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/math 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/monotonic-stack 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/carry 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/counting 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/expand-around-centre 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/hash-set 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/matrix 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/prefix-sums 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/sorting 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/stack 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/topological-sort 2026-10-08T03:04:41.967Z weekly 0.7 https://leettube.dev/topics/trie 2026-10-08T03:04:41.967Z 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/move-zeroes Move Zeroes (LeetCode 283) https://leettube.dev/posters/move-zeroes.webp Push every zero to the end without changing the order of the rest, in place. A write pointer marks where the next non-zero belongs; swap each non-zero into it as you scan, and the zeros drift back in one O(n) pass with O(1) space. https://leettube.dev/api/video/move-zeroes/video.mp4 94 2026-10-08T02:27:38.480Z 2026-10-08T02:27:38.480Z 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/majority-element Majority Element (LeetCode 169) https://leettube.dev/posters/majority-element.webp One value fills more than half the list. Boyer–Moore voting pairs off different values like rival fighters knocking each other off a hill, and the majority is the one left standing, in one pass and O(1) space. https://leettube.dev/api/video/majority-element/video.mp4 94 2026-10-08T00:01:25.770Z 2026-10-08T00:01:25.770Z 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/kth-largest-element-in-an-array Kth Largest Element in an Array (LeetCode 215) https://leettube.dev/posters/kth-largest-element-in-an-array.webp Find the kth largest number without sorting everything. Quickselect partitions around a pivot, which lands in its final sorted spot, and then keeps only the side that holds index n−k, for O(n) average time and O(1) space. https://leettube.dev/api/video/kth-largest-element-in-an-array/video.mp4 104 2026-10-08T00:33:17.944Z 2026-10-08T00:33:17.944Z 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/permutation-in-string Permutation in String (LeetCode 567) https://leettube.dev/posters/permutation-in-string.webp Does any window of s2 hold exactly the letters of s1? Slide a fixed-size window and keep 26 letter counts in step, one letter in and one out, so every check is O(1) and the whole scan is O(n). https://leettube.dev/api/video/permutation-in-string/video.mp4 101 2026-10-08T00:05:57.320Z 2026-10-08T00:05:57.320Z monthly 0.8 https://leettube.dev/watch/longest-repeating-character-replacement Longest Repeating Character Replacement (LeetCode 424) https://leettube.dev/posters/longest-repeating-character-replacement.webp Change at most k letters to get the longest run of one letter. Slide a window and keep letter counts: it's fine while its length minus its most common letter's count is at most k, and the top count never needs to shrink. O(n) time. https://leettube.dev/api/video/longest-repeating-character-replacement/video.mp4 110 2026-10-08T02:32:11.038Z 2026-10-08T02:32:11.038Z 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/two-sum-ii-input-array-is-sorted Two Sum II - Input Array Is Sorted (LeetCode 167) https://leettube.dev/posters/two-sum-ii-input-array-is-sorted.webp The list is sorted, so start one pointer at each end. If the pair adds up too small, move the left one right; too big, move the right one left. Each step rules out a whole row of pairs: O(n) time, O(1) space. https://leettube.dev/api/video/two-sum-ii-input-array-is-sorted/video.mp4 103 2026-10-08T02:25:11.265Z 2026-10-08T02:25:11.265Z 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/koko-eating-bananas Koko Eating Bananas (LeetCode 875) https://leettube.dev/posters/koko-eating-bananas.webp Koko must finish every banana pile before the guard returns in h hours. Hours only shrink as her speed grows, so binary search the speeds from 1 to the biggest pile for the slowest one that fits, in O(n log max). https://leettube.dev/api/video/koko-eating-bananas/video.mp4 106 2026-10-08T00:11:22.094Z 2026-10-08T00:11:22.094Z 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/count-good-nodes-in-binary-tree Count Good Nodes in Binary Tree (LeetCode 1448) https://leettube.dev/posters/count-good-nodes-in-binary-tree.webp A node is good if nothing on the path from the root is bigger. Walk down with DFS carrying the largest value seen so far, and count every node that meets or beats it, in O(n) time. https://leettube.dev/api/video/count-good-nodes-in-binary-tree/video.mp4 91 2026-10-08T00:03:55.058Z 2026-10-08T00:03:55.058Z 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/flatten-binary-tree-to-linked-list Flatten Binary Tree to Linked List (LeetCode 114) https://leettube.dev/posters/flatten-binary-tree-to-linked-list.webp Turn a tree into a right-leaning chain in preorder, in place. At each node, find the rightmost node of its left side, hang the right subtree there, swing the left side over to the right, and step on: O(n) time, O(1) space. https://leettube.dev/api/video/flatten-binary-tree-to-linked-list/video.mp4 97 2026-10-08T02:29:45.122Z 2026-10-08T02:29:45.122Z 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/target-sum Target Sum (LeetCode 494) https://leettube.dev/posters/target-sum.webp Put + or − before every number and count the ways to hit the target. The sign tree doubles at every step, but the same (index, running total) keeps coming back, so memoize it and the work drops to O(n·S). https://leettube.dev/api/video/target-sum/video.mp4 94 2026-10-08T00:25:44.840Z 2026-10-08T00:25:44.840Z 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/matchsticks-to-square Matchsticks to Square (LeetCode 473) https://leettube.dev/posters/matchsticks-to-square.webp Can every matchstick, used once and unbroken, form a square? Check the total splits by four, sort longest first, then place each stick on a side with room and undo on a dead end, skipping side lengths already tried. https://leettube.dev/api/video/matchsticks-to-square/video.mp4 99 2026-10-08T02:56:10.819Z 2026-10-08T02:56:10.819Z 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/longest-palindromic-substring Longest Palindromic Substring (LeetCode 5) https://leettube.dev/posters/longest-palindromic-substring.webp Find the longest stretch that reads the same both ways. Every palindrome mirrors around a center, a letter or a gap, so try all 2n−1 centers and grow outwards while the ends match, in O(n²) time and O(1) space. https://leettube.dev/api/video/longest-palindromic-substring/video.mp4 100 2026-10-08T00:23:47.686Z 2026-10-08T00:23:47.686Z 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/maximal-square Maximal Square (LeetCode 221) https://leettube.dev/posters/maximal-square.webp Find the biggest square of 1s in a grid. For each cell, the largest square ending there is one more than the smallest of the squares above, to the left and diagonally up-left, so one pass fills the table in O(mn). https://leettube.dev/api/video/maximal-square/video.mp4 97 2026-10-08T02:44:16.343Z 2026-10-08T02:44:16.343Z 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/snakes-and-ladders Snakes and Ladders (LeetCode 909) https://leettube.dev/posters/snakes-and-ladders.webp Fewest dice rolls to reach the last square of a zig-zag board full of snakes and ladders. Treat squares as nodes and rolls as edges, and breadth-first search finds the answer level by level in O(n²). https://leettube.dev/api/video/snakes-and-ladders/video.mp4 104 2026-10-08T00:09:12.683Z 2026-10-08T00:09:12.683Z monthly 0.8 https://leettube.dev/watch/shortest-path-in-binary-matrix Shortest Path in Binary Matrix (LeetCode 1091) https://leettube.dev/posters/shortest-path-in-binary-matrix.webp Cross a grid of open and blocked cells from top-left to bottom-right, moving in eight directions. Breadth-first search spreads out one ring at a time, so the first time it reaches the corner is the shortest path: O(n²). https://leettube.dev/api/video/shortest-path-in-binary-matrix/video.mp4 103 2026-10-08T02:59:19.858Z 2026-10-08T02:59:19.858Z 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/assign-cookies Assign Cookies (LeetCode 455) https://leettube.dev/posters/assign-cookies.webp Each child wants a cookie at least as big as their greed. Sort both lists and walk the cookies smallest first, handing each to the least greedy child it can satisfy, so no big cookie is wasted, in O(n log n + m log m). https://leettube.dev/api/video/assign-cookies/video.mp4 103 2026-10-08T00:21:47.083Z 2026-10-08T00:21:47.083Z 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/insert-interval Insert Interval (LeetCode 57) https://leettube.dev/posters/insert-interval.webp Slot a new interval into a sorted, non-overlapping list. One pass in three phases: copy everything that ends before it, absorb everything that overlaps into one wider interval, then copy the rest. No sort needed: O(n). https://leettube.dev/api/video/insert-interval/video.mp4 100 2026-10-08T02:46:12.443Z 2026-10-08T02:46:12.443Z 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/single-number-iii Single Number III (LeetCode 260) https://leettube.dev/posters/single-number-iii.webp Every number appears twice except two. XOR everything to get a XOR b, take its lowest set bit to split the numbers into two lanes, and XOR each lane to find the two loners, in O(n) time and O(1) space. https://leettube.dev/api/video/single-number-iii/video.mp4 108 2026-10-08T00:31:02.988Z 2026-10-08T00:31:02.988Z 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/gray-code Gray Code (LeetCode 89) https://leettube.dev/posters/gray-code.webp List every n-bit number so each differs from the next by exactly one bit. Start with 0, then for each new bit mirror the list and switch that bit on in the mirrored half; the seam changes only the new bit. Same as i XOR (i >> 1). https://leettube.dev/api/video/gray-code/video.mp4 96 2026-10-08T02:54:12.765Z 2026-10-08T02:54:12.765Z 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/online-stock-span Online Stock Span (LeetCode 901) https://leettube.dev/posters/online-stock-span.webp Each day, report how many days in a row the price has been at or below today's. Keep a stack of (price, span) pairs: pop every smaller price and add its span to today's. Each day is pushed and popped once: O(1) amortized. https://leettube.dev/api/video/online-stock-span/video.mp4 106 2026-10-08T03:04:41.967Z 2026-10-08T03:04:41.967Z 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