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 a string s, find the length of the longest substring without repeating characters.

Longest Substring Without Repeating Characters

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

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 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 a string `s`, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.

Valid Palindrome

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

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

Min Stack

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

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

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

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

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

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

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

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

Implement Trie (Prefix Tree)

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 `nums` where `nums[i]` represents the maximum jump length from index `i`, determine if you can reach the last index.

Status	Problem	Difficulty	Actions
	Best Time to Buy and Sell Stock	Easy
	Longest Substring Without Repeating Characters	Medium
	Minimum Window Substring	Hard
	Valid Parentheses	Easy
	Evaluate Reverse Polish Notation	Medium
	Valid Palindrome	Easy
	Container With Most Water	Medium
	Trapping Rain Water	Hard
	Binary Search	Easy
	Two Sum	Easy
	3Sum	Medium
	Group Anagrams	Medium
	Product of Array Except Self	Medium
	Min Stack	Medium
	Daily Temperatures	Medium
	Largest Rectangle in Histogram	Hard
	Find Minimum in Rotated Sorted Array	Medium
	Search a 2D Matrix	Medium
	Find Peak Element	Medium
	Newspapers	Hard
	Same Tree	Easy
	Maximum Depth of Binary Tree	Easy
	Binary Tree Level Order Traversal	Medium
	Validate Binary Search Tree	Medium
	Kth Smallest Element in a BST	Medium
	Lowest Common Ancestor of a Binary Tree	Medium
	Combination Sum	Medium
	Word Search	Medium
	N-Queens	Hard
	Alien Dictionary	Hard
	Flood Fill	Easy
	Minimum Knight Moves	Medium
	Number of Islands	Medium
	Course Schedule	Medium
	Word Ladder	Hard
	K Closest Points to Origin	Medium
	Kth Largest Element in an Array	Medium
	Reverse Linked List	Easy
	Merge Two Sorted Lists	Easy
	Middle of the Linked List	Easy
	Reorder List	Medium
	Merge K Sorted Lists	Hard
	LRU Cache	Medium
	Climbing Stairs	Easy
	House Robber	Medium
	Coin Change	Medium
	Implement Trie (Prefix Tree)	Medium
	Merge Intervals	Medium
	Jump Game	Medium

Monster 50 Guided Practice