An shorter list of 50 problems, each directly tied to the learning and patterns taught on AlgoMonster. Every question is a guided step-by-step walkthrough practice.


Given an `m x n` image represented by a 2D integer grid where `image[i][j]` represents the color of the pixel, perform a flood fill. The flood fill starts from the given pixel `(sr, sc)` and changes the color of all connected pixels with the same initial color to `newColor`. Connected pixels are adjacent pixels horizontally or vertically.

Flood Fill

Given a string s, find the length of the longest substring without repeating characters.

Longest Substring Without Repeating Characters

Given an array of distinct integers `candidates` and a target integer `target`, return all unique combinations of `candidates` where the chosen numbers sum to `target`. You may use the same number multiple times. The answer can be returned in any order.

Combination Sum

Given an `m x n` board of characters and a word, return `true` if the word exists in the grid. The word can be constructed from letters in adjacent cells (horizontally or vertically) but cannot reuse the same letter cell more than once.

Word Search

Given the head of a singly linked list, return the middle node of the list. If there are two middle nodes, return the second middle node.

Middle of the Linked List

Given a sorted array of `n` integers and a target value, return the index of the target in the array. If the target is not found, return `-1`. The algorithm must run in O(log N) time.

Binary Search

Given the roots of two binary trees `p` and `q`, determine if they are the same. Two binary trees are considered the same if they have the same structure and the same node values.

Same Tree

Given the root of a binary tree, return the level order traversal of its nodes' values (i.e., from left to right, level by level).

Binary Tree Level Order Traversal

Given an integer array `nums`, return an array `answer` such that `answer[i]` is equal to the product of all elements in `nums` except `nums[i]`. The solution must run in O(N) time and should not use division.

Product of Array Except Self

Given an array of integers `temperatures` representing daily temperatures, return an array `answer` where `answer[i]` is the number of days you have to wait until a warmer temperature. If there is no future day with a warmer temperature, set `answer[i] = 0`.

Daily Temperatures

Design and implement a Trie (Prefix Tree) with `insert`, `search`, and `startsWith` operations.

Implement Trie (Prefix Tree)

Given an array of integers `nums` and an integer `target`, return the indices of the two numbers such that they add up to `target`. You may assume that each input would have exactly one solution, and you may not use the same element twice.

Two Sum

Given an array `prices` where `prices[i]` is the price of a given stock on day `i`, find the maximum profit you can achieve. You may only complete one transaction (i.e., buy one and sell one share of the stock).

Best Time to Buy and Sell Stock

Given the root of a binary tree, return its maximum depth. The maximum depth is the number of edges along the longest path from the root down to the farthest leaf node.

Maximum Depth of Binary Tree

Given a sorted array that has been rotated at some unknown pivot, find the minimum element. You must write an algorithm that runs in O(log N) time.

Find Minimum in Rotated Sorted Array

Given an integer array `nums`, find a peak element and return its index. A peak element is an element that is strictly greater than its neighbors. If the array contains multiple peaks, return the index of any of the peaks.

Find Peak Element

Given an integer array `nums`, return all unique triplets `[nums[i], nums[j], nums[k]]` such that `i != j != k` and `nums[i] + nums[j] + nums[k] == 0`. The solution set must not contain duplicate triplets.

3Sum

Given `numCourses` and a list of prerequisite pairs where `prerequisites[i] = [a, b]` means course `a` depends on course `b`, determine if it's possible to finish all courses. Return `true` if possible, otherwise return `false`.

Course Schedule

Given an integer array `height` where `height[i]` represents the height of a vertical line at index `i`, find two lines that together with the x-axis form a container that holds the most water. Return the maximum amount of water a container can store.

Container With Most Water

Given the head of a singly linked list, reorder it to follow this pattern - the first node, then the last node, then the second node, then the second-last node, and so on. The reordering must be done in-place without modifying node values.

Reorder List

Given an `m x n` matrix where each row is sorted in ascending order and the first integer of each row is greater than the last integer of the previous row, write an efficient algorithm that searches for a target value.

Search a 2D Matrix

You are organizing newspapers for your coworkers to read. Each newspaper has a read time, and coworkers can only read one newspaper at a time. Your goal is to assign consecutive sections of newspapers to workers such that the maximum reading time among all workers is minimized.

Newspapers

Given an array of heights representing the histogram's bar heights where the width of each bar is `1`, return the area of the largest rectangle in the histogram.

Largest Rectangle in Histogram

Given an integer `n`, return all possible distinct solutions to the N-Queens puzzle, where `n` queens are placed on an `n x n` chessboard such that no two queens attack each other.

