Skip to content

DragonSSS/curated-list-of-top-75-leetcode-questions

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

1,433 Commits

.github

.github

 
 

.vscode

.vscode

 
 

gradle/wrapper

gradle/wrapper

 
 

leetcode

leetcode

 
 

.gitignore

.gitignore

 
 

LICENSE

LICENSE

 
 

Makefile

Makefile

 
 

README.md

README.md

 
 

build.gradle

build.gradle

 
 

gradlew

gradlew

 
 

gradlew.bat

gradlew.bat

 
 

revisit.md

revisit.md

 
 

settings.gradle

settings.gradle

 
 

Repository files navigation

curated-list-of-coding-questions-master Actions Status

Curated List of Top 75 LeetCode Questions

TL;DR

source

Array (10)

Binary (5)

  • LeetCode #371 Sum of Two Integers

    • description
    • solution
    • hint: use carry with shift 1 to get common components, xor operation is to get opposite components

  • LeetCode #191 Number of 1 Bits

  • LeetCode #338 Counting Bits

    • description
    • solution
    • hint: dp, n is 2^x (dp[n] = 1) or n % 2 == 0 (dp[n] = dp[n / 2]) or n % 2 == 1 (dp[n] = dp[n - 1] + 1)

  • LeetCode #268 Missing Number

  • LeetCode #190 Reverse Bits

Dynamic Programming (11)

  • LeetCode #70 Climbing Stairs

  • LeetCode #332 Coin Change

  • LeetCode #300 Longest Increasing Subsequence

    • description
    • solution
    • hint: two pointers of current index and previous index (start with -1) + recursion + memorization, or dp

  • LeetCode #1143 Longest Common Subsequence

  • LeetCode #139 Word Break

  • LeetCode #377 Combination Sum IV

  • LeetCode #198 House Robber

  • LeetCode #213 House Robber II

  • LeetCode #91 Decode Ways

  • LeetCode #62 Unique Paths

  • LeetCode #55 Jump Game

Graph (8)

  • LeetCode #133 Clone Graph (NeetCode 150)

  • LeetCode #207 Course Schedule

  • LeetCode #417 Pacific Atlantic Water Flow

  • LeetCode #200 Number of Islands

  • LeetCode #128 Longest Consecutive Sequence (NeetCode 150)

    • description
    • solution
    • hint: sort first + iteration with while loop (could use union-find or hashtable as well)

  • LeetCode #269 Alien Dictionary

  • LeetCode #261 Graph Valid Tree

  • LeetCode #323 Number of Connected Components in an Undirected Graph

Interval (5)

  • LeetCode #57 Insert Interval (NeetCode 150)

    • description
    • solution
    • hint: if newInterval[1] < interval[0] else if newInterval[0] > interval[1] else do sth

  • LeetCode #56 Merge Intervals (NeetCode 150)

    • description
    • solution
    • hint: same as Insert Interval, if newInterval[1] < interval[0] else if newInterval[0] > interval[1] else do sth

  • LeetCode #435 Non-overlapping Intervals (NeetCode 150)

    • description
    • solution
    • hint: sort array first by start of interval, record preEnd and compare it with intervals

  • LeetCode #252 Meeting Rooms (NeetCode 150)

    • description
    • solution
    • hint: sort array first by start of interval, compare two intervals with sliding window size of 2

  • LeetCode #253 Meeting Rooms II (NeetCode 150)

    • description
    • solution
    • hint: sort array first by start of interval, use priorityQueue (sorted by end of interval) to record the intervals as required rooms

Linked List (6)

  • LeetCode #206 Reverse Linked List

  • LeetCode #141 Linked List Cycle

  • LeetCode #21 Merge Two Sorted Lists

  • LeetCode #23 Merge k Sorted Lists

  • LeetCode #19 Remove Nth Node From End of List

  • LeetCode #143 Reorder List

    • description
    • solution
    • hint: find the mid to split two linked lists, reverse second one and merge two linked list into one

Matrix (4)

  • LeetCode #73 Set Matrix Zeroes (NeetCode 150)

  • LeetCode #54 Spiral Matrix (NeetCode 150)

    • description
    • solution
    • hint: four pointers for corners: top, bottom, left and right when res.size() < m * n

  • LeetCode #48 Rotate Image (NeetCode 150)

    • description
    • solution
    • hint: clockwise rotate = reverse up to down + swap the symmetry, anticlockwise = reverse left to right + swap the symmetry

  • LeetCode #79 Word Search

String (10)

  • LeetCode #3 Longest Substring Without Repeating Characters

  • LeetCode #424 Longest Repeating Character Replacement

  • LeetCode #76 Minimum Window Substring

  • LeetCode #242 Valid Anagram

  • LeetCode #49 Group Anagrams

  • LeetCode #20 Valid Parentheses

  • LeetCode #125 Valid Palindrome (NeetCode 150)

  • LeetCode #5 Longest Palindromic Substring

  • LeetCode #647 Palindromic Substrings

  • LeetCode #271 Encode and Decode Strings

Tree (14)

  • LeetCode #104 Maximum Depth of Binary Tree

  • LeetCode #100 Same Tree

  • LeetCode #266 Invert Binary Tree

  • LeetCode #124 Binary Tree Maximum Path Sum

  • LeetCode #102 Binary Tree Level Order Traversal

  • LeetCode #297 Serialize and Deserialize Binary Tree

    • description
    • solution
    • hint: tree traversal (pre-order, in-order and post-order), bfs iteratively and dfs recursively

  • LeetCode #572 Subtree of Another Tree

  • LeetCode #105 Construct Binary Tree from Preorder and Inorder Traversal

    • description
    • solution
    • hint: recursion + use preorder to find root + use inorder to split array into right and left tree

  • LeetCode #208 Implement Trie (Prefix Tree)

  • LeetCode #98 Validate Binary Search Tree

    • description
    • solution
    • hint: preorder traversal + stack or recursion with max and min boundaries

  • LeetCode #235 Lowest Common Ancestor of a Binary Search Tree

  • LeetCode #212 Word Search II

  • LeetCode #230 Kth Smallest Element in a BST

  • LeetCode #211 Design Add and Search Words Data Structure

Heap (3)

  • LeetCode #23 Merge k Sorted Lists

  • LeetCode #347 Top K Frequent Elements

  • LeetCode #295 Find Median from Data Stream

    • description
    • solution
    • hint: two priorityQueue as heaps, smallHalf as maxHeap, largeHalf as minHeap

