LeetCode
Greedy
This section collects Hot100 greedy tutorials, focusing on which local state is enough, why it stays valid while scanning, and how that local choice proves the global answer. Recommended Reading Order LeetCode 121: Best Time to Buy and Sell Stock, derive one-transaction greedy from the historical minimum price LeetCode 55: Jump Game, use the farthest reachable range to decide reachability LeetCode 45: Jump Game II, upgrade reachability into minimum jump layers LeetCode 435: Non-overlapping Intervals, turn minimum removals into maximum kept intervals LeetCode 452: Minimum Number of Arrows, derive interval greedy from shared intersections
Union-Find
This section collects Hot100 Union-Find templates and problems, focusing on set representatives, path compression, merge conditions, connectivity checks, and connected component counting.
Trie
This section collects Hot100 Trie tutorials, focusing on node fields, child traversal, end markers, and loop invariants.
LeetCode 136: Single Number Without Growing Extra Storage
Problem Requirement You are given a non-empty integer array nums. Exactly one element appears once. Every other element appears exactly twice. Return the element that appears once. LeetCode provides this method contract: singleNumber(nums: List[int]) -> int The solution must also satisfy two resource requirements: O(n) time O(1) extra space Example 1 Input: nums = [2,2,1] Output: 1 2 appears twice. Only 1 appears once. Example 2 Input: nums = [4,1,2,1,2] Output: 4 Both 1 and 2 have matching copies. Only 4 remains unpaired. ...
LeetCode 191: Number of 1 Bits and How to Skip Irrelevant Zeros
Problem Requirement Given a positive integer n, return the number of 1 bits in its binary representation. This count is also called the Hamming weight. LeetCode provides this method contract: hammingWeight(n: int) -> int Example 1 Input: n = 11 Binary: 1011 Output: 3 Example 2 Input: n = 128 Binary: 10000000 Output: 1 Constraints 1 <= n <= 2^31 - 1 The input stays in the problem’s non-negative integer domain. Although the current constraints start at 1, the implementation also handles n = 0 naturally and returns 0. ...
LeetCode 338: Counting Bits by Reusing Smaller Results
Problem Requirement Given a non-negative integer n, return an array answer of length n + 1. For every index: answer[i] = the number of 1 bits in the binary representation of i The requested range includes both 0 and n. LeetCode provides this method contract: countBits(n: int) -> List[int] Example 1 Input: n = 2 Output: [0,1,1] 0 -> 0 -> 0 set bits 1 -> 1 -> 1 set bit 2 -> 10 -> 1 set bit Example 2 Input: n = 5 Output: [0,1,1,2,1,2] Constraints 0 <= n <= 10^5 Step 1: This Time We Need Every Answer From 0 to n LeetCode 191 asks for one integer’s set-bit count. For n = 5, this problem asks for all six related answers: ...
LeetCode 739: Daily Temperatures and the First Warmer Day to the Right
Problem Requirement You are given an integer array temperatures, where temperatures[i] is the temperature on day i. Return an array answer where: answer[i] = the number of days after day i until a warmer temperature If no later day is warmer, answer[i] = 0. “Warmer” means strictly greater. An equal temperature does not resolve a waiting day. LeetCode provides this method contract: dailyTemperatures(temperatures: List[int]) -> List[int] Example Input: temperatures = [73,74,75,71,69,72,76,73] Output: [1,1,4,2,1,1,0,0] Constraints 1 <= temperatures.length <= 10^5 30 <= temperatures[i] <= 100 Step 1: The Answer Is a Waiting Time, Not a Temperature Start with a smaller input: ...
LeetCode 684: Redundant Connection With Union-Find
Subtitle / Summary The key signal in this problem is not a component count. It is a failed union: if two endpoints are already connected, adding the current edge closes a cycle. Reading time: 8-10 min Tags: Union-Find, DSU, graph, tree, cycle detection SEO keywords: LeetCode 684, Redundant Connection, Union-Find, DSU, cycle detection Meta description: A pressure-first Python guide to LeetCode 684 that derives 1-indexed Union-Find, bool-returning union, ordered edge scanning, and final checks. Problem Requirement You are given an undirected graph. It started as a tree with n nodes labeled from 1 to n, then one extra edge was added. ...
LeetCode 547: Number of Provinces, Turn an Adjacency Matrix into Connected Components
Problem Requirement You are given an n x n matrix isConnected, where there are n cities. If isConnected[i][j] == 1, city i and city j are directly connected. If two cities can reach each other through one or more directly connected cities, they belong to the same province. The problem asks you to return the total number of provinces. The easiest mistake is to think that the answer is the number of 1s in the matrix, or only the number of directly connected pairs. That is not what the problem asks. ...
LeetCode 198: House Robber, Deriving 1D DP from Rob or Skip
Problem Input and Output Input: an integer array nums nums[i] is the money in the i-th house Adjacent houses cannot both be robbed Output: return the maximum amount of money that can be robbed Constraints: 1 <= nums.length <= 100, 0 <= nums[i] <= 400 Examples Input: nums = [1,2,3,1] Output: 4 Explanation: rob indices 0 and 2, for 1 + 3 = 4 Input: nums = [2,7,9,3,1] Output: 12 Explanation: rob indices 0, 2, and 4, for 2 + 9 + 1 = 12 This article uses Python only and derives 1D DP from the conflict between two choices. ...
LeetCode 70: Climbing Stairs, Deriving 1D DP from dp[i]
Problem Input and Output Input: an integer n Meaning: climb to the top of the n-step staircase Each move can climb 1 or 2 steps Output: return the number of distinct ways to reach the top Constraints: 1 <= n <= 45 Examples Input: n = 2 Output: 2 Explanation: 1+1, 2 Input: n = 3 Output: 3 Explanation: 1+1+1, 1+2, 2+1 This article uses Python only and derives the final solution step by step from the meaning of dp[i]. ...
LeetCode 746: Min Cost Climbing Stairs, Deriving DP from the Top Position
Problem Input and Output Input: an integer array cost cost[i] is the cost of stepping on stair i Each move can climb 1 or 2 steps You may start from index 0 or index 1 Output: return the minimum cost to reach the top Constraints: 2 <= cost.length <= 1000, 0 <= cost[i] <= 999 Examples Input: cost = [10,15,20] Output: 15 Explanation: start from index 1, pay 15, then reach the top directly Input: cost = [1,100,1,1,1,100,1,1,100,1] Output: 6 Start from the Top Position of [10,15,20] Look at the small example: ...
LeetCode 78: Subsets, Derive the startIndex Backtracking Template
Problem Requirement Input / Output Input: nums, with 1 <= nums.length <= 10 Value range: -10 <= nums[i] <= 10 All elements in nums are distinct Output: return all possible subsets of nums Ordering: the result order does not matter, and subset element order is not the point Example Input: nums = [1,2,3] Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] This tutorial builds one minimal Python solution. Start From the Search Tree for [1,2] The smallest branching example is: ...