N-Queens

Given an `m x n` grid consisting of `1`s (land) and `0`s (water), return the number of islands. An island is formed by connecting adjacent `1`s vertically or horizontally.

Number of Islands

Given a knight at position `(0,0)` on an infinite chessboard, find the minimum number of moves required to reach `(x,y)`. The knight moves in an "L" shape - two squares in one direction and then one square perpendicular.

Minimum Knight Moves

Given two words, `beginWord` and `endWord`, and a dictionary `wordList`, return the shortest transformation sequence from `beginWord` to `endWord`, such that
- Only one letter can be changed at a time.
- Each transformed word must exist in `wordList`.
- If no such sequence exists, return 0.


Word Ladder

Given the root of a binary search tree (BST) and an integer `k`, return the `k`th smallest value (1-indexed) of all the values of the nodes in the tree.

Kth Smallest Element in a BST

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes `p` and `q`. The LCA is the lowest node in the tree that has both `p` and `q` as descendants.

Lowest Common Ancestor of a Binary Tree

Given a list of words sorted lexicographically in an unknown language, determine the order of characters in the alphabet of that language. If no valid ordering exists, return an empty string.

Alien Dictionary

Given two strings `s` and `t`, return the minimum window in `s` that contains all the characters in `t`. If no such window exists, return an empty string `""`.

Minimum Window Substring

A logistics company must transport items from n warehouses to a distribution center.  The i-th warehouse contains `warehouses[i]` items. The company has allocated `h` truck  trips to complete this task.
Truck Rules: - Each truck has a fixed capacity `k` (maximum items it can carry in one trip) - One warehouse per trip: A truck can only visit one warehouse per trip - Partial loads count: If a warehouse has fewer than `k` items left, the truck takes 
  all remaining items in one trip

Your goal is to find the **smallest possible truck capacity `k`** such that all items  can be transported within `h` trips.


Minimum Truck Size to Finish Pickups

Given a string `s`, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.

Valid Palindrome

Given a string `s` containing just the characters `(`, `)`, `{`, `}`, `[` and `]`, determine if the input string is valid. An input string is valid if
- Open brackets must be closed by the same type of brackets.
- Open brackets must be closed in the correct order.
- Every closing bracket has a corresponding open bracket of the same type.


Valid Parentheses

Given the head of a singly linked list, reverse the list and return the new head.

Reverse Linked List

Given two sorted linked lists, merge them into one sorted linked list and return the head of the merged list.

Merge Two Sorted Lists

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.

Min Stack

You are climbing a staircase. It takes `n` steps to reach the top. Each time you can climb `1` or `2` steps. In how many distinct ways can you reach the top?

Climbing Stairs

Given an array of strings `tokens` representing an arithmetic expression in Reverse Polish Notation (RPN), evaluate the expression and return the result.

Evaluate Reverse Polish Notation

Given an array of strings `strs`, group the anagrams together. An anagram is a word formed by rearranging the letters of another word.

Group Anagrams

Given an array `height` where `height[i]` represents the elevation at index `i`, compute how much water can be trapped after raining.

Trapping Rain Water

Given an array of intervals where `intervals[i] = [start, end]`, merge all overlapping intervals and return an array of the non-overlapping intervals that cover all the intervals in the input.

Merge Intervals

Given an array of `k` linked lists, where each linked list is sorted in ascending order, merge all the linked lists into one sorted linked list and return it.

Merge K Sorted Lists

Design a Least Recently Used (LRU) cache that supports `get(key)` and `put(key, value)`, both in O(1) time complexity.

LRU Cache

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. However, you cannot rob two adjacent houses. Given an integer array `nums` representing the amount of money at each house, return the maximum amount of money you can rob without alerting the police.

House Robber

Given an integer array `coins` representing different denominations and an integer `amount`, return the fewest number of coins needed to make up that amount. If it is impossible, return `-1`.

Coin Change

Given an array `nums` where `nums[i]` represents the maximum jump length from index `i`, determine if you can reach the last index.

Jump Game

Given the root of a binary tree, determine if it is a valid binary search tree (BST). A valid BST must satisfy the following conditions
- The left subtree of a node contains only nodes with values less than the node's value.
- The right subtree of a node contains only nodes with values greater than the node's value.
- Both left and right subtrees must also be binary search trees.


Validate Binary Search Tree

Given an array of points where `points[i] = [xi, yi]` represents a point on the X-Y plane, return the `k` closest points to the origin `(0,0)`. The distance between two points is calculated using the Euclidean distance formula.

K Closest Points to Origin

