Solutions & Explanations

Browse 4,029+ detailed solutions with multiple approaches, code in Python, Java, C++ and more.

4,029 Solutions961 Easy2102 Medium966 Hard

Title	Difficulty	Acceptance	Topics	Solution
201. Bitwise AND of Numbers Range	Medium	48.8%	Bit Manipulation	Read
202. Happy Number	Easy	60.0%	Hash Table Math+1	Read
203. Remove Linked List Elements	Easy	55.3%	Linked List Recursion	Read
204. Count Primes	Medium	36.4%	Array Enumeration+2	Read
205. Isomorphic Strings	Easy	48.8%	Hash Table String	Read
206. Reverse Linked List	Easy	81.0%	Linked List Recursion	Read
207. Course Schedule	Medium	52.2%	Breadth-First Search Depth-First Search+2	Read
208. Implement Trie (Prefix Tree)	Medium	69.9%	Design Hash Table+2	Read
209. Minimum Size Subarray Sum	Medium	52.5%	Array Binary Search+2	Read
210. Course Schedule II	Medium	56.3%	Breadth-First Search Depth-First Search+2	Read
211. Design Add and Search Words Data Structure	Medium	48.9%	Depth-First Search Design+2	Read
212. Word Search II	Hard	38.8%	Array Backtracking+3	Read
213. House Robber II	Medium	45.3%	Array Dynamic Programming	Read
214. Shortest Palindrome	Hard	42.7%	Hash Function Rolling Hash+2	Read
215. Kth Largest Element in an Array	Medium	68.8%	Array Divide and Conquer+3	Read
216. Combination Sum III	Medium	73.6%	Array Backtracking	Read
217. Contains Duplicate	Easy	64.2%	Array Hash Table+1	Read
218. The Skyline Problem	Hard	45.7%	Array Binary Indexed Tree+5	Read
219. Contains Duplicate II	Easy	51.6%	Array Hash Table+1	Read
220. Contains Duplicate III	Hard	25.2%	Array Bucket Sort+3	Read
221. Maximal Square	Medium	50.7%	Array Dynamic Programming+1	Read
222. Count Complete Tree Nodes	Medium	72.6%	Binary Search Binary Tree+2	Read
223. Rectangle Area	Medium	50.3%	Geometry Math	Read
224. Basic Calculator	Hard	46.7%	Math Recursion+2	Read
225. Implement Stack using Queues	Easy	70.1%	Design Queue+1	Read
226. Invert Binary Tree	Easy	80.5%	Binary Tree Breadth-First Search+2	Read
227. Basic Calculator II	Medium	46.7%	Math Stack+1	Read
228. Summary Ranges	Easy	54.6%	Array	Read
229. Majority Element II	Medium	56.5%	Array Counting+2	Read
230. Kth Smallest Element in a BST	Medium	77.2%	Binary Search Tree Binary Tree+2	Read
231. Power of Two	Easy	50.5%	Bit Manipulation Math+1	Read
232. Implement Queue using Stacks	Easy	70.2%	Design Queue+1	Read
233. Number of Digit One	Hard	39.3%	Dynamic Programming Math+1	Read
234. Palindrome Linked List	Easy	58.8%	Linked List Recursion+2	Read
235. Lowest Common Ancestor of a Binary Search Tree	Medium	71.4%	Binary Search Tree Binary Tree+2	Read
236. Lowest Common Ancestor of a Binary Tree	Medium	70.1%	Binary Tree Depth-First Search+1	Read
237. Delete Node in a Linked List	Medium	84.3%	Linked List	Read
238. Product of Array Except Self	Medium	69.3%	Array Prefix Sum	Read
239. Sliding Window Maximum	Hard	49.1%	Array Heap (Priority Queue)+3	Read
240. Search a 2D Matrix II	Medium	57.6%	Array Binary Search+2	Read
241. Different Ways to Add Parentheses	Medium	73.7%	Dynamic Programming Math+3	Read
242. Valid Anagram	Easy	68.5%	Hash Table Sorting+1	Read
243. Shortest Word Distance	Easy	66.3%	Array String	Read
244. Shortest Word Distance II	Medium	62.8%	Array Design+3	Read
245. Shortest Word Distance III	Medium	59.4%	Array String	Read
246. Strobogrammatic Number	Easy	47.6%	Hash Table String+1	Read
247. Strobogrammatic Number II	Medium	53.5%	Array Recursion+1	Read
248. Strobogrammatic Number III	Hard	42.3%	Array Recursion+1	Read
249. Group Shifted Strings	Medium	67.8%	Array Hash Table+1	Read
250. Count Univalue Subtrees	Medium	57.5%	Binary Tree Depth-First Search+1	Read

#201Medium

Bitwise AND of Numbers Range

Bit Manipulation

Acceptance: 48.8%

#202Easy

Happy Number

Hash TableMathTwo Pointers

Acceptance: 60.0%

#203Easy

Remove Linked List Elements

Linked ListRecursion

Acceptance: 55.3%

#204Medium

Count Primes

ArrayEnumerationMath+1

Acceptance: 36.4%

#205Easy

Isomorphic Strings

Hash TableString

Acceptance: 48.8%

#206Easy

Reverse Linked List

Linked ListRecursion

Acceptance: 81.0%

#207Medium

Course Schedule

Breadth-First SearchDepth-First SearchGraph+1

Acceptance: 52.2%

#208Medium