High Frequency (Bonus)

Graph

  • LeetCode #1761 Minimum Degree of a Connected Trio in a Graph

    • description
    • solution
    • hint: compute degree for each node, build hashmap for each edge to indicate if it is a edge with given two nodes, calculate min degree by sum of degree of three nodes in a trio

  • LeetCode #684 Redundant Connection (NeetCode 150)

    • description
    • solution
    • hint: union-find or recurisvely dfs graph before adding the current edge into graph

  • LeetCode #785 Is Graph Bipartite

  • LeetCode #1584 Min Cost to Connect All Points (NeetCode 150)

    • description
    • solution
    • hint: minimum spaning tree (MST) using Prim's algorithm (BFS with minHeap) or Kruskal's algorithm (union-find with minHeap that tracks the distance between each pair of nodes)

  • LeetCode #2115 Find All Possible Recipes from Given Supplies

  • LeetCode #1101 The Earliest Moment When Everyone Become Friends

  • LeetCode #802 Find Eventual Safe States

  • LeetCode #947 Most Stones Removed with Same Row or Column

    • description
    • solution
    • hint: dfs or union-find, the most stones that can be removed = number of stones - number of islands (same row or column of stones are treated as island)

  • LeetCode #791 Accounts Merge

  • LeetCode #2204 Distance to a Cycle in Undirected Graph

    • description
    • solution
    • hint: dfs (find all nodes in the cycle) + bfs (find min distance to the cycle)

  • LeetCode #1615 Maximal Network Rank

  • LeetCode #2642 Design Graph With Shortest Path Calculator

DFS

  • LeetCode #332 Reconstruct Itinerary

    • description
    • solution
    • hint: post traversal with removing edge: dfs + priorityQueue + list.add(0, ticket) for reverse result list or backtracking with dfs

  • LeetCode #529 Minesweeper

  • LeetCode #547 Number of Provinces

  • LeetCode #695 Max Area of Island

  • LeetCode #934 Shortest Bridge

  • LeetCode #341 Flatten Nested List Iterator

  • LeetCode #694 Number of Distinct Islands

    • description
    • solution
    • hint: dfs recursion, use appending string of directions to store unique shape of island. remember to append back after recursion

  • LeetCode #339 Nested List Weight Sum

  • LeetCode #363 Nested List Weight Sum II

    • description
    • solution
    • hint: two dfs recursion, one find max depth, the other calculate weight sum

  • LeetCode #399 Evaluate Division

    • description
    • solution
    • hint: build graph based on each equation, dfs to find each result of query

  • LeetCode #463 Island Perimeter

    • description
    • solution
    • hint: dfs recursion + memorization, trick is to make the condition when return 1 or 0 in recursion func.

  • LeetCode #329 Longest Increasing Path in a Matrix (NeetCode 150)

  • LeetCode #733 Flood Fill

  • LeetCode #472 Concatenated Words

    • description
    • solution
    • hint: use trie to store all words, dfs for each word with memeorization and check existence of prefix word by TrieNode.isWord

  • LeetCode #827 Making A Large Island

    • description
    • solution
    • hint: group island using group index, calcualte group area by dfs and save <group, area> to a map, try four directions for each gird[][] == 0 and use hash set to track visited groups, record largest area

  • LeetCode #1192 Critical Connections in a Network

    • description
    • solution
    • hint: Tarjan's algorithm, record visitedTimes and lowTimes for each node, dfs with visited set, track previous node and current node

  • LeetCode #582 Kill Process

  • LeetCode #256 Paint House

  • LeetCode #1905 Count Sub Islands

  • LeetCode #2101 Detonate the Maximum Bombs

  • LeetCode #419 Battleships in a Board

  • LeetCode #1236 Web Crawler

  • LeetCode #1242 Web Crawler Multithreaded

  • LeetCode #886 Possible Bipartition

  • LeetCode #576 Out of Boundary Paths

  • LeetCode #1239 Maximum Length of a Concatenated String with Unique Characters

BFS

  • LeetCode #103 Binary Tree Zigzag Level Order Traversal

  • LeetCode #301 Remove Invalid Parentheses

    • description
    • solution
    • hint: dfs, use count as stack to figure out where delete invalid char, record lastRemove position, reverse string for another round dfs to cover the case with more left parentheses

  • LeetCode #310 Minimum Height Trees

  • LeetCode #127 Word Ladder

    • description
    • solution
    • hint: bfs, find next possible word by replacing one character every time

  • LeetCode #815 Bus Routes

    • description
    • solution
    • hint: bfs finds shortest number of buses from source to target, build graph based on which buses (value) could reach each stop (key)

  • LeetCode #1197 Minimum Knight Moves

    • description
    • solution
    • hint: only bfs on positive ones instead of searching both positieve and negative

  • LeeCode #909 Snakes and Ladders

    • description
    • solution
    • hint: bfs with square value 1 to n^2, one tricky function for converting square one 1 to n^2 to board matrix value board[x][y]

  • LeetCode #126 Word Ladder II

    • description
    • solution
    • hint: use bfs to build the graph and record the distance between beginWord and currentWord, use dfs to find all shortest paths between beginWord and endWord

  • LeetCode #210 Course Schedule II

    • description
    • solution
    • hint: topological sort with bfs or dfs with int[] visited, 0 - unknown, 1 - visiting, 2 - visited to detect existing circle.

  • LeetCode #1730 Shortest Path to Get Food

  • LeetCode #752 Open the Lock

  • LeetCode #279 Perfect Squares

  • LeetCode #994 Rotting Oranges

  • LeetCode #863 All Nodes Distance K in Binary Tree

    • description
    • solution
    • hint: convert tree to graph via hashmap(parent node <=> child nodes), avoid duplicates via hashset, bfs with queue or dfs with recursion

  • LeetCode #1291 Sequential Digits

    • description
    • solution
    • hint: add 1 - 9 into queue, every time poll one number, get lowerest single digit by % 10, add next one cur * 10 + singleDigit + 1 only if <= high and singleDigit < 9

  • LeetCode #1091 Shortest Path in Binary Matrix

  • LeetCode #818 Race Car

    • description
    • solution
    • hint: bfs, try overshooting, and detect overshooting asap with trying reverse

  • LeetCode #1293 Shortest Path in a Grid with Obstacles Elimination

    • description
    • solution
    • hint: bfs, with int[]{x, y, k} where k is number of elimination step left

  • LeetCode #286 Walls and Gates

  • LeetCode #317 Shortest Distance from All Buildings

  • LeetCode #1466 Reorder Routes to Make All Paths Lead to the City Zero

    • description
    • solution
    • hint: dfs or bfs starts with zero city, reverse current connection, cost 1, reverse reversed current connection, cost 0

  • LeetCode #691 Stickers to Spell Word

  • LeetCode #490 The Maze

  • LeetCode #1136 Parallel Courses

  • LeetCode #2050 Parallel Courses III

  • LeetCode #542 01 Matrix

  • LeetCode #1376 Time Needed to Inform All Employees

  • LeetCode #2385 Amount of Time for Binary Tree to Be Infected

  • LeetCode #2850 Minimum Moves to Spread Stones Over Grid

  • LeetCode #2477 Minimum Fuel Cost to Report to the Capital