Given an integer array `nums` and an integer `k`, return the `k`th largest element in the array. Note that it is the `k`th largest element in sorted order, not the `k`th distinct element.

Kth Largest Element in an Array

Monster 50

Blind 75 is the go-to list for interview prep, but most platforms make you tackle it alone. On AlgoMonster, each problem is backed by the core patterns you've already learned, so you're not just guessing — you're applying real techniques. And if you mess up, we'll tell you exactly where you went wrong and how to fix it. It's the Blind 75, but finally with actual support.


Given an unsorted array of integers `nums`, return *the length of the longest consecutive elements sequence.*

You must write an algorithm that runs in `O(n)` time.


Longest Consecutive Sequence

Given a string s, return the longest palindromic substring in s. A palindrome is a string that reads the same backward as forward.

Longest Palindromic Substring

Given a reference of a node in a connected undirected graph, return a deep copy (clone) of the graph. Each node in the graph contains a val (int) and a list (List[Node]) of its neighbors.

Clone Graph

Given n nodes labeled from 0 to n-1 and a list of undirected edges (each edge is a pair of nodes), write a function to check whether these edges make up a valid tree. A valid tree must have exactly n-1 edges and be fully connected.

Graph Valid Tree

Given a string s, return the number of palindromic substrings in it. A substring is a contiguous sequence of characters within the string. A palindrome is a string that reads the same backward as forward.

Palindromic Substrings

Given a string s and a dictionary of strings wordDict, return true if s can be segmented into a space-separated sequence of one or more dictionary words. The same word in the dictionary may be reused multiple times in the segmentation.

Word Break

Given the head of a linked list, determine if the linked list has a cycle in it. A cycle exists if there is some node in the list that can be reached again by continuously following the next pointer.

Linked List Cycle

Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.

Missing Number

Design an algorithm to encode a list of strings to a string. The encoded string is then sent over the network and is decoded back to the original list of strings. Please implement encode and decode functions.

Encode and Decode Strings

Given the head of a linked list, remove the n-th node from the end of list and return its head. The list may be empty, and n is always valid (1 ≤ n ≤ length of list).

Remove Nth Node From End of List

Given an integer array nums, find a contiguous non-empty subarray within the array that has the largest product, and return the product. The test cases are generated so that the answer will fit in a 32-bit integer.

Maximum Product Subarray

There is an integer array nums sorted in ascending order (with distinct values). Prior to being passed to your function, nums is possibly rotated at an unknown pivot index k (1 <= k < nums.length). Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums. You must write an algorithm with O(log n) runtime complexity.

Search in Rotated Sorted Array

There is an m x n rectangular island that borders both the Pacific Ocean and Atlantic Ocean. The Pacific Ocean touches the island's left and top edges, and the Atlantic Ocean touches the island's right and bottom edges. The island is partitioned into a grid of square cells. You are given an m x n integer matrix heights where heights[r][c] represents the height above sea level of the cell at coordinate (r, c). The island receives a lot of rain, and the rain water can flow to neighboring cells directly north, south, east, and west if the neighboring cell's height is less than or equal to the current cell's height. Water can flow from any cell adjacent to an ocean into the ocean. Return a 2D list of grid coordinates result where result[i] = [ri, ci] denotes that rain water can flow from cell (ri, ci) to both the Pacific and Atlantic oceans.

Pacific Atlantic Water Flow

The median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value and the median is the mean of the two middle values. For example, for arr = [2,3,4], the median is 3. For arr = [2,3], the median is (2 + 3) / 2 = 2.5. Implement the MedianFinder class: MedianFinder() initializes the MedianFinder object. void addNum(int num) adds the integer num from the data stream to the data structure. double findMedian() returns the median of all elements so far. Answers within 10^-5 of the actual answer will be accepted.


Find Median from Data Stream

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment. Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure. Clarification: The input/output format is the same as how LeetCode serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.


Serialize and Deserialize Binary Tree

You are given a string s and an integer k. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most k times. Return the length of the longest substring containing the same letter you can get after performing the above operations.

Longest Repeating Character Replacement

Given an integer array nums, return the length of the longest strictly increasing subsequence. A subsequence is a sequence that can be derived from an array by deleting some or no elements without changing the order of the remaining elements.

Longest Increasing Subsequence

You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise). You have to rotate the image in-place, which means you have to modify the input 2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.

Rotate Image

Given an array of intervals intervals where intervals[i] = [starti, endi], return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.

Non-overlapping Intervals

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

Maximum Subarray

