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.

BFS on a Matrix

Flood Fill

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

Sliding Window Flexible - Longest

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.

Backtracking - Basic

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.

Backtracking - Aggregation

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.

Two Pointers (Same Direction)

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.

DFS on Tree

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).

BFS on Tree

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.

Prefix Sum

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`.

Mono Stack

Daily Temperatures

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

Trie

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 nodes 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.

Two Pointers (Opposite Direction)

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`.

Topological Sort

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.

BFS on Graphs

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 `""`.

Sliding Window Flexible - Shortest

Minimum Window Substring

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.

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

Monster 50 Guided Practice