Array

  • LeetCode #4 Median of Two Sorted Arrays (NeetCode 150)

    • description
    • solution
    • hint: binary search with the shortest array, cut two arrays and compare leftMax/rightMin

  • LeetCode #42 Trapping Rain Water

    • description
    • solution
    • hint: two pointers or you can use two arrays to record leftMax and rightMax (int bit = Math.min(left[i], right[i]) - height[i])

  • LeetCode #162 Find Peak Element

    • description
    • solution
    • hint: linear scan to find the first index that drops or binary search via comparing nums[mid] and nums[mid + 1]

  • LeetCode #1235 Maximum Profit in Job Scheduling

  • LeetCode #811 Subdomain Visit Count

  • LeetCode #1710 Maximum Units on a Truck

  • LeetCode #937 Reorder Data in Log Files

  • LeetCode #1152 Analyze User Website Visit Pattern

    • description
    • solution
    • hint: build userToSite map by Map<String, TreeMap<Integer, String>> where timeToSite map is TreeMap<Integer, String>, build sequenceCount map by Map<String, Integer>

  • LeetCode #1151 Minimum Swaps to Group All 1's Together

    • description
    • solution
    • hint: result is allOnes - maxOnesInWindow where window size is allOnes or use deque to maintain the window size

  • LeetCode #2134 Minimum Swaps to Group All 1's Together II

    • description
    • solution
    • hint: address circular array by doubling array, the result is allOnes - maxOnesInWindow where window size is allOnes

  • LeetCode #1481 Least Number of Unique Integers after K Removals

    • description
    • solution
    • hint: use hashtable to store value with its frequency, use priorityQueue to store values by comparing their frequencies

  • LeetCode #986 Interval List Intersections

  • LeetCode #1366 Rank Teams by Votes

  • LeetCode #1567 Maximum Length of Subarray With Positive Product

    • description
    • solution
    • hint: record latest zeroIndex(-1) and first negativeIndex(-1), update max length by i - zeroIndex and i - negativeIndex only if negativeCount%2 != 0

  • LeetCode #167 Two Sum II - Input Array Is Sorted (NeetCode 150)

  • LeetCode #881 Boats to Save People

    • description
    • solution
    • hint: two pointers + greedy, try to put heaviest and lightest ppl in one boat if possible

  • LeetCode #554 Brick Wall

    • description
    • solution
    • hint: use hashtable to store the width index of bricks with its count, so the result is wall.size() - maxCount, not consider the last brick

  • LeetCode #118 Pascal's Triangle

  • LeetCode #605 Can Place Flowers

  • LeetCode #838 Push Dominoes

    • description
    • solution
    • hint: calculate force on each domino, scan from left to right and right to left

  • LeetCode #665 Non-decreasing Array

  • LeetCode #75 Sort Colors

  • LeetCode #1498 Number of Subsequences That Satisfy the Given Sum Condition

  • LeetCode #1968 Array With Elements Not Equal to Average of Neighbors

    • description
    • solution
    • hint: greedy + two pointers, use the pattern: small, big, small, big..on sorted array

  • LeetCode #16 3Sum Closest

    • description
    • solution
    • hint: three pointers, track the diff between current sum and target sum, return target sum - diff

  • LeetCode #416 Partition Equal Subset Sum

    • description
    • solution
    • hint: dfs + memorization, calculate sum and use half of sum as target sum for subset array, Boolean memo[index][target sum + 1]

  • LeetCode #39 Combination Sum

  • LeetCode #2244 Minimum Rounds to Complete All Tasks

  • LeetCode #36 Valid Sudoku

  • LeetCode #904 Fruit Into Baskets

  • LeetCode #1343 Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold

  • LeetCode #1658 Minimum Operations to Reduce X to Zero

  • LeetCode #905 Sort Array By Parity

  • LeetCode #896 Monotonic Array

  • LeetCode #1218 Longest Arithmetic Subsequence of Given Difference

  • LeetCode #852 Peak Index in a Mountain Array

  • LeetCode #1823 Find the Winner of the Circular Game

  • LeetCode #1838 Frequency of the Most Frequent Element

  • LeetCode #1493 Longest Subarray of 1's After Deleting One Element

  • LeetCode #1004 Max Consecutive Ones III

  • LeetCode #2747 Count Zero Request Servers

  • LeetCode #2870 Minimum Number of Operations to Make Array Empty

  • LeetCode #2007 Find Original Array From Doubled Array

  • LeetCode #1700 Number of Students Unable to Eat Lunch

  • LeetCode #163 Missing Ranges

    • description
    • solution
    • hint: check boundaries of sorted array with lower and upper limits, loop the sorted array with checking nums[i + 1] - nums[i] <= 1

Binary Search

  • LeetCode #540 Single Element in a Sorted Array

    • description
    • solution
    • hint: check left and right boundaries first, check nums[mid] == nums[mid + 1] or nums[mid] == nums[mid + 1], then check if number of elements at right half is even

  • LeetCode #875 Koko Eating Bananas (NeetCode 150)

    • description
    • solution
    • hint: binary search with speed k start=1 and end=max(piles[x]), calculate current hours with speed mid, compare current hours with provided h

  • LeetCode #1891 Cutting Ribbons

    • description
    • solution
    • hint: binary search, start with left 1 and right max(ribbons), calculate current k number of ribbons using mid and compare with required k

  • LeetCode #74 Search a 2D Matrix (NeetCode 150)

  • LeetCode #278 First Bad Version

  • LeetCode #678 Find K Closest Elements

  • LeetCode #1011 Capacity To Ship Packages Within D Days

  • LeetCode #1898 Maximum Number of Removable Characters

  • LeetCode #441 Arranging Coins

  • LeetCode #2616 Minimize the Maximum Difference of Pairs

  • LeetCode #1060 Missing Element in Sorted Array

  • LeetCode #1539 Kth Missing Positive Number