Given an m x n matrix, return all elements of the matrix in spiral order. Spiral order starts from the top-left corner and moves in a clockwise spiral pattern.

Spiral Matrix

You are given an array of non-overlapping intervals intervals where intervals[i] = [starti, endi] represent the start and the end of the ith interval and intervals is sorted in ascending order by starti. You are also given an interval newInterval = [start, end] that represents the start and end of another interval. Insert newInterval into intervals such that intervals is still sorted in ascending order by starti and intervals still does not have any overlapping intervals (merge overlapping intervals if necessary).

Insert Interval

Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values as subRoot and false otherwise. A subtree of a binary tree tree is a tree that consists of a node in tree and all of this node's descendants. The tree tree could also be considered as a subtree of itself. An empty tree is considered a subtree of any tree.

Subtree of Another Tree

There is a robot on an m x n grid. The robot is initially located at the top-left corner (i.e., grid[0][0]). The robot tries to move to the bottom-right corner (i.e., grid[m-1][n-1]). The robot can only move either down or right at any point in time. Given the two integers m and n, return the number of possible unique paths that the robot can take to reach the bottom-right corner.

Unique Paths

Reverse bits of a given 32 bits unsigned integer. Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as a signed integer type. You should treat it as an unsigned integer and reverse its bits.

Reverse Bits

Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the Hamming weight). Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as a signed integer type. You should treat it as an unsigned integer and return the number of '1' bits it has.

Number of 1 Bits

Given an undirected graph with n nodes and edges, return the number of connected components in the graph. A connected component is a subgraph in which any two vertices are connected to each other by at least one path, and which is connected to no additional vertices in the supergraph.

Number of Connected Components in an Undirected Graph

Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's. You must do it in place.

Set Matrix Zeroes

Given an integer n, return an array ans of length n + 1 such that for each i (0 ≤ i ≤ n), the number of 1's in the binary representation of i is stored in ans[i].

Counting Bits

Given an m x n board of characters and a list of strings words, return all words on the board. Each word must be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.

Word Search II

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are arranged in a circle. That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have a security system connected, and it will automatically contact the police if two adjacent houses were broken into on the same night. Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.

House Robber II

Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.

Contains Duplicate

A message containing letters from A-Z can be encoded into numbers using the following mapping: 'A' -> "1", 'B' -> "2", ..., 'Z' -> "26". To decode an encoded message, all the digits must be grouped and then mapped back into letters using the reverse of the mapping above (there may be multiple ways). For example, "11106" can be mapped into "AAJF" with the grouping (1 1 10 6), but it can also be mapped into "KJF" with the grouping (11 10 6). Note that the grouping (1 11 06) is invalid because "06" cannot be mapped into 'F' since "6" is different from "06". Given a string s containing only digits, return the number of ways to decode it.


Decode Ways

Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order.

Top K Frequent Elements

Given an array of meeting time intervals intervals where intervals[i] = [starti, endi], return the minimum number of conference rooms required.

Meeting Rooms II

Given the root of a binary tree, invert the tree, and return its root. Inverting a binary tree means that the left and right children of each node are swapped.

Invert Binary Tree

Given two strings text1 and text2, return the length of their longest common subsequence. A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

Longest Common Subsequence

Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.

Construct Binary Tree from Preorder and Inorder Traversal

Given two integers a and b, return the sum of the two integers without using the operators + and -.

Sum of Two Integers

Given an array of meeting time intervals where intervals[i] = [starti, endi], determine if a person could attend all meetings.

Meeting Rooms

A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence at most once. The path sum is the sum of the node values in the path. Given the root of a binary tree, return the maximum path sum of any non-empty path.

Status	Problem	Difficulty	Video	Actions
		Medium
		Easy
		Medium
		Medium
		Medium
		Medium
		Medium
		Medium
		Medium
		Easy
		Easy
		Medium
		Medium
		Hard
		Medium
		Medium
		Easy
		Easy
		Hard
		Medium
		Medium
		Medium
		Medium
		Medium
		Hard
		Hard
		Medium
		Medium
		Medium
		Medium
		Medium
		Medium
		Medium
		Medium
		Medium
		Medium
		Easy
		Medium
		Easy
		Easy
		Medium
		Medium
		Easy
		Medium
		Medium
		Medium
		Hard
		Easy
		Medium
		Medium
		Medium
		Easy
		Hard
		Medium
		Easy
		Medium
		Medium
		Medium
		Medium
		Easy
		Easy
		Medium
		Medium
		Medium
		Easy
		Medium
		Medium
		Medium
		Medium
		Easy
		Easy
		Hard
		Easy

The classic grind — now upgraded with feedback.