Implement Trie (Prefix Tree)

DesignHash TableString+1

Acceptance: 69.9%

#209Medium

Minimum Size Subarray Sum

ArrayBinary SearchPrefix Sum+1

Acceptance: 52.5%

#210Medium

Course Schedule II

Breadth-First SearchDepth-First SearchGraph+1

Acceptance: 56.3%

#211Medium

Design Add and Search Words Data Structure

Depth-First SearchDesignString+1

Acceptance: 48.9%

#212Hard

Word Search II

ArrayBacktrackingMatrix+2

Acceptance: 38.8%

#213Medium

House Robber II

ArrayDynamic Programming

Acceptance: 45.3%

#214Hard

Shortest Palindrome

Hash FunctionRolling HashString+1

Acceptance: 42.7%

#215Medium

Kth Largest Element in an Array

ArrayDivide and ConquerHeap (Priority Queue)+2

Acceptance: 68.8%

#216Medium

Combination Sum III

ArrayBacktracking

Acceptance: 73.6%

#217Easy

Contains Duplicate

ArrayHash TableSorting

Acceptance: 64.2%

#218Hard

The Skyline Problem

ArrayBinary Indexed TreeDivide and Conquer+4

Acceptance: 45.7%

#219Easy

Contains Duplicate II

ArrayHash TableSliding Window

Acceptance: 51.6%

#220Hard

Contains Duplicate III

ArrayBucket SortOrdered Set+2

Acceptance: 25.2%

#221Medium

Maximal Square

ArrayDynamic ProgrammingMatrix

Acceptance: 50.7%

#222Medium

Count Complete Tree Nodes

Binary SearchBinary TreeBit Manipulation+1

Acceptance: 72.6%

#223Medium

Rectangle Area

GeometryMath

Acceptance: 50.3%

#224Hard

Basic Calculator

MathRecursionStack+1

Acceptance: 46.7%

#225Easy

Implement Stack using Queues

DesignQueueStack

Acceptance: 70.1%

#226Easy

Invert Binary Tree

Binary TreeBreadth-First SearchDepth-First Search+1

Acceptance: 80.5%

#227Medium

Basic Calculator II

MathStackString

Acceptance: 46.7%

#228Easy

Summary Ranges

Array

Acceptance: 54.6%

#229Medium

Majority Element II

ArrayCountingHash Table+1

Acceptance: 56.5%

#230Medium

Kth Smallest Element in a BST

Binary Search TreeBinary TreeDepth-First Search+1

Acceptance: 77.2%

#231Easy

Power of Two

Bit ManipulationMathRecursion

Acceptance: 50.5%

#232Easy

Implement Queue using Stacks

DesignQueueStack

Acceptance: 70.2%

#233Hard

Number of Digit One

Dynamic ProgrammingMathRecursion

Acceptance: 39.3%

#234Easy

Palindrome Linked List

Linked ListRecursionStack+1

Acceptance: 58.8%

#235Medium

Lowest Common Ancestor of a Binary Search Tree

Binary Search TreeBinary TreeDepth-First Search+1

Acceptance: 71.4%

#236Medium

Lowest Common Ancestor of a Binary Tree

Binary TreeDepth-First SearchTree

Acceptance: 70.1%

#237Medium

Delete Node in a Linked List

Linked List

Acceptance: 84.3%

#238Medium

Product of Array Except Self

ArrayPrefix Sum

Acceptance: 69.3%

#239Hard

Sliding Window Maximum

ArrayHeap (Priority Queue)Monotonic Queue+2

Acceptance: 49.1%

#240Medium

Search a 2D Matrix II

ArrayBinary SearchDivide and Conquer+1

Acceptance: 57.6%

#241Medium

Different Ways to Add Parentheses

Dynamic ProgrammingMathMemoization+2

Acceptance: 73.7%

#242Easy

Valid Anagram

Hash TableSortingString

Acceptance: 68.5%

#243Easy

Shortest Word Distance

ArrayString

Acceptance: 66.3%

#244Medium

Shortest Word Distance II

ArrayDesignHash Table+2

Acceptance: 62.8%

#245Medium

Shortest Word Distance III

ArrayString

Acceptance: 59.4%

#246Easy

Strobogrammatic Number

Hash TableStringTwo Pointers

Acceptance: 47.6%

#247Medium

Strobogrammatic Number II

ArrayRecursionString

Acceptance: 53.5%

#248Hard

Strobogrammatic Number III

ArrayRecursionString

Acceptance: 42.3%

#249Medium

Group Shifted Strings

ArrayHash TableString

Acceptance: 67.8%

#250Medium

Count Univalue Subtrees

Binary TreeDepth-First SearchTree

Acceptance: 57.5%

1 2 3 4 5 679 80 81

Page 5 of 81

Master DSA with Step-by-Step Solutions

Each solution article on FleetCode breaks down the problem into multiple approaches, from brute force to optimal, with detailed explanations and code in Python, Java, C++ and more. Understanding why an approach works - not just copying code - is what separates candidates who clear interviews from those who don't.

How to Use These Solutions

Try the problem first: Spend at least 20 minutes before reading the solution
Read all approaches: Start from brute force to understand the problem fully, then study the optimized solution
Understand the complexity: Pay attention to time and space analysis for each approach
Code it yourself: After understanding the approach, close the solution and implement from memory
Revisit after a week: Spaced repetition helps retain problem-solving patterns