Prefix Sum

  • LeetCode #560 Subarray Sum Equals K

    • description
    • solution
    • hint: sum[i, j] = prefixSum[0, j] - prefixSum[0, i], use hastable to store prefix sum and its frequency

  • LeetCode #370 Range Addition

    • description
    • solution
    • hint: prefix sum by only applying value at the index of start and end + 1

  • LeetCode #528 Random Pick with Weight

    • description
    • solution
    • hint: use prefix sum to build an arry, randomly generate value between [0, totalSum], binary search to return target index

  • LeetCode #862 Shortest Subarray with Sum at Least K (Monotonic Queue)

    • description
    • solution
    • hint: calculate prefix sum array (size is array.length + 1) from [0] to [array.length], use deque to store and maintain start indexes, before adding i index during iteration, check prefixSum[i] - prefixSum[startIndexes.peek()] >= k and prefixSum[i] <= prefixSum[startIndexes.peekLast()]

  • LeetCode #2100 Find Good Days to Rob the Bank

    • description
    • solution
    • hint: use to arrays to track non-increase (forward) nonincrease[i - 1] and non-decrease (backward) nondecrease[i + 1] days at current day[i], use time to decide which day is fine

  • LeetCode #523 Continuous Subarray Sum

  • LeetCode #2055 Plates Between Candles

    • description
    • solution
    • hint: for each index of string, find the index of first left candle and the index of first right candle by using two arrays, count prefix sum of candles for each index, calculate the result by res[index] = rightCandle - leftCandle + 1 - (candlePrefixSum[rightCandle] - candlePrefixSum[leftCandle] + 1);

  • LeetCode #724 Find Pivot Index

  • LeetCode #2017 Grid Game

    • description
    • solution
    • hint: prefix sum, the path of robot 2 is predictable with robot 1's path

  • LeetCode #2483 Minimum Penalty for a Shop

    • description
    • solution
    • hint: prefix sum, assume close at index 0 to calculate penalty, then iterate from index 1 with close

Dynamic Programming

  • LeetCode #741 Cherry Pickup

    • description
    • solution
    • hint: simulate two ppl collect cherries together to right-down corner cell, return Integer.MIN_VALUE for invalid path

  • LeetCode #343 Integer Break

    • description
    • solution
    • hint: use dp array to record max product for i, the formula is dp[i] = Math.max(dp[i], Math.max(j * (i - j), dp[i - j] * j)); where i starts with 3 and j smaller than i

  • LeetCode #516 Longest Palindromic Subsequence

    • description
    • solution
    • hint: recursion with memorization, similar to #1143 Longest Common Subsequence

  • LeetCode #1312 Minimum Insertion Steps to Make a String Palindrome

    • description
    • solution
    • hint: similar to #516 Longest Palindromic Subsequence, figure out minimum number of add or deletion to make string palindrome by s.length() - lps.length()

  • LeetCode #740 Delete and Earn

  • LeetCode #72 Edit Distance (NeetCode 150)

  • LeetCode #1048 Longest String Chain

  • LeetCode #1220 Count Vowels Permutation

    • description
    • solution
    • hint: dp to track the number of string ending by each character ['a', 'e', 'i', 'o', 'u']

  • LeetCode #123 Best Time to Buy and Sell Stock III

  • LeetCode #97 Interleaving String (NeetCode 150)

  • LeetCode #494 Target Sum (NeetCode 150)

  • LeetCode #312 Burst Balloons (NeetCode 150)

    • description
    • solution
    • hint: dp + memorization, use left and right as range to split one question to sub problems, treat ith boolean to last hit instead of first hit

  • LeetCode #115 Distinct Subsequences (NeetCode 150)

  • LeetCode #10 Regular Expression Matching (NeetCode 150)

  • LeetCode #2222 Number of Ways to Select Buildings

    • description
    • solution
    • hint: kind of dp, result = number of 1..0..1 + number of 0..1..0 (.. could be blank), use one loop count number of 1, 0, 0..1 and 1..0

  • LeetCode #1553 Minimum Number of Days to Eat N Oranges

  • LeetCode #1105 Filling Bookcase Shelves

  • LeetCode #1387 Sort Integers by The Power Value

  • LeetCode #120 Triangle

  • LeetCode #1706 Where Will the Ball Fall

  • LeetCode #221 Maximal Square

  • LeetCode #877 Stone Game

  • LeetCode #799 Champagne Tower

  • LeetCode #486 Predict the Winner

  • LeetCode #714 Best Time to Buy and Sell Stock with Transaction Fee

Tree

  • LeetCode #236 Lowest Common Ancestor of a Binary Tree

  • LeetCode #95 Unique Binary Search Trees II

    • description
    • solution
    • hint: recursion (top-down) + calculate sub left tree and sub right tree, store new root node with these two sub trees

  • LeetCode #96 Unique Binary Search Trees

    • description
    • solution
    • hint: recursion (top-down) + memorization or dp: dp[i] += dp[j - 1] (left substree) * dp[i - j] (right subtree) where i is the number of node (value), j is the current root

  • LeetCode #103 Binary Tree Zigzag Level Order Traversal

  • LeetCode #199 Binary Tree Right Side View

    • description
    • solution
    • hint: bfs via queue to do level traversal and pick up last node at each level or dfs that starts with rightmost child and tracks the level of tree (node val is added into res only if level == res.size(), so that only add single node val per level if any node exists)

  • LeetCode #314 Binary Tree Vertical Order Traversal (Tree, BFS, even DFS or HashTable)

    • description
    • solution
    • hint: dfs to get min and max vertical levels (root is 0), bfs (two queues) to put node into res with vertical level, or hashtable(treemap, red-black tree) + bfs (two queues)

  • LeetCode #99 Recover Binary Search Tree

    • description
    • solution
    • hint: in-order traversal, use gloabl variables to track the previous, first, and second nodes. At end swap values between first and second nodes.

  • LeetCode #129 Sum Root to Leaf Numbers

  • LeetCode #222 Count Complete Tree Nodes

    • description
    • solution
    • hint: divide and conquer to get left and right height, then compare heights and do recursion if necessary

  • LeetCode #366 Find Leaves of Binary Tree

    • description
    • solution
    • hint: dfs and use height (number of edges to lowest node of subtree) as index of subarray in array

  • LeetCode #545 Boundary of Binary Tree

    • description
    • solution
    • hint: three recursion: findLeftBoundary, findRightBoundary and findLeaves

  • LeetCode #1372 Longest ZigZag Path in a Binary Tree

  • LeetCode #333 Largest BST Subtree

    • description
    • solution
    • hint: use an array { min, max, size } as a recursion func's result, similar to Validate Binary Search Tree

  • LeetCode #543 Diameter of Binary Tree

  • LeetCode #2096 Step-By-Step Directions From a Binary Tree Node to Another

    • description
    • solution
    • hint: find LCA of two nodes, traversal from LCA node to two nodes (start, end nodes) by recursion and backtracking to build the path, combine two path together (reverse the path from LCA node to start node, all U)

  • LeetCode #1448 Count Good Nodes in Binary Tree

  • LeetCode #337 House Robber III

    • description
    • solution
    • hint: dfs, use new int[2] as output of helper func, 2 array elements means two states: rob and non-rob

  • LeetCode #589 N-ary Tree Preorder Traversal

  • LeetCode #110 Balanced Binary Tree

    • description
    • solution
    • hint: calculate height of current node's left subtree and right substree recusively

  • LeetCode #437 Path Sum III

  • LeetCode #108 Convert Sorted Array to Binary Search Tree

  • LeetCode #101 Symmetric Tree

  • LeetCode #662 Maximum Width of Binary Tree

    • description
    • solution
    • hint: bfs, two queues: one is to track index of node, the other is to track tree node itself, check rightmost index and leftmost index: width = rightmost - leftmost + 1

  • LeetCode #938 Range Sum of BST

  • LeetCode #450 Delete Node in a BST

  • LeetCode #701 Insert into a Binary Search Tree

  • LeetCode #1361 Validate Binary Tree Nodes

    • description
    • solution
    • hint: check all nodes connected without a cycle and it is directed graph by dfs or bfs

  • LeetCode #515 Find Largest Value in Each Tree Row

  • LeetCode #1110 Delete Nodes And Return Forest

  • LeetCode #1530 Number of Good Leaf Nodes Pairs

  • LeetCode #1161 Maximum Level Sum of a Binary Tree

  • LeetCode #652 Find Duplicate Subtrees

  • LeetCode #894 All Possible Full Binary Trees

  • LeetCode #1382 Balance a Binary Search Tree

    • description
    • solution
    • hint: in-order traversal to get list of tree nodes + recontruct BST with index of list

  • LeetCode #1302 Deepest Leaves Sum

  • LeetCode #530 Minimum Absolute Difference in BST

  • LeetCode #1305 All Elements in Two Binary Search Trees

  • LeetCode #1008 Construct Binary Search Tree from Preorder Traversal

  • LeetCode #2265 Count Nodes Equal to Average of Subtree

  • LeetCode #1038 Binary Search Tree to Greater Sum Tree

  • LeetCode #270 Closest Binary Search Tree Value

    • description
    • solution
    • hint: while loop by comparing node val with target root = root.val > target ? root.left : root.right;

  • LeetCode #536 Construct Binary Tree from String

  • LeetCode #958 Check Completeness of a Binary Tree

LinkedList

  • LeetCode #61 Rotate List

    • description
    • solution
    • hint: make the linked list to a circle and count total number n of nodes, then iterate nodes and return new head using n - k % n - 1

  • LeetCode #1019 Next Greater Node In Linked List

    • description
    • solution
    • hint: use list to store all nodes, use monotonic stack to find array of next greater node

  • LeetCode #2130 Maximum Twin Sum of a Linked List

    • description
    • solution
    • hint: two points to break linkedlist into two parts, reverse second one, iterate two linkedlist

  • LeetCode #25 Reverse Nodes in k-Group (NeetCode 150)

    • description
    • solution
    • hint: reverse the linkedlist by recursion (using sub-linkedlist as split by group size k)

  • LeetCode #138 Copy List with Random Pointer (NeetCode 150)

  • LeetCode #287 Find the Duplicate Number (NeetCode 150)

    • description
    • solution
    • hint: linkedlist cycle detection by slow and fast pointers, floyd’s algorithm to find intersaction point

  • LeetCode #2 Add Two Numbers (NeetCode 150)

    • description
    • solution
    • hint: two linklist node pointers with while loop, take care of carry by sum / 10

  • LeetCode #328 Odd Even Linked List

  • LeetCode #876 Middle of the Linked List

  • LeetCode #142 Linked List Cycle II

  • LeetCode #234 Palindrome Linked List

    • description
    • solution
    • hint: slow and fast pointers, reverse second part and compare two sub linkedlists

  • LeetCode #148 Sort List

    • description
    • solution
    • hint: slow and fast pointers to split the linked list into two parts, sort on each part and merge them recursively (merge sort)

  • LeetCode #24 Swap Nodes in Pairs

  • LeetCode #1171 Remove Zero Sum Consecutive Nodes from Linked List

  • LeetCode #430 Flatten a Multilevel Doubly Linked List

  • LeetCode #2487 Remove Nodes From Linked List

  • LeetCode #160 Intersection of Two Linked Lists

  • LeetCode #708 Insert into a Sorted Circular Linked List

Stack

  • LeetCode #71 Simplify Path

    • description
    • solution
    • hint: use stack to track the parent directory, .. triggers stack.pop() and dir triggers stack.push(dir)

  • LeetCode #173 Binary Search Tree Iterator (Tree)

    • description
    • solution
    • hint: keep pushing left node into stack, if stack is not empty, it means hasNext() returns true. next() add right node into stack

  • LeetCode #496 Next Greater Element I

    • description
    • solution
    • hint: use stack to store the number that hasn't found next greater element, pop up if current one > peek of stack

  • LeetCode #503 Next Greater Element II

    • description
    • solution
    • hint: compared to #496 Next Greater Element I, loop twice and use stack to sore index instead

  • LeetCode #901 Online Stock Span

    • description
    • solution
    • hint: use monotonic stack to track consecutive days with less than or equal price of the day by stack<int[]> where arr[0] is the price and arr[1] is the number of consecutive days.

  • LeetCode #1249 Minimum Remove to Make Valid Parentheses

    • description
    • solution
    • hint: use stack to push index of (, pop index of ( if see ), record index ) if stack is empty, any index of ( in stack left, need to remove, and any recorded index ), need to remove

  • LeetCode #921 Minimum Add to Make Parentheses Valid

    • description
    • solution
    • hint: similar to #1249 Minimum Remove to Make Valid Parentheses, use count add ( at left side to record number of index ) if stack is empty, return stack.size() + count

  • LeetCode #772 Basic Calculator

    • description
    • solution
    • hint: use one stack to store nums and the other to store operators, handle edge cases of -(1 + 1) and 1-(-2) carefully

  • LeetCode #772 Basic Calculator II

  • LeetCode #772 Basic Calculator III

    • description
    • solution
    • hint: use one stack to store nums and the other to store operators/parenthese

  • LeetCode #1597 Build Binary Expression Tree From Infix Expression

    • description
    • solution
    • hint: use one stack to store nums and the other to store operators, create node instead of making operation

  • LeetCode #277 Find the Celebrity

    • description
    • solution
    • hint: push all people into stack, every time pop() two people to check, push() the people back to stack if he is possible celebrity

  • LeetCode #907 Sum of Subarray Minimums

    • description
    • solution
    • hint: monotonic stack to find index of preSmaller and nextSmaller for arr[i]

  • LeetCode #2281 Sum of Total Strength of Wizards

    • description
    • solution
    • hint: similar to Sum of Subarray Minimums, see the detailed comments within the code

  • LeetCode #2104 Sum of Subarray Ranges

    • description
    • solution
    • hint: similar to Sum of Subarray Minimums, could user monotonic stack to find index of preSmaller nextSmaller, preGreater and nextGreater for arr[i]

  • LeetCode #735 Asteroid Collision

  • LeetCode #1047 Remove All Adjacent Duplicates In String

  • LeetCode #1209 Remove All Adjacent Duplicates In String II

  • LeetCode #1963 Minimum Number of Swaps to Make the String Balanced

    • description
    • solution
    • hint: stack, trick is to calculate number of swap based size of stack, looking for a pattern, one swap could remove 4 invalid chars

  • LeetCode #1653 Minimum Deletions to Make String Balanced

  • LeetCode #456 132 Pattern

  • LeetCode #1762 Buildings With an Ocean View

  • LeetCode #636 Exclusive Time of Functions

    • description
    • solution
    • hint: use stack to store function id, and track the previous timestamp, branch code based on start or end

  • LeetCode #150 Evaluate Reverse Polish Notation

  • LeetCode #739 Daily Temperatures (NeetCode 150)

  • LeetCode #853 Car Fleet (NeetCode 150)

    • description
    • solution
    • hint: sorting + monotonic stack, calculate time based on distance and speed and sort data based on position/distance

  • LeetCode #84 Largest Rectangle in Histogram (NeetCode 150)

    • description
    • solution
    • hint: monotonic stack Stack<int[index, height]>(), look backward with start index with current height to push into stack if height decreases, look forward with non-empty stack (increasing height)

  • LeetCode #1944 Number of Visible People in a Queue

  • LeetCode #402 Remove K Digits

  • LeetCode #895 Maximum Frequency Stack

    • description
    • solution
    • hint: two hashmaps: Map<Integer, Integer> freqOfVal; Map<Integer, Stack<Integer>> freqToVals;

  • LeetCode #844 Backspace String Compare

  • LeetCode #394 Decode String

    • description
    • solution
    • hint: two stacks, one for digit value, the other for preious string result, track current built string

  • LeetCode #32 Longest Valid Parentheses

  • LeetCode #316 Remove Duplicate Letters

    • description
    • solution
    • hint: greedy + stack + hashmap to track last index of char presence, same as #1081

  • LeetCode #946 Validate Stack Sequences

  • LeetCode #856 Score of Parentheses

  • LeetCode #2751 Robot Collisions

  • LeetCode #1793 Maximum Score of a Good Subarray

  • LeetCode #1541 Minimum Insertions to Balance a Parentheses String

  • LeetCode #388 Longest Absolute File Path

    • description
    • solution
    • hint: stack, split string by \n, use nums of \t to determine the depth of path

String

  • LeetCode #71 Simplify Path

    • description
    • solution
    • hint: use stack to track the parent directory, .. triggers stack.pop() and dir triggers stack.push(dir)

  • LeetCode #680 Valid Palindrome II

  • LeetCode #828 Count Unique Characters of All Substrings of a Given String

    • description
    • solution
    • hint: use two arrays to find most left and right positions of char at each index in string, result will be calculated by res += (i - leftBound + 1) * (rightBound - i + 1)

  • LeetCode #696 Count Binary Substrings

    • description
    • solution
    • hint: two pointers: curRunLength and preRunLength, res++ only when preRunLength >= curRunLength

  • LeetCode #926 Flip String to Monotone Increasing

    • description
    • solution
    • hint: use flipCount to track flip 0 -> 1, and oneCount to track flip 1 -> 0, do flipCount = oneCount if oneCount < flipCount

  • LeetCode #809 Expressive Words

  • LeetCode #443 String Compression

  • LeetCode #415 Add Strings

  • LeetCode #1268 Search Suggestions System

    • description
    • solution
    • hint: trie, treeNode has additional property linkedList<String>, so size could be limited to 3 and sorted by Collections.sort()

  • LeetCode #249 Group Shifted Strings

  • LeetCode #791 Custom Sort String

  • LeetCode #567 Permutation in String

  • LeetCode #1055 Shortest Way to Form String

    • description
    • solution
    • hint: while loop starts with index of target string, within while loop to do for loop on the source string

  • LeetCode #187 Repeated DNA Sequences

  • LeetCode #953 Verifying an Alien Dictionary

  • LeetCode #14 Longest Common Prefix

    • description
    • solution
    • hint: sort the array of strings, compare first string with last one with index increment, or trie

  • LeetCode #792 Number of Matching Subsequences

  • LeetCode #392 Is Subsequence

  • LeetCode #28 Find the Index of the First Occurrence in a String

  • LeetCode #205 Isomorphic Strings

  • LeetCode #438 Find All Anagrams in a String

  • LeetCode #299 Bulls and Cows

  • LeetCode #43 Multiply Strings

    • description
    • solution
    • hint: result[i+j+1] = (nums[i] * nums[j]) % 10 and result[i+j] = (nums[i] * nums[j]) / 10

  • LeetCode #2131 Longest Palindrome by Concatenating Two Letter Words

    • description
    • solution
    • hint: use hashtable to store string with its frequency, and check reverse of string's existence in hashtable

  • LeetCode #13 Roman to Integer

    • description
    • solution
    • hint: use hashtable to map each Roman char to integer, compare preious and current Roman char to decide add the value of current char or (value of current char - value of preious char), e.g. IV = 5 - 1 = 4

  • LeetCode #179 Largest Number

  • LeetCode #1071 Greatest Common Divisor of Strings

    • description
    • solution
    • hint: loop with length range from Math.min(str1.length(), str2.length()) to 1

  • LeetCode #1647 Minimum Deletions to Make Character Frequencies Unique

    • description
    • solution
    • hint: hashtable (char frequency) + maxHeap (compare poll() with peek()) + greedy

  • LeetCode #880 Decoded String at Index

  • LeetCode #2384 Largest Palindromic Number

  • LeetCode #340 Longest Substring with At Most K Distinct Characters

  • LeetCode #2781 Length of the Longest Valid Substring

  • LeetCode #1297 Maximum Number of Occurrences of a Substring

  • LeetCode #214 Shortest Palindrome

  • LeetCode #2024 Maximize the Confusion of an Exam

Greedy

  • LeetCode #134 Gas Station

    • description
    • solution
    • hint: record current gas amount and total gas amount across all stations, update res station if current gas amount is negative, check total gas amount at end for returning -1

  • LeetCode #45 Jump Game II

  • LeetCode #763 Partition Labels (NeetCode 150)

    • description
    • solution
    • hint: use hashtable to track last index of char in the string, greedily split the string at at the last index of any char

  • LeetCode #1029 Two City Scheduling

    • description
    • solution
    • hint: dfs + memo or greedy: sort costs array by letting ppl go to B instead Of A diff = cost[i][1] - cost[i][0], iterate sorted array to calculate cost

  • LeetCode #2214 Minimum Health to Beat Game

  • LeetCode #1899 Merge Triplets to Form Target Triplet (NeetCode 150)

    • description
    • solution
    • hint: greedy, skip invalid triplets that has greater value than target one, build the final triplet and check if it is equal to target one

  • LeetCode #678 Valid Parenthesis String (NeetCode 150)

    • description
    • solution
    • hint: two stacks to iterate each char or greedy using min and mix number of left parenthesis

  • LeetCode #2193 Minimum Number of Moves to Make Palindrome

    • description
    • solution
    • hint: find String.lastIndexOf() of first char and String.indexOf() of last char, compare the steps move them into palindrome position, substring string for each round

  • LeetCode #1921 Eliminate Maximum Number of Monsters

  • LeetCode #2136 Earliest Possible Day of Full Bloom

    • description
    • solution
    • hint: early plant the seed which takes longer to glow, so that it bloom earlier, sorting + greedy

  • LeetCode #1529 Minimum Suffix Flips

    • description
    • solution
    • hint: check current char with previous one, flip count + 1 if they are different

  • LeetCode #1328 Break a Palindrome

    • description
    • solution
    • hint: check any char is not a, change the char to a if found, otherwise set last char to b

Backtracking

  • LeetCode #40 Combination Sum II

  • LeetCode #526 Beautiful Arrangement

  • LeetCode #94 Restore IP Addresses

  • LeetCode #131 Palindrome Partitioning

  • LeetCode #2151 Maximum Good People Based on Statements

  • LeetCode #51 N-Queens

  • LeetCode #46 Permutations

  • LeetCode #17 Letter Combinations of a Phone Number

  • LeetCode #140 Word Break II

  • LeetCode #473 Matchsticks to Square

  • LeetCode #22 Generate Parentheses (NeetCode 150)

  • LeetCode #679 24 Game

    • description
    • solution
    • hint: backtracking + dfs with an input list of possible cards for this round

  • LeetCode #465 Optimal Account Balancing

    • description
    • solution
    • hint: hashmap to track each person balance, dfs + backtracking to find minimum transactions

  • LeetCode #489 Robot Room Cleaner

    • description
    • solution
    • hint: backtracking (using robot apis turnRight() and move()) + dfs, traversal by clockwise

  • LeetCode #698 Partition to K Equal Sum Subsets

  • LeetCode #37 Sudoku Solver

  • LeetCode #2305 Fair Distribution of Cookies

Heap (Priority Queue)

  • LeetCode #378 Kth Smallest Element in a Sorted Matrix

    • description
    • solution
    • hint: priorityQueue or binary search by counting the numbers that are less or equal mid value (low = matrix[0][0] and high = matrix[n - 1][n - 1])

  • LeetCode #973 K Closest Points to Origin

    • description
    • solution
    • hint: use priorityQueue to store the points based on shortest distance to origin, poll() first kth points

  • LeetCode #1167 Minimum Cost to Connect Sticks

    • description
    • solution
    • hint: the earlier stick combined will be added into cost again, so we want to smaller stick combined first asap and cost will be minimum (greedy)

  • LeetCode #1648 Sell Diminishing-Valued Colored Balls

    • description
    • solution
    • hint: use priorityqueue to store Ball(val, 1), poll() each Ball and compare with peek() to see if we can use up all of orders

  • LeetCode #1135 Connecting Cities With Minimum Cost

    • description
    • solution
    • hint: build graph with next city and its cost, use priorityQueue to choose next city with minimum cost on new edge

  • LeetCode #1353 Maximum Number of Events That Can Be Attended

    • description
    • solution
    • hint: sort event by starting time, iterate day 1 to 10^5, use priorityQueue to track closing time, poll() already closed event, offer() the event can be attended at ith day, poll() event attended, make res += 1

  • LeetCode #1405 Longest Happy String

  • LeetCode #2102 Sequentially Ordinal Rank Tracker

  • LeetCode #767 Reorganize String

    • description
    • solution
    • hint: use priorityQueue to store char with its freq, greedy to poll one or two to build string

  • LeetCode #692 Top K Frequent Words

    • description
    • solution
    • hint: use priorityQueue to store map entry with string as key and freqency as value

  • LeetCode #787 Cheapest Flights Within K Stops (NeetCode 150) (Dijkstra's algorithm)

    • description
    • solution
    • hint: bfs, dfs(backtracing), Dijkstra's algorithm(minHeap) or Bellman Ford(dp)

  • LeetCode #743 Network Delay Time (NeetCode 150) (Dijkstra's algorithm)

  • LeetCode #778 Swim in Rising Water (NeetCode 150)

  • LeetCode #1631 Path With Minimum Effort

  • LeetCode #1102 Path With Maximum Minimum Value

  • LeetCode #621 Task Scheduler (NeetCode 150)

    • description
    • solution
    • hint: PriorityQueue (store cpu task to process) + queue (store awaiting task)

  • LeetCode #1046 Last Stone Weight (NeetCode 150)

  • LeetCode #1229 Meeting Scheduler

    • description
    • solution
    • hint: minHeap to store valid slots (>= duration), compare poll()[1] and peek()[0] + duration

  • LeetCode #759 Employee Free Time

    • description
    • solution
    • hint: minHeap to store interval, track previous interval and merge current interval with previous one if need, if previous one has no interaction with current one, add the new interval into result

  • LeetCode #1834 Single-Threaded CPU

  • LeetCode #502 IPO

  • LeetCode #1882 Process Tasks Using Servers

  • LeetCode #632 Smallest Range Covering Elements from K Lists

    • description
    • solution
    • hint: pq + greedy, every time we have lists.size() size of numbers in the pq from sorted lists (start from first/smallest num), track the max num (and start and end of min range) if we offer new num into pq and poll() minimum num from minHeap to compare range, until one of lists exhausted, e.g, imagine that each list only contains one number

  • LeetCode #215 Kth Largest Element in an Array

  • LeetCode #1425 Constrained Subsequence Sum

Design

  • LeetCode #146 LRU Cache (NeetCode 150)

    • description
    • solution
    • hint: double linked list to set head and remove tail node, hashmap to get and put node

  • LeetCode # 460 LFU Cache

    • description
    • solution
    • hint: three hashmaps: vals map, usage counts map and usage count-listOfKeys map. use min to track minimum usage count

  • LeetCode #588 Design In-Memory File System

  • LeetCode #1396 Design Underground System

  • LeetCode #380 Insert Delete GetRandom O(1)

    • description
    • solution
    • hint: use list to store val, use map to store val as key and index of val as value. trick is to remove val by swapping last one with removed one

  • LeetCode #381 Insert Delete GetRandom O(1) - Duplicates allowed

    • description
    • solution
    • hint: use list to store val, use map to store val as key and the list of indexes of val as value. trick is to remove val by swapping last one with removed one

  • LeetCode #1570 Dot Product of Two Sparse Vectors

  • LeetCode #981 Time Based Key-Value Store (NeetCode 150)

    • description
    • solution
    • hint: use treeMap with floorKey() or use HashMap<String, List<Data>>() where the Data class has two properties: timestamp and value, binary search on timestamp to find the value

  • LeetCode #244 Shortest Word Distance II

  • LeetCode #362 Design Hit Counter

    • description
    • solution
    • hint: use queue or could just use two arrays as buckets (one is for hits[300], the other is times[300] and index could be timestamp mod 300)

  • LeetCode #716 Max Stack

  • LeetCode #155 Min Stack

  • LeetCode #1381 Design a Stack With Increment Operation

  • LeetCode #1146 Snapshot Array

    • description
    • solution
    • hint: use List<Map<Integer, Integer>> to store the diff/delta between each snapshot

  • LeetCode #706 Design HashMap

  • LeetCode #1472 Design Browser History

  • LeetCode #348 Design Tic-Tac-Toe

    • description
    • solution
    • hint: the better solution could be to check sum of rows, cols and diagonals with one player +1 and the other -1

  • LeetCode #1278 Find Winner on a Tic Tac Toe Game

    • description
    • solution
    • hint: the better solution could be to check sum of rows, cols and diagonals with one player +1 and the other -1, similar to Design Tic-Tac-Toe

  • LeetCode #642 Design Search Autocomplete System

    • description
    • solution
    • hint: trie, trieNode uses arraylist to store top 3 hot sentences that pass through current node

  • LeetCode #1628 Design an Expression Tree With Evaluate Function

    • description
    • solution
    • hint: use postorder traveral by recursion to evaluate, use stack to build tree from array

  • LeetCode #1166 Design File System

  • LeetCode #353 Design Snake Game

  • LeetCode #355 Design Twitter (NeetCode 150)

    • description
    • solution
    • hint: create Tweet and User classes, User class stores the tweets as the linkedlist by tracking head, use maxHeap to return news feed of recent 10 tweet ids

  • LeetCode #2013 Detect Squares (NeetCode 150)

    • description
    • solution
    • hint: use hashtable with list to check if diagonal point exists, then verify existence of other two points

  • LeetCode #2034 Stock Price Fluctuation

  • LeetCode #729 My Calendar I

  • LeetCode #715 Range Module

    • description
    • solution
    • hint: TreeMap<left, right>, use floorKey() to find if there is a value before or equal to the key, use subMap().clear() to remove additional keys

  • LeetCode #1244 Design A Leaderboard

  • LeetCode #1845 Seat Reservation Manager

  • LeetCode #703 Kth Largest Element in a Stream

  • LeetCode #232 Implement Queue using Stacks

  • LeetCode #1600 Throne Inheritance

  • LeetCode #1797 Design Authentication Manager

  • LeetCode #2241 Design an ATM Machine

  • LeetCode #2043 Simple Bank System

  • LeetCode #2502 Design Memory Allocator

  • LeetCode #2590 Design a Todo List

  • LeetCode #2296 Design a Text Editor

  • LeetCode #1804 Implement Trie II (Prefix Tree)

  • LeetCode #1500 Design a File Sharing System

    • description
    • solution
    • hint: min heap for tracking ids and hashtable for tracking trunks per id

Monotonic Queue

  • LeetCode #239 Sliding Window Maximum (NeetCode 150)

    • description
    • solution
    • hint: priorityQueue is TLE, use deque to track valid index of nums that is at peek(), keep cleaning old index from peek() that is out of the window, keep cleaning useless index that has smaller value from peekLast()

  • LeetCode #1438 Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit

    • description
    • solution
    • hint: use two deque to track min and max values with two pointers left and right

Interval

  • LeetCode #1851 Minimum Interval to Include Each Query (NeetCode 150)

  • LeetCode #1288 Remove Covered Intervals

    • description
    • solution
    • hint: sort array by start of interval (if starts are equal, compare ends of intervals), loop sorted intervals with comparing current end value

  • LeetCode #2158 Amount of New Area Painted Each Day

Bit Manipulation (Bitmask)

About

Curated List of Top 75 LeetCode Questions

Resources

Readme

License

MIT license
Activity

Stars

1 star

Watchers

1 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Languages