Full Code of gzc/leetcode for AI

gitextract_k9u05cp_/

├── .gitignore
├── LICENSE
├── README.md
├── Solve the Equation.cpp
├── TODO
├── cpp/
│   ├── 001-010/
│   │   ├── Add Two Numbers.cpp
│   │   ├── Longest Palindromic Substring.cpp
│   │   ├── Longest Substring Without Repeating Characters.cpp
│   │   ├── Median of Two Sorted Arrays.cpp
│   │   ├── Palindrome Number.cpp
│   │   ├── Regular Expression Matching.cpp
│   │   ├── Reverse Integer.cpp
│   │   ├── String to Integer (atoi).cpp
│   │   ├── Two Sum.cpp
│   │   └── ZigZag Conversion.cpp
│   ├── 011-020/
│   │   ├── 3Sum Closest.cpp
│   │   ├── 3Sum.cpp
│   │   ├── 4Sum.cpp
│   │   ├── Container With Most Water.cpp
│   │   ├── Integer to Roman.cpp
│   │   ├── Letter Combinations of a Phone Number.cpp
│   │   ├── Longest Common Prefix.cpp
│   │   ├── Remove Nth Node From End of List.cpp
│   │   ├── Roman to Integer.cpp
│   │   └── Valid Parentheses.cpp
│   ├── 021-030/
│   │   ├── Divide Two Integers.cpp
│   │   ├── Generate Parentheses.cpp
│   │   ├── Implement strStr().cpp
│   │   ├── Merge Two Sorted Lists.cpp
│   │   ├── Merge k Sorted Lists.cpp
│   │   ├── Remove Duplicates from Sorted Array.cpp
│   │   ├── Remove Element.cpp
│   │   ├── Reverse Nodes in k-Group.cpp
│   │   ├── Substring with Concatenation of All Words.cpp
│   │   └── Swap Nodes in Pairs.cpp
│   ├── 031-040/
│   │   ├── Combination Sum II.cpp
│   │   ├── Combination Sum.cpp
│   │   ├── Count and Say.cpp
│   │   ├── Longest Valid Parentheses.cpp
│   │   ├── Next Permutation.cpp
│   │   ├── Search Insert Position.cpp
│   │   ├── Search for a Range.cpp
│   │   ├── Search in Rotated Sorted Array.cpp
│   │   ├── Sudoku Solver.cpp
│   │   └── Valid Sudoku.cpp
│   ├── 041-050/
│   │   ├── First Missing Positive.cpp
│   │   ├── Group Anagrams.cpp
│   │   ├── Jump Game II.cpp
│   │   ├── Multiply Strings.cpp
│   │   ├── Permutations II.cpp
│   │   ├── Permutations.cpp
│   │   ├── Pow.cpp
│   │   ├── Rotate Image.cpp
│   │   ├── Trapping Rain Water.cpp
│   │   └── Wildcard Matching.cpp
│   ├── 051-060/
│   │   ├── Insert Interval.cpp
│   │   ├── Jump Game.cpp
│   │   ├── Length of Last Word.cpp
│   │   ├── Maximum_Subarray.cpp
│   │   ├── Merge Intervals.cpp
│   │   ├── N-Queens II.cpp
│   │   ├── N-Queens.cpp
│   │   ├── Permutation Sequence.cpp
│   │   ├── Spiral Matrix II.cpp
│   │   └── Spiral Matrix.cpp
│   ├── 061-070/
│   │   ├── Add Binary.cpp
│   │   ├── Climbing Stairs.cpp
│   │   ├── Minimum Path Sum .cpp
│   │   ├── Plus One.cpp
│   │   ├── Rotate List.cpp
│   │   ├── Sqrt.cpp
│   │   ├── Text Justification.cpp
│   │   ├── Unique Paths II .cpp
│   │   ├── Unique Paths.cpp
│   │   └── Valid Number.cpp
│   ├── 071-080/
│   │   ├── Combinations.cpp
│   │   ├── Edit Distance.cpp
│   │   ├── Minimum Window Substring.cpp
│   │   ├── Remove Duplicates from Sorted Array II.cpp
│   │   ├── Search a 2D Matrix.cpp
│   │   ├── Set Matrix Zeroes.cpp
│   │   ├── Simplify Path.cpp
│   │   ├── Sort Colors.cpp
│   │   ├── Subsets.cpp
│   │   └── Word Search.cpp
│   ├── 081-090/
│   │   ├── Gray Code.cpp
│   │   ├── Largest Rectangle in Histogram.cpp
│   │   ├── Maximal Rectangle.cpp
│   │   ├── Merge Sorted Array.cpp
│   │   ├── Partition List.cpp
│   │   ├── Remove Duplicates from Sorted List II.cpp
│   │   ├── Remove Duplicates from Sorted List.cpp
│   │   ├── Scramble String.cpp
│   │   ├── Search in Rotated Sorted Array II.cpp
│   │   └── Subsets II.cpp
│   ├── 091-100/
│   │   ├── Binary Tree Inorder Traversal.cpp
│   │   ├── Decode Ways.cpp
│   │   ├── Interleaving String.cpp
│   │   ├── Recover Binary Search Tree.cpp
│   │   ├── Restore IP Addresses.cpp
│   │   ├── Reverse Linked List II.cpp
│   │   ├── Same Tree.cpp
│   │   ├── Unique Binary Search Trees II.cpp
│   │   ├── Unique Binary Search Trees.cpp
│   │   └── Validate Binary Search Tree.cpp
│   ├── 1001-10000/
│   │   ├── 1001-1010/
│   │   │   └── Construct Binary Search Tree from Preorder Traversal.cpp
│   │   ├── 1011-1020/
│   │   │   ├── Best Sightseeing Pair.cpp
│   │   │   ├── Binary Prefix Divisible By 5.cpp
│   │   │   ├── Binary String With Substrings Representing 1 To N.cpp
│   │   │   ├── Convert to Base -2.cpp
│   │   │   ├── Next Greater Node In Linked List.cpp
│   │   │   ├── Number of Enclaves.cpp
│   │   │   └── Partition Array Into Three Parts With Equal Sum.cpp
│   │   ├── 1021-1030/
│   │   │   ├── Camelcase Matching.cpp
│   │   │   ├── Divisor Game.cpp
│   │   │   ├── Longest Arithmetic Sequence.cpp
│   │   │   ├── Matrix Cells in Distance Order.cpp
│   │   │   ├── Maximum Difference Between Node and Ancestor.cpp
│   │   │   ├── Recover a Tree From Preorder Traversal.cpp
│   │   │   ├── Remove Outermost Parentheses.cpp
│   │   │   ├── Sum of Root To Leaf Binary Numbers.cpp
│   │   │   ├── Two City Scheduling.cpp
│   │   │   └── Video Stitching.cpp
│   │   ├── 1031-1040/
│   │   │   ├── Binary Search Tree to Greater Sum Tree.cpp
│   │   │   ├── Coloring A Border.cpp
│   │   │   ├── Escape a Large Maze.cpp
│   │   │   ├── Maximum Sum of Two Non-Overlapping Subarrays.cpp
│   │   │   ├── Minimum Score Triangulation of Polygon.cpp
│   │   │   ├── Moving Stones Until Consecutive.cpp
│   │   │   ├── Stream of Characters.cpp
│   │   │   ├── Uncrossed Lines.cpp
│   │   │   └── Valid Boomerang.cpp
│   │   ├── 1041-1050/
│   │   │   ├── Flower Planting With No Adjacent.cpp
│   │   │   ├── Last Stone Weight II.cpp
│   │   │   ├── Last Stone Weight.cpp
│   │   │   ├── Longest String Chain.cpp
│   │   │   ├── Partition Array for Maximum Sum.cpp
│   │   │   ├── Remove All Adjacent Duplicates In String.cpp
│   │   │   └── Robot Bounded In Circle.cpp
│   │   ├── 1051-1060/
│   │   │   ├── Distant Barcodes.cpp
│   │   │   ├── Grumpy Bookstore Owner.cpp
│   │   │   ├── Height Checker.cpp
│   │   │   └── Previous Permutation With One Swap.cpp
│   │   ├── 1071-1080/
│   │   │   ├── Adding Two Negabinary Numbers.cpp
│   │   │   ├── Flip Columns For Maximum Number of Equal Rows.cpp
│   │   │   ├── Greatest Common Divisor of Strings.cpp
│   │   │   ├── Insufficient Nodes in Root to Leaf Paths.cpp
│   │   │   ├── Letter Tile Possibilities.cpp
│   │   │   ├── Number of Submatrices That Sum to Target.cpp
│   │   │   └── Occurrences After Bigram.cpp
│   │   ├── 1081-1090/
│   │   │   ├── Duplicate Zeros.cpp
│   │   │   ├── Largest Values From Labels.cpp
│   │   │   └── Smallest Subsequence of Distinct Characters.cpp
│   │   ├── 1091-1100/
│   │   │   ├── Brace Expansion II.cpp
│   │   │   ├── Car Pooling.cpp
│   │   │   ├── Find in Mountain Array.cpp
│   │   │   ├── Shortest Common Supersequence.cpp
│   │   │   ├── Shortest Path in Binary Matrix.cpp
│   │   │   ├── Statistics from a Large Sample.cpp
│   │   │   └── Two Sum Less Than K.cpp
│   │   ├── 1101-1110/
│   │   │   ├── Corporate Flight Bookings.cpp
│   │   │   ├── Defanging an IP Address.cpp
│   │   │   ├── Delete Nodes And Return Forest.cpp
│   │   │   ├── Distribute Candies to People.cpp
│   │   │   ├── Filling Bookcase Shelves.cpp
│   │   │   ├── Parsing A Boolean Expression.cpp
│   │   │   └── Path In Zigzag Labelled Binary Tree.cpp
│   │   ├── 1111-1120/
│   │   │   ├── Maximum Nesting Depth of Two Valid Parentheses Strings.cpp
│   │   │   ├── Print FooBar Alternately.cpp
│   │   │   └── Print in Order.cpp
│   │   ├── 1121-1130/
│   │   │   ├── Lowest Common Ancestor of Deepest Leaves.cpp
│   │   │   ├── Minimum Cost Tree From Leaf Values.cpp
│   │   │   ├── Number of Equivalent Domino Pairs.cpp
│   │   │   ├── Relative Sort Array.cpp
│   │   │   └── Smallest Sufficient Team.cpp
│   │   ├── 1131-1140/
│   │   │   └── N-th Tribonacci Number.cpp
│   │   ├── 1141-1150/
│   │   │   ├── Binary Tree Coloring Game.cpp
│   │   │   ├── Decrease Elements To Make Array Zigzag.cpp
│   │   │   ├── Longest Chunked Palindrome Decomposition.cpp
│   │   │   ├── Longest Common Subsequence.cpp
│   │   │   └── Snapshot Array.cpp
│   │   ├── 1151-1160/
│   │   │   ├── Day of the Year.cpp
│   │   │   ├── Find Words That Can Be Formed by Characters.cpp
│   │   │   └── Number of Dice Rolls With Target Sum.cpp
│   │   ├── 1161-1170/
│   │   │   ├── As Far from Land as Possible.cpp
│   │   │   ├── Compare Strings by Frequency of the Smallest Character.cpp
│   │   │   ├── Design File System.cpp
│   │   │   ├── Invalid Transactions.cpp
│   │   │   ├── Maximum Level Sum of a Binary Tree.cpp
│   │   │   ├── Minimum Cost to Connect Sticks.cpp
│   │   │   ├── Optimize Water Distribution in a Village.cpp
│   │   │   └── Single-Row Keyboard.cpp
│   │   ├── 1171-1180/
│   │   │   ├── Can Make Palindrome from Substring.cpp
│   │   │   ├── Count Substrings with Only One Distinct Letter.cpp
│   │   │   ├── Diet Plan Performance.cpp
│   │   │   ├── Dinner Plate Stacks.cpp
│   │   │   ├── Prime Arrangements.cpp
│   │   │   └── Remove Zero Sum Consecutive Nodes from Linked List.cpp
│   │   ├── 1181-1190/
│   │   │   ├── Before and After Puzzle.cpp
│   │   │   ├── Day of the Week.cpp
│   │   │   ├── Design Bounded Blocking Queue.cpp
│   │   │   ├── Distance Between Bus Stops.cpp
│   │   │   ├── Make Array Strictly Increasing.cpp
│   │   │   ├── Maximum Subarray Sum with One Deletion.cpp
│   │   │   └── Shortest Distance to Target Color.cpp
│   │   ├── 1191-1200/
│   │   │   └── Minimum Knight Moves.cpp
│   │   ├── 1201-1210/
│   │   │   ├── Design Skiplist.cpp
│   │   │   └── Smallest String With Swaps.cpp
│   │   ├── 1221-1230/
│   │   │   ├── Dice Roll Simulation.cpp
│   │   │   ├── Queens That Can Attack the King.cpp
│   │   │   └── Split a String in Balanced Strings.cpp
│   │   ├── 1231-1240/
│   │   │   ├── Maximum Profit in Job Scheduling.cpp
│   │   │   └── Replace the Substring for Balanced String.cpp
│   │   ├── 1241-1250/
│   │   │   ├── Minimum Remove to Make Valid Parentheses.cpp
│   │   │   └── Web Crawler Multithreaded.cpp
│   │   ├── 1261-1270/
│   │   │   └── Greatest Sum Divisible by Three.cpp
│   │   ├── 1281-1290/
│   │   │   ├── Convert Binary Number in a Linked List to Integer.cpp
│   │   │   ├── Element Appearing More Than 25% In Sorted Array.cpp
│   │   │   └── Remove Covered Intervals.cpp
│   │   ├── 1291-1300/
│   │   │   ├── Maximum Side Length of a Square with Sum Less than or Equal to Threshold.cpp
│   │   │   └── Sequential Digits.cpp
│   │   ├── 1311-1320/
│   │   │   └── Minimum Distance to Type a Word Using Two Fingers.cpp
│   │   ├── 1411-1420/
│   │   │   └── Minimum Value to Get Positive Step by Step Sum.cpp
│   │   ├── 1421-1430/
│   │   │   └── Leftmost Column with at Least a One.cpp
│   │   ├── 1481-1490/
│   │   │   ├── Avoid Flood in The City.cpp
│   │   │   ├── Find Critical and Pseudo-Critical Edges in Minimum Spanning Tree.cpp
│   │   │   ├── Making File Names Unique.cpp
│   │   │   └── XOR Operation in an Array.cpp
│   │   ├── 1501-1510/
│   │   │   └── Stone Game IV.cpp
│   │   ├── 1541-1550/
│   │   │   └── Minimum Insertions to Balance a Parentheses String.cpp
│   │   ├── 1561-1570/
│   │   │   └── Dot Product of Two Sparse Vectors.cpp
│   │   ├── 1621-1630/
│   │   │   ├── Arithmetic Subarrays.cpp
│   │   │   └── Slowest Key.cpp
│   │   ├── 1631-1640/
│   │   │   ├── Check Array Formation Through Concatenation.cpp
│   │   │   ├── Number of Ways to Form a Target String Given a Dictionary.cpp
│   │   │   ├── Path With Minimum Effort.cpp
│   │   │   └── Rank Transform of a Matrix.cpp
│   │   ├── 1641-1650/
│   │   │   ├── Count Sorted Vowel Strings.cpp
│   │   │   ├── Create Sorted Array through Instructions.cpp
│   │   │   ├── Furthest Building You Can Reach.cpp
│   │   │   ├── Get Maximum in Generated Array.cpp
│   │   │   ├── Kth Smallest Instructions.cpp
│   │   │   ├── Lowest Common Ancestor of a Binary Tree II.cpp
│   │   │   ├── Lowest Common Ancestor of a Binary Tree III.cpp
│   │   │   ├── Minimum Deletions to Make Character Frequencies Unique.cpp
│   │   │   └── Sell Diminishing-Valued Colored Balls.cpp
│   │   ├── 1671-1680/
│   │   │   ├── Lowest Common Ancestor of a Binary Tree IV.cpp
│   │   │   └── Minimum Moves to Make Array Complementary.cpp
│   │   ├── 1681-1690/
│   │   │   ├── Delivering Boxes from Storage to Ports.cpp
│   │   │   ├── Stone Game VI.cpp
│   │   │   └── Sum of Absolute Differences in a Sorted Array.cpp
│   │   ├── 1701-1710/
│   │   │   ├── Determine if String Halves Are Alike.cpp
│   │   │   ├── Maximum Number of Eaten Apples.cpp
│   │   │   ├── Maximum Units on a Truck.cpp
│   │   │   ├── Maximum XOR With an Element From Array.cpp
│   │   │   └── Where Will the Ball Fall.cpp
│   │   ├── 1711-1720/
│   │   │   ├── Count Good Meals.cpp
│   │   │   ├── Decode XORed Array.cpp
│   │   │   ├── Minimum Operations to Make a Subsequence.cpp
│   │   │   └── Ways to Split Array Into Three Subarrays.cpp
│   │   ├── 1721-1730/
│   │   │   ├── Find Minimum Time to Finish All Jobs.cpp
│   │   │   ├── Largest Submatrix With Rearrangements.cpp
│   │   │   ├── Minimize Hamming Distance After Swap Operations.cpp
│   │   │   ├── Number Of Rectangles That Can Form The Largest Square.cpp
│   │   │   ├── Swapping Nodes in a Linked List.cpp
│   │   │   └── Tuple with Same Product.cpp
│   │   ├── 1731-1740/
│   │   │   └── Building Boxes.cpp
│   │   ├── 1751-1760/
│   │   │   ├── Closest Subsequence Sum.cpp
│   │   │   ├── Largest Merge Of Two Strings.cpp
│   │   │   ├── Maximum Number of Events That Can Be Attended II.cpp
│   │   │   └── Minimum Limit of Balls in a Bag.cpp
│   │   ├── 1761-1770/
│   │   │   ├── Form Array by Concatenating Subarrays of Another Array.cpp
│   │   │   ├── Map of Highest Peak.cpp
│   │   │   ├── Maximum Score from Performing Multiplication Operations.cpp
│   │   │   ├── Minimum Degree of a Connected Trio in a Graph.cpp
│   │   │   └── Tree of Coprimes.cpp
│   │   ├── 1771-1780/
│   │   │   ├── Car Fleet II.cpp
│   │   │   ├── Check if Number is a Sum of Powers of Three.cpp
│   │   │   ├── Closest Dessert Cost.cpp
│   │   │   ├── Equal Sum Arrays With Minimum Number of Operations.cpp
│   │   │   ├── Find Nearest Point That Has the Same X or Y Coordinate.cpp
│   │   │   ├── Maximize Palindrome Length From Subsequences.cpp
│   │   │   └── Shortest Path in a Hidden Grid.cpp
│   │   ├── 1781-1790/
│   │   │   ├── Check if Binary String Has at Most One Segment of Ones.cpp
│   │   │   ├── Check if One String Swap Can Make Strings Equal.cpp
│   │   │   ├── Count Pairs Of Nodes.cpp
│   │   │   ├── Make the XOR of All Segments Equal to Zero.cpp
│   │   │   ├── Maximize the Beauty of the Garden.cpp
│   │   │   ├── Minimum Elements to Add to Form a Given Sum.cpp
│   │   │   ├── Number of Restricted Paths From First to Last Node.cpp
│   │   │   └── Sum of Beauty of All Substrings.cpp
│   │   ├── 1791-1800/
│   │   │   ├── Count Pairs of Equal Substrings With Minimum Difference.cpp
│   │   │   ├── Design Authentication Manager.cpp
│   │   │   ├── Find Center of Star Graph.cpp
│   │   │   ├── Maximize Score After N Operations.cpp
│   │   │   ├── Maximum Ascending Subarray Sum.cpp
│   │   │   ├── Maximum Average Pass Ratio.cpp
│   │   │   ├── Maximum Number of Consecutive Values You Can Make.cpp
│   │   │   ├── Maximum Score of a Good Subarray.cpp
│   │   │   └── Second Largest Digit in a String.cpp
│   │   ├── 1801-1810/
│   │   │   ├── Count Pairs With XOR in a Range.cpp
│   │   │   ├── Evaluate the Bracket Pairs of a String.cpp
│   │   │   ├── Implement Trie II (Prefix Tree).cpp
│   │   │   ├── Maximize Number of Nice Divisors.cpp
│   │   │   ├── Maximum Value at a Given Index in a Bounded Array.cpp
│   │   │   ├── Minimum Path Cost in a Hidden Grid.cpp
│   │   │   ├── Number of Different Integers in a String.cpp
│   │   │   └── Number of Orders in the Backlog.cpp
│   │   ├── 1811-1820/
│   │   │   ├── Count Nice Pairs in an Array.cpp
│   │   │   ├── Determine Color of a Chessboard Square.cpp
│   │   │   ├── Finding the Users Active Minutes.cpp
│   │   │   ├── Maximum Number of Accepted Invitations.cpp
│   │   │   ├── Maximum Number of Groups Getting Fresh Donuts.cpp
│   │   │   ├── Minimum Absolute Sum Difference.cpp
│   │   │   ├── Number of Different Subsequences GCDs.cpp
│   │   │   ├── Sentence Similarity III.cpp
│   │   │   └── Truncate Sentence.cpp
│   │   ├── 1821-1830/
│   │   │   ├── Faulty Sensor.cpp
│   │   │   ├── Finding MK Average.cpp
│   │   │   ├── Maximum XOR for Each Query.cpp
│   │   │   ├── Minimum Number of Operations to Make String Sorted.cpp
│   │   │   ├── Minimum Operations to Make the Array Increasing.cpp
│   │   │   ├── Minimum Sideway Jumps.cpp
│   │   │   ├── Queries on Number of Points Inside a Circle.cpp
│   │   │   └── Sign of the Product of an Array.cpp
│   │   ├── 1831-1840/
│   │   │   ├── Check if the Sentence Is Pangram.cpp
│   │   │   ├── Find XOR Sum of All Pairs Bitwise AND.cpp
│   │   │   ├── Longest Substring Of All Vowels in Order.cpp
│   │   │   ├── Maximum Building Height.cpp
│   │   │   ├── Maximum Ice Cream Bars.cpp
│   │   │   ├── Remove Duplicates From an Unsorted Linked List.cpp
│   │   │   ├── Single-Threaded CPU.cpp
│   │   │   └── Sum of Digits in Base K.cpp
│   │   ├── 1841-1850/
│   │   │   ├── Closest Room.cpp
│   │   │   └── Minimum Adjacent Swaps to Reach the Kth Smallest Number.cpp
│   │   └── 1851-1860/
│   │       └── Minimum Interval to Include Each Query.cpp
│   ├── 101-110/
│   │   ├── Balanced Binary Tree.cpp
│   │   ├── Binary Tree Level Order Traversal II.cpp
│   │   ├── Binary Tree Level Order Traversal.cpp
│   │   ├── Binary Tree Zigzag Level Order Traversal.cpp
│   │   ├── Construct Binary Tree from Inorder and Postorder Traversal.cpp
│   │   ├── Construct Binary Tree from Preorder and Inorder Traversal.cpp
│   │   ├── Convert Sorted Array to Binary Search Tree.cpp
│   │   ├── Convert Sorted List to Binary Search Tree.cpp
│   │   ├── Maximum Depth of Binary Tree.cpp
│   │   └── Symmetric Tree.cpp
│   ├── 111-120/
│   │   ├── Distinct Subsequences.cpp
│   │   ├── Flatten Binary Tree to Linked List.cpp
│   │   ├── Minimum Depth of Binary Tree.cpp
│   │   ├── Pascal's Triangle II.cpp
│   │   ├── Pascal's Triangle.cpp
│   │   ├── Path Sum II.cpp
│   │   ├── Path Sum.cpp
│   │   ├── Populating Next Right Pointers in Each Node II.cpp
│   │   ├── Populating Next Right Pointers in Each Node.cpp
│   │   └── Triangle.cpp
│   ├── 121-130/
│   │   ├── Best Time to Buy and Sell Stock II.cpp
│   │   ├── Best Time to Buy and Sell Stock III.cpp
│   │   ├── Best Time to Buy and Sell Stock.cpp
│   │   ├── Binary Tree Maximum Path Sum.cpp
│   │   ├── Longest Consecutive Sequence.cpp
│   │   ├── Sum Root to Leaf Numbers.cpp
│   │   ├── Surrounded Regions.cpp
│   │   ├── Valid Palindrome.cpp
│   │   ├── Word Ladder II.cpp
│   │   └── Word Ladder.cpp
│   ├── 131-140/
│   │   ├── Candy.cpp
│   │   ├── Clone Graph.cpp
│   │   ├── Copy List with Random Pointer.cpp
│   │   ├── Gas Station.cpp
│   │   ├── Palindrome Partitioning II.cpp
│   │   ├── Palindrome Partitioning.cpp
│   │   ├── Single Number II.cpp
│   │   ├── Single Number.cpp
│   │   ├── Word Break II.cpp
│   │   └── Word Break.cpp
│   ├── 141-150/
│   │   ├── Binary Tree Postorder Traversal.cpp
│   │   ├── Evaluate Reverse Polish Notation.cpp
│   │   ├── Insertion Sort List.cpp
│   │   ├── LRU Cache.cpp
│   │   ├── Linked List Cycle II.cpp
│   │   ├── Linked List Cycle.cpp
│   │   ├── Max Points on a Line.cpp
│   │   ├── Reorder List.cpp
│   │   ├── Sort List.cpp
│   │   └── Tree Preorder Traversal.cpp
│   ├── 151-160/
│   │   ├── Binary Tree Upside Down.cpp
│   │   ├── Find Minimum in Rotated Sorted Array II.cpp
│   │   ├── Find Minimum in Rotated Sorted Array.cpp
│   │   ├── Intersection of Two Linked Lists.cpp
│   │   ├── Longest Substring with At Most Two Distinct Characters.cpp
│   │   ├── Maximum Product Subarray.cpp
│   │   ├── Min Stack.cpp
│   │   ├── Read N Characters Given Read4 II - Call multiple times.cpp
│   │   ├── Read N Characters Given Read4.cpp
│   │   └── Reverse Words in a String.cpp
│   ├── 161-170/
│   │   ├── Compare Version Numbers.cpp
│   │   ├── Excel Sheet Column Title.cpp
│   │   ├── Find Peak Element.cpp
│   │   ├── Fraction to Recurring Decimal.cpp
│   │   ├── Majority Element.cpp
│   │   ├── Maximum Gap.cpp
│   │   ├── Missing Ranges.cpp
│   │   ├── One Edit Distance.cpp
│   │   ├── Two Sum II - Input array is sorted.cpp
│   │   └── Two Sum III - Data structure design.cpp
│   ├── 171-180/
│   │   ├── Binary Search Tree Iterator.cpp
│   │   ├── Dungeon Game.cpp
│   │   ├── Excel Sheet Column Number.cpp
│   │   ├── Factorial Trailing Zeroes.cpp
│   │   └── Largest Number.cpp
│   ├── 181-190/
│   │   ├── Best Time to Buy and Sell Stock IV.cpp
│   │   ├── Repeated DNA Sequences.cpp
│   │   ├── Reverse Bits.cpp
│   │   ├── Reverse Words in a String II.cpp
│   │   └── Rotate Array.cpp
│   ├── 191-200/
│   │   ├── Binary Tree Right Side View.cpp
│   │   ├── House Robber.cpp
│   │   ├── Number of 1 Bits.cpp
│   │   ├── Number of Islands.cpp
│   │   └── Reverse Bits.cpp
│   ├── 201-210/
│   │   ├── Bitwise AND of Numbers Range.cpp
│   │   ├── Count Primes.cpp
│   │   ├── Course Schedule II.cpp
│   │   ├── Course Schedule.cpp
│   │   ├── Happy Number.cpp
│   │   ├── Implement Trie (Prefix Tree).cpp
│   │   ├── Isomorphic Strings.cpp
│   │   ├── Minimum Size Subarray Sum.cpp
│   │   ├── Remove Linked List Elements.cpp
│   │   └── Reverse Linked List.cpp
│   ├── 211-220/
│   │   ├── Add and Search Word - Data structure design.cpp
│   │   ├── Combination Sum III.cpp
│   │   ├── Contains Duplicate II.cpp
│   │   ├── Contains Duplicate III.cpp
│   │   ├── Contains Duplicate.cpp
│   │   ├── House Robber II.cpp
│   │   ├── Kth Largest Element in an Array.cpp
│   │   ├── Shortest Palindrome.cpp
│   │   ├── The Skyline Problem.cpp
│   │   └── Word Search II.cpp
│   ├── 221-230/
│   │   ├── Basic Calculator II.cpp
│   │   ├── Basic Calculator.cpp
│   │   ├── Count Complete Tree Nodes.cpp
│   │   ├── Implement Stack using Queues.cpp
│   │   ├── Invert Binary Tree.cpp
│   │   ├── Kth Smallest Element in a BST.cpp
│   │   ├── Majority Element II.cpp
│   │   ├── Maximal Square.cpp
│   │   ├── Rectangle Area.cpp
│   │   └── Summary Ranges.cpp
│   ├── 231-240/
│   │   ├── Delete Node in a Linked List.cpp
│   │   ├── Implement Queue using Stacks.cpp
│   │   ├── Lowest Common Ancestor of a Binary Search Tree.cpp
│   │   ├── Lowest Common Ancestor of a Binary Tree.cpp
│   │   ├── Number of Digit One.cpp
│   │   ├── Palindrome Linked List.cpp
│   │   ├── Power of Two.cpp
│   │   ├── Product of Array Except Self.cpp
│   │   ├── Search a 2D Matrix II.cpp
│   │   └── Sliding Window Maximum.cpp
│   ├── 241-250/
│   │   ├── Count Univalue Subtrees.cpp
│   │   ├── Different Ways to Add Parentheses.cpp
│   │   ├── Group Shifted Strings.cpp
│   │   ├── Shortest Word Distance II.cpp
│   │   ├── Shortest Word Distance III.cpp
│   │   ├── Shortest Word Distance.cpp
│   │   ├── Strobogrammatic Number II.cpp
│   │   ├── Strobogrammatic Number III.cpp
│   │   ├── Strobogrammatic Number.cpp
│   │   └── Valid Anagram.cpp
│   ├── 251-260/
│   │   ├── 3Sum Smaller.cpp
│   │   ├── Add Digits.cpp
│   │   ├── Binary Tree Paths.cpp
│   │   ├── Factor Combinations.cpp
│   │   ├── Flatten 2D Vector.cpp
│   │   ├── Meeting Rooms II.cpp
│   │   ├── Meeting Rooms.cpp
│   │   ├── Paint House.cpp
│   │   ├── Single Number III.cpp
│   │   └── Verify Preorder Sequence in Binary Search Tree.cpp
│   ├── 261-270/
│   │   ├── Alien Dictionary.cpp
│   │   ├── Closest Binary Search Tree Value.cpp
│   │   ├── Factor Combinations.cpp
│   │   ├── Graph Valid Tree.cpp
│   │   ├── Missing Number.cpp
│   │   ├── Paint House II.cpp
│   │   ├── Palindrome Permutation II.cpp
│   │   ├── Palindrome Permutation.cpp
│   │   ├── Ugly Number II.cpp
│   │   └── Ugly Number.cpp
│   ├── 271-280/
│   │   ├── Closest Binary Search Tree Value II.cpp
│   │   ├── Encode and Decode Strings.cpp
│   │   ├── Find the Celebrity.cpp
│   │   ├── First Bad Version.cpp
│   │   ├── H-Index II.cpp
│   │   ├── H-Index.cpp
│   │   ├── Integer to English Words.cpp
│   │   ├── Paint Fence.cpp
│   │   ├── Perfect Squares.cpp
│   │   └── Wiggle Sort.cpp
│   ├── 281-290/
│   │   ├── Expression Add Operators.cpp
│   │   ├── Find the Duplicate Number.cpp
│   │   ├── Game of Life.cpp
│   │   ├── Inorder Successor in BST.cpp
│   │   ├── Move Zeroes.cpp
│   │   ├── Peeking Iterator.cpp
│   │   ├── Unique Word Abbreviation.cpp
│   │   ├── Walls and Gates.cpp
│   │   ├── Word Pattern.cpp
│   │   └── Zigzag Iterator.cpp
│   ├── 291-300/
│   │   ├── Best Meeting Point.cpp
│   │   ├── Binary Tree Longest Consecutive Sequence.cpp
│   │   ├── Bulls and Cows.cpp
│   │   ├── Find Median from Data Stream.cpp
│   │   ├── Flip Game II.cpp
│   │   ├── Flip Game.cpp
│   │   ├── Longest Increasing Subsequence.cpp
│   │   ├── Nim Game.cpp
│   │   ├── Serialize and Deserialize Binary Tree.cpp
│   │   └── Word Pattern II.cpp
│   ├── 301-310/
│   │   ├── Additive Number.cpp
│   │   ├── Best Time to Buy and Sell Stock with Cooldown.cpp
│   │   ├── Minimum Height Trees.cpp
│   │   ├── Number of Islands II.cpp
│   │   ├── Range Sum Query - Immutable.cpp
│   │   ├── Range Sum Query - Mutable.cpp
│   │   ├── Range Sum Query 2D - Immutable.cpp
│   │   ├── Range Sum Query 2D - Mutable.cpp
│   │   ├── Remove Invalid Parentheses.cpp
│   │   └── Smallest Rectangle Enclosing Black Pixels.cpp
│   ├── 311-320/
│   │   ├── Binary Tree Vertical Order Traversal.cpp
│   │   ├── Bulb Switcher.cpp
│   │   ├── Burst Balloons.cpp
│   │   ├── Count of Smaller Numbers After Self.cpp
│   │   ├── Generalized Abbreviation.cpp
│   │   ├── Maximum Product of Word Lengths.cpp
│   │   ├── Remove Duplicate Letters.cpp
│   │   ├── Shortest Distance from All Buildings.cpp
│   │   ├── Sparse Matrix Multiplication.cpp
│   │   └── Super Ugly Number.cpp
│   ├── 321-330/
│   │   ├── Coin Change.cpp
│   │   ├── Count of Range Sum.cpp
│   │   ├── Create Maximum Number.cpp
│   │   ├── Longest Increasing Path in a Matrix.cpp
│   │   ├── Maximum Size Subarray Sum Equals k.cpp
│   │   ├── Number of Connected Components in an Undirected Graph.cpp
│   │   ├── Odd Even Linked List.cpp
│   │   ├── Patching Array.cpp
│   │   ├── Power of Three.cpp
│   │   └── Wiggle Sort II.cpp
│   ├── 331-340/
│   │   ├── Counting Bits.cpp
│   │   ├── House Robber III.cpp
│   │   ├── Increasing Triplet Subsequence.cpp
│   │   ├── Largest BST Subtree.cpp
│   │   ├── Longest Substring with At Most K Distinct Characters.cpp
│   │   ├── Nested List Weight Sum.cpp
│   │   ├── Palindrome Pairs.cpp
│   │   ├── Reconstruct Itinerary.cpp
│   │   ├── Self Crossing.cpp
│   │   └── Verify Preorder Serialization of a Binary Tree.cpp
│   ├── 341-350/
│   │   ├── Design Tic-Tac-Toe.cpp
│   │   ├── Flatten Nested List Iterator.cpp
│   │   ├── Integer Break.cpp
│   │   ├── Intersection of Two Arrays II.cpp
│   │   ├── Intersection of Two Arrays.cpp
│   │   ├── Moving Average from Data Stream.cpp
│   │   ├── Power of Four.cpp
│   │   ├── Reverse String.cpp
│   │   ├── Reverse Vowels of a String.cpp
│   │   └── Top K Frequent Elements.cpp
│   ├── 351-360/
│   │   ├── Android Unlock Patterns.cpp
│   │   ├── Count Numbers with Unique Digits.cpp
│   │   ├── Data Stream as Disjoint Intervals.cpp
│   │   ├── Design Snake Game.cpp
│   │   ├── Design Twitter.cpp
│   │   ├── Line Reflection.cpp
│   │   ├── Logger Rate Limiter.cpp
│   │   ├── Rearrange String k Distance Apart.cpp
│   │   ├── Russian Doll Envelopes.cpp
│   │   └── Sort Transformed Array.cpp
│   ├── 361-370/
│   │   ├── Bomb Enemy.cpp
│   │   ├── Design Hit Counter.cpp
│   │   ├── Find Leaves of Binary Tree.cpp
│   │   ├── Largest Divisible Subset.cpp
│   │   ├── Max Sum of Rectangle No Larger Than K.cpp
│   │   ├── Nested List Weight Sum II.cpp
│   │   ├── Plus One Linked List.cpp
│   │   ├── Range Addition.cpp
│   │   ├── Valid Perfect Square.cpp
│   │   └── Water and Jug Problem.cpp
│   ├── 371-380/
│   │   ├── Combination Sum IV.cpp
│   │   ├── Design Phone Directory.cpp
│   │   ├── Find K Pairs with Smallest Sums.cpp
│   │   ├── Guess Number Higher or Lower II.cpp
│   │   ├── Guess Number Higher or Lower.cpp
│   │   ├── Insert Delete GetRandom O(1).cpp
│   │   ├── Kth Smallest Element in a Sorted Matrix.cpp
│   │   ├── Sum of Two Integers.cpp
│   │   ├── Super Pow.cpp
│   │   └── Wiggle Subsequence.cpp
│   ├── 381-390/
│   │   ├── Elimination Game.cpp
│   │   ├── Find the Difference.cpp
│   │   ├── First Unique Character in a String.cpp
│   │   ├── Insert Delete GetRandom O(1) - Duplicates allowed.cpp
│   │   ├── Lexicographical Numbers.cpp
│   │   ├── Linked List Random Node.cpp
│   │   ├── Longest Absolute File Path.cpp
│   │   ├── Mini Parser.cpp
│   │   ├── Ransom Note.cpp
│   │   └── Shuffle an Array.cpp
│   ├── 391-400/
│   │   ├── Decode String.cpp
│   │   ├── Evaluate Division.cpp
│   │   ├── Integer Replacement.cpp
│   │   ├── Is Subsequence.cpp
│   │   ├── Longest Substring with At Least K Repeating Characters.cpp
│   │   ├── Nth Digit.cpp
│   │   ├── Perfect Rectangle.cpp
│   │   ├── Random Pick Index.cpp
│   │   ├── Rotate Function.cpp
│   │   └── UTF-8 Validation.cpp
│   ├── 401-410/
│   │   ├── Binary Watch.cpp
│   │   ├── Convert a Number to Hexadecimal.cpp
│   │   ├── Frog Jump.cpp
│   │   ├── Longest Palindrome.cpp
│   │   ├── Queue Reconstruction by Height.cpp
│   │   ├── Remove K Digits.cpp
│   │   ├── Split Array Largest Sum.cpp
│   │   ├── Sum of Left Leaves.cpp
│   │   ├── Trapping Rain Water II.cpp
│   │   └── Valid Word Abbreviation.cpp
│   ├── 411-420/
│   │   ├── Add Strings.cpp
│   │   ├── Arithmetic Slices.cpp
│   │   ├── Battleships in a Board.cpp
│   │   ├── Fizz Buzz.cpp
│   │   ├── Minimum Unique Word Abbreviation.cpp
│   │   ├── Pacific Atlantic Water Flow.cpp
│   │   ├── Partition Equal Subset Sum.cpp
│   │   ├── Sentence Screen Fitting.cpp
│   │   └── Third Maximum Number.cpp
│   ├── 421-430/
│   │   ├── Convert Binary Search Tree to Sorted Doubly Linked List.cpp
│   │   ├── Maximum XOR of Two Numbers in an Array.cpp
│   │   ├── Serialize and Deserialize N-ary Tree.cpp
│   │   ├── Valid Word Square.cpp
│   │   └── Word Squares.cpp
│   ├── 431-440/
│   │   ├── All O`one Data Structure.cpp
│   │   ├── Find All Anagrams in a String.cpp
│   │   ├── Find Right Interval.cpp
│   │   ├── K-th Smallest in Lexicographical Order.cpp
│   │   ├── Minimum Genetic Mutation.cpp
│   │   ├── Number of Segments in a String.cpp
│   │   ├── Path Sum III.cpp
│   │   └── Ternary Expression Parser.cpp
│   ├── 441-450/
│   │   ├── Add Two Numbers II.cpp
│   │   ├── Arithmetic Slices II - Subsequence.cpp
│   │   ├── Arranging Coins.cpp
│   │   ├── Delete Node in a BST.cpp
│   │   ├── Find All Duplicates in an Array.cpp
│   │   ├── Number of Boomerangs.cpp
│   │   ├── Sequence Reconstruction.cpp
│   │   ├── Serialize and Deserialize BST.cpp
│   │   └── String Compression.cpp
│   ├── 451-460/
│   │   ├── 132 Pattern.cpp
│   │   ├── 4Sum II.cpp
│   │   ├── Assign Cookies.cpp
│   │   ├── LFU Cache.cpp
│   │   ├── Minimum Moves to Equal Array Elements.cpp
│   │   ├── Minimum Number of Arrows to Burst Balloons.cpp
│   │   ├── Repeated Substring Pattern.cpp
│   │   └── Sort Characters By Frequency.cpp
│   ├── 461-470/
│   │   ├── Can I Win.cpp
│   │   ├── Convex Polygon.cpp
│   │   ├── Count The Repetitions.cpp
│   │   ├── Hamming Distance.cpp
│   │   ├── Island Perimeter.cpp
│   │   ├── Minimum Moves to Equal Array Elements II.cpp
│   │   ├── Optimal Account Balancing.cpp
│   │   ├── Unique Substrings in Wraparound String.cpp
│   │   └── Validate IP Address.cpp
│   ├── 471-480/
│   │   ├── Concatenated Words.cpp
│   │   ├── Encode String with Shortest Length.cpp
│   │   ├── Heaters.cpp
│   │   ├── Largest Palindrome Product.cpp
│   │   ├── Matchsticks to Square.cpp
│   │   ├── Number Complement.cpp
│   │   ├── Ones and Zeroes.cpp
│   │   ├── Sliding Window Median.cpp
│   │   └── Total Hamming Distance.cpp
│   ├── 481-490/
│   │   ├── Find Permutation.cpp
│   │   ├── License Key Formatting.cpp
│   │   ├── Magical String.cpp
│   │   ├── Max Consecutive Ones II.cpp
│   │   ├── Max Consecutive Ones.cpp
│   │   ├── Predict the Winner.cpp
│   │   ├── Robot Room Cleaner.cpp
│   │   ├── Smallest Good Base.cpp
│   │   ├── The Maze.cpp
│   │   └── Zuma Game.cpp
│   ├── 491-500/
│   │   ├── Construct the Rectangle.cpp
│   │   ├── Diagonal Traverse.cpp
│   │   ├── Increasing Subsequences.cpp
│   │   ├── Keyboard Row.cpp
│   │   ├── Next Greater Element I.cpp
│   │   ├── Reverse Pairs.cpp
│   │   ├── Target Sum.cpp
│   │   ├── Teemo Attacking.cpp
│   │   └── The Maze III.cpp
│   ├── 501-510/
│   │   ├── Base 7.cpp
│   │   ├── Find Mode in Binary Search Tree.cpp
│   │   ├── IPO.cpp
│   │   ├── Most Frequent Subtree Sum.cpp
│   │   ├── Next Greater Element II.cpp
│   │   ├── Perfect Number.cpp
│   │   ├── Relative Ranks.cpp
│   │   └── The Maze II.cpp
│   ├── 511-520/
│   │   ├── Coin Change 2.cpp
│   │   ├── Detect Capital.cpp
│   │   ├── Find Bottom Left Tree Value.cpp
│   │   ├── Find Largest Value in Each Tree Row.cpp
│   │   ├── Freedom Trail.cpp
│   │   ├── Longest Palindromic Subsequence.cpp
│   │   └── Super Washing Machines.cpp
│   ├── 521-530/
│   │   ├── Beautiful Arrangement.cpp
│   │   ├── Contiguous Array.cpp
│   │   ├── Continuous Subarray Sum.cpp
│   │   ├── Longest Uncommon Subsequence I.cpp
│   │   ├── Longest Uncommon Subsequence II.cpp
│   │   ├── Longest Word in Dictionary through Deleting.cpp
│   │   ├── Minimum Distance Between BST Nodes.cpp
│   │   └── Word Abbreviation.cpp
│   ├── 531-540/
│   │   ├── Complex Number Multiplication.cpp
│   │   ├── Convert BST to Greater Tree.cpp
│   │   ├── Encode and Decode TinyURL.cpp
│   │   ├── Lonely Pixel I.cpp
│   │   ├── Lonely Pixel II.cpp
│   │   └── Single Element in a Sorted Array.cpp
│   ├── 541-550/
│   │   ├── 01 Matrix.cpp
│   │   ├── Binary Tree Longest Consecutive Sequence II.cpp
│   │   ├── Boundary of Binary Tree.cpp
│   │   ├── Diameter of Binary Tree.cpp
│   │   ├── Friend Circles.cpp
│   │   ├── Output Contest Matches.cpp
│   │   ├── Reverse String II.cpp
│   │   └── Split Array with Equal Sum.cpp
│   ├── 551-560/
│   │   ├── Brick Wall.cpp
│   │   ├── Next Greater Element III.cpp
│   │   ├── Optimal Division.cpp
│   │   ├── Reverse Words in a String III.cpp
│   │   ├── Split Concatenated Strings.cpp
│   │   ├── Student Attendance Record I.cpp
│   │   ├── Student Attendance Record II.cpp
│   │   └── Subarray Sum Equals K.cpp
│   ├── 561-570/
│   │   ├── Array Nesting.cpp
│   │   ├── Array Partition I.cpp
│   │   ├── Binary Tree Tilt.cpp
│   │   ├── Longest Line of Consecutive One in Matrix.cpp
│   │   ├── Maximum Vacation Days.cpp
│   │   ├── Permutation in String.cpp
│   │   └── Reshape the Matrix.cpp
│   ├── 571-580/
│   │   ├── Distribute Candies.cpp
│   │   ├── Out of Boundary Paths.cpp
│   │   ├── Squirrel Simulation.cpp
│   │   └── Subtree of Another Tree.cpp
│   ├── 581-590/
│   │   ├── Delete Operation for Two Strings.cpp
│   │   ├── Design In-Memory File System.cpp
│   │   ├── Erect the Fence.cpp
│   │   ├── Kill Process.cpp
│   │   └── Shortest Unsorted Continuous Subarray.cpp
│   ├── 591-600/
│   │   ├── Fraction Addition and Subtraction.cpp
│   │   ├── Longest Harmonious Subsequence.cpp
│   │   ├── Minimum Index Sum of Two Lists.cpp
│   │   ├── Non-negative Integers without Consecutive Ones.cpp
│   │   ├── Range Addition II.cpp
│   │   ├── Tag Validator.cpp
│   │   └── Valid Square.cpp
│   ├── 601-610/
│   │   ├── Can Place Flowers.cpp
│   │   ├── Construct String from Binary Tree.cpp
│   │   ├── Design Compressed String Iterator.cpp
│   │   └── Find Duplicate File in System.cpp
│   ├── 611-620/
│   │   ├── Add Bold Tag in String.cpp
│   │   ├── Merge Two Binary Trees.cpp
│   │   └── Valid Triangle Number.cpp
│   ├── 621-630/
│   │   ├── Add One Row to Tree.cpp
│   │   ├── Course Schedule III.cpp
│   │   ├── Design Circular Queue.cpp
│   │   ├── K Inverse Pairs Array.cpp
│   │   ├── Maximum Distance in Arrays.cpp
│   │   ├── Maximum Product of Three Numbers.cpp
│   │   ├── Minimum Factorization.cpp
│   │   └── Task Scheduler.cpp
│   ├── 631-640/
│   │   ├── Average of Levels in Binary Tree.cpp
│   │   ├── Decode Ways II.cpp
│   │   ├── Design Excel Sum Formula.cpp
│   │   ├── Design Log Storage System.cpp
│   │   ├── Exclusive Time of Functions.cpp
│   │   ├── Find the Derangement of An Array.cpp
│   │   ├── Shopping Offers.cpp
│   │   ├── Smallest Range.cpp
│   │   ├── Solve the Equation.cpp
│   │   └── Sum of Square Numbers.cpp
│   ├── 641-650/
│   │   ├── 2 Keys Keyboard.cpp
│   │   ├── Design Search Autocomplete System.cpp
│   │   ├── Dota2 Senate.cpp
│   │   ├── Maximum Average Subarray I.cpp
│   │   ├── Maximum Average Subarray II.cpp
│   │   ├── Maximum Length of Pair Chain.cpp
│   │   ├── Palindromic Substrings.cpp
│   │   ├── Replace Words.cpp
│   │   └── Set Mismatch.cpp
│   ├── 651-660/
│   │   ├── 4 Keys Keyboard.cpp
│   │   ├── Coin Path.cpp
│   │   ├── Find Duplicate Subtrees.cpp
│   │   ├── Find K Closest Elements.cpp
│   │   ├── Judge Route Circle.cpp
│   │   ├── Maximum Binary Tree.cpp
│   │   ├── Print Binary Tree.cpp
│   │   ├── Remove 9.cpp
│   │   ├── Split Array into Consecutive Subsequences.cpp
│   │   └── Two Sum IV - Input is a BST.cpp
│   ├── 661-670/
│   │   ├── Beautiful Arrangement II.cpp
│   │   ├── Equal Tree Partition.cpp
│   │   ├── Image Smoother.cpp
│   │   ├── Kth largest Number in Multiplication Table.cpp
│   │   ├── Maximum Swap.cpp
│   │   ├── Maximum Width of Binary Tree.cpp
│   │   ├── Non-decreasing Array.cpp
│   │   ├── Path Sum IV.cpp
│   │   ├── Strange Printer.cpp
│   │   └── Trim a Binary Search Tree.cpp
│   ├── 671-680/
│   │   ├── 24 Game.cpp
│   │   ├── Cut Off Trees for Golf Event.cpp
│   │   ├── Implement Magic Dictionary.cpp
│   │   ├── Longest Continuous Increasing Subsequence.cpp
│   │   ├── Map Sum Pairs.cpp
│   │   ├── Number of Longest Increasing Subsequence.cpp
│   │   ├── Second Minimum Node In a Binary Tree.cpp
│   │   ├── Valid Palindrome II.cpp
│   │   └── Valid Parenthesis String.cpp
│   ├── 681-690/
│   │   ├── Baseball Game.cpp
│   │   ├── Employee Importance.cpp
│   │   ├── K Empty Slots.cpp
│   │   ├── Knight Probability in Chessboard.cpp
│   │   ├── Longest Univalue Path.cpp
│   │   ├── Maximum Sum of 3 Non-Overlapping Subarrays.cpp
│   │   ├── Next Closest Time.cpp
│   │   ├── Redundant Connection II.cpp
│   │   ├── Redundant Connection.cpp
│   │   └── Repeated String Match.cpp
│   ├── 691-700/
│   │   ├── Binary Number with Alternating Bits.cpp
│   │   ├── Count Binary Substrings.cpp
│   │   ├── Degree of an Array.cpp
│   │   ├── Falling Squares.cpp
│   │   ├── Max Area of Island.cpp
│   │   ├── Number of Distinct Islands.cpp
│   │   ├── Partition to K Equal Sum Subsets.cpp
│   │   └── Top K Frequent Words.cpp
│   ├── 701-710/
│   │   ├── Insert into a Binary Search Tree.cpp
│   │   ├── Random Pick with Blacklist.cpp
│   │   └── To Lower Case.cpp
│   ├── 711-720/
│   │   ├── 1-bit and 2-bit Characters.cpp
│   │   ├── Best Time to Buy and Sell Stock with Transaction Fee.cpp
│   │   ├── Find K-th Smallest Pair Distance.cpp
│   │   ├── Longest Word in Dictionary.cpp
│   │   ├── Max Stack.cpp
│   │   ├── Maximum Length of Repeated Subarray.cpp
│   │   ├── Minimum ASCII Delete Sum for Two Strings.cpp
│   │   ├── Number of Distinct Islands II.cpp
│   │   ├── Range Module.cpp
│   │   └── Subarray Product Less Than K.cpp
│   ├── 721-730/
│   │   ├── Accounts Merge.cpp
│   │   ├── Candy Crush.cpp
│   │   ├── Count Different Palindromic Subsequences.cpp
│   │   ├── Find Pivot Index.cpp
│   │   ├── My Calendar I.cpp
│   │   ├── Number of Atoms.cpp
│   │   ├── Remove Comments.cpp
│   │   ├── Self Dividing Numbers.cpp
│   │   └── Split Linked List in Parts.cpp
│   ├── 731-740/
│   │   ├── Asteroid Collision.cpp
│   │   ├── Daily Temperatures.cpp
│   │   ├── Delete and Earn.cpp
│   │   ├── Flood Fill.cpp
│   │   ├── Monotone Increasing Digits.cpp
│   │   ├── My Calendar II.cpp
│   │   ├── My Calendar III.cpp
│   │   ├── Parse Lisp Expression.cpp
│   │   ├── Sentence Similarity II.cpp
│   │   └── Sentence Similarity.cpp
│   ├── 741-750/
│   │   ├── Closest Leaf in a Binary Tree.cpp
│   │   ├── Find Smallest Letter Greater Than Target.cpp
│   │   ├── Largest Number At Least Twice of Others.cpp
│   │   ├── Min Cost Climbing Stairs.cpp
│   │   ├── Network Delay Time.cpp
│   │   ├── Number Of Corner Rectangles.cpp
│   │   ├── Prefix and Suffix Search.cpp
│   │   └── Shortest Completing Word.cpp
│   ├── 751-760/
│   │   ├── Bold Words in String.cpp
│   │   ├── Cracking the Safe.cpp
│   │   ├── Employee Free Time.cpp
│   │   ├── Find Anagram Mappings.cpp
│   │   ├── IP to CIDR.cpp
│   │   ├── Open the Lock.cpp
│   │   ├── Pour Water.cpp
│   │   ├── Pyramid Transition Matrix.cpp
│   │   ├── Reach a Number.cpp
│   │   └── Set Intersection Size At Least Two.cpp
│   ├── 761-770/
│   │   ├── Couples Holding Hands.cpp
│   │   ├── Largest Plus Sign.cpp
│   │   ├── Max Chunks To Make Sorted II.cpp
│   │   ├── Max Chunks To Make Sorted.cpp
│   │   ├── Partition Labels.cpp
│   │   ├── Prime Number of Set Bits in Binary Representation.cpp
│   │   ├── Reorganize String.cpp
│   │   ├── Special Binary String.cpp
│   │   └── Toeplitz Marix.cpp
│   ├── 771-780/
│   │   ├── Basic Calculator III.cpp
│   │   ├── Global and Local Inversions.cpp
│   │   ├── Jewels and Stones.cpp
│   │   ├── K-th Symbol in Grammar.cpp
│   │   ├── Minimize Max Distance to Gas Station.cpp
│   │   ├── Sliding Puzzle.cpp
│   │   ├── Split BST.cpp
│   │   ├── Swap Adjacent in LR String.cpp
│   │   └── Swim in Rising Water.cpp
│   ├── 781-790/
│   │   ├── Cheapest Flights Within K Stops.cpp
│   │   ├── Escape The Ghosts.cpp
│   │   ├── Is Graph Bipartite?.cpp
│   │   ├── K-th Smallest Prime Fraction.cpp
│   │   ├── Letter Case Permutation.cpp
│   │   ├── Minimum Distance Between BST Nodes.cpp
│   │   ├── Rabbits in Forest.cpp
│   │   ├── Rotated Digits.cpp
│   │   └── Transform to Chessboard.cpp
│   ├── 791-800/
│   │   ├── All Paths From Source to Target.cpp
│   │   ├── Champagne Tower.cpp
│   │   ├── Custom Sort String.cpp
│   │   ├── Number of Matching Subsequences.cpp
│   │   ├── Number of Subarrays with Bounded Maximum.cpp
│   │   ├── Preimage Size of Factorial Zeroes Function.cpp
│   │   ├── Rotate String
│   │   ├── Similar RGB Color.cpp
│   │   └── Valid Tic-Tac-Toe State.cpp
│   ├── 801-810/
│   │   ├── Bricks Falling When Hit.cpp
│   │   ├── Chalkboard XOR Game.cpp
│   │   ├── Expressive Words.cpp
│   │   ├── Find Eventual Safe States.cpp
│   │   ├── Max Increase to Keep City Skyline.cpp
│   │   ├── Minimum Swaps To Make Sequences Increasing.cpp
│   │   ├── Number of Lines To Write String.cpp
│   │   ├── Soup Servings.cpp
│   │   └── Unique Morse Code Words.cpp
│   ├── 811-820/
│   │   ├── Ambiguous Coordinates.cpp
│   │   ├── Binary Tree Pruning.cpp
│   │   ├── Bus Routes.cpp
│   │   ├── Largest Sum of Averages.cpp
│   │   ├── Linked List Components.cpp
│   │   ├── Most Common Word.cpp
│   │   ├── Race Car.cpp
│   │   ├── Short Encoding of Words.cpp
│   │   └── Subdomain Visit Count.cpp
│   ├── 821-830/
│   │   ├── Binary Trees With Factors.cpp
│   │   ├── Card Flipping Game.cpp
│   │   ├── Consecutive Numbers Sum.cpp
│   │   ├── Friends Of Appropriate Ages.cpp
│   │   ├── Goat Latin.cpp
│   │   ├── Making A Large Island.cpp
│   │   ├── Most Profit Assigning Work.cpp
│   │   ├── Positions of Large Groups.cpp
│   │   ├── Shortest Distance to a Character.cpp
│   │   └── Unique Letter String.cpp
│   ├── 831-840/
│   │   ├── Find And Replace in String.cpp
│   │   ├── Flipping an Image.cpp
│   │   ├── Image Overlap.cpp
│   │   ├── Magic Squares In Grid.cpp
│   │   ├── Masking Personal Information.cpp
│   │   ├── New 21 Game.cpp
│   │   ├── Push Dominoes.cpp
│   │   ├── Rectangle Overlap.cpp
│   │   ├── Similar String Groups.cpp
│   │   └── Sum of Distances in Tree.cpp
│   ├── 841-850/
│   │   ├── Backspace String Compare.cpp
│   │   ├── Guess the Word.cpp
│   │   ├── Hand of Straights.cpp
│   │   ├── Keys and Rooms.cpp
│   │   ├── Longest Mountain in Array.cpp
│   │   ├── Maximize Distance to Closest Person.cpp
│   │   ├── Shifting Letters.cpp
│   │   ├── Shortest Path Visiting All Nodes.cpp
│   │   └── Split Array into Fibonacci Sequence.cpp
│   ├── 851-860/
│   │   ├── Buddy Strings.cpp
│   │   ├── Car Fleet.cpp
│   │   ├── Exam Room.cpp
│   │   ├── K-Similar Strings.cpp
│   │   ├── Lemonade Change.cpp
│   │   ├── Loud and Rich.cpp
│   │   ├── Peak Index in a Mountain Array.cpp
│   │   └── Score of Parentheses.cpp
│   ├── 861-870/
│   │   ├── Advantage Shuffle.cpp
│   │   ├── All Nodes Distance K in Binary Tree.cpp
│   │   ├── Binary Gap.cpp
│   │   ├── Prime Palindrome.cpp
│   │   ├── Reordered Power of 2.cpp
│   │   ├── Score After Flipping Matrix.cpp
│   │   ├── Smallest Subtree with all the Deepest Nodes.cpp
│   │   └── Transpose Matrix.cpp
│   ├── 871-880/
│   │   ├── Implement Rand10() Using Rand7().cpp
│   │   ├── Koko Eating Bananas.cpp
│   │   ├── Leaf-Similar Trees.cpp
│   │   ├── Length of Longest Fibonacci Subsequence.cpp
│   │   ├── Middle of the Linked List.cpp
│   │   └── Stone Game.cpp
│   ├── 881-890/
│   │   ├── Boats to Save People.cpp
│   │   ├── Possible Bipartition.cpp
│   │   ├── Projection Area of 3D Shapes.cpp
│   │   └── Uncommon Words from Two Sentences.cpp
│   ├── 891-900/
│   │   └── Maximum Frequency Stack.cpp
│   ├── 911-920/
│   │   ├── Complete Binary Tree Inserter.cpp
│   │   ├── Maximum Sum Circular Subarray.cpp
│   │   ├── Number of Music Playlists.cpp
│   │   ├── Online Election.cpp
│   │   ├── Partition Array into Disjoint Intervals.cpp
│   │   ├── Reverse Only Letters.cpp
│   │   ├── Word Subsets.cpp
│   │   └── X of a Kind in a Deck of Cards.cpp
│   ├── 921-930/
│   │   ├── 3Sum With Multiplicity.cpp
│   │   ├── Binary Subarrays With Sum.cpp
│   │   ├── Flip String to Monotone Increasing.cpp
│   │   ├── Long Pressed Name.cpp
│   │   ├── Minimize Malware Spread.cpp
│   │   ├── Minimum Add to Make Parentheses Valid.cpp
│   │   ├── Sort Array By Parity II.cpp
│   │   ├── Three Equal Parts.cpp
│   │   └── Unique Email Addresses.cpp
│   ├── 931-940/
│   │   ├── Beautiful Array.cpp
│   │   ├── Distinct Subsequences II.cpp
│   │   ├── Knight Dialer.cpp
│   │   ├── Minimum Area Rectangle.cpp
│   │   ├── Minimum Falling Path Sum.cpp
│   │   ├── Number of Recent Calls.cpp
│   │   ├── Range Sum of BST.cpp
│   │   ├── Reorder Log Files.cpp
│   │   ├── Shortest Bridge.cpp
│   │   └── Stamping The Sequence.cpp
│   ├── 941-950/
│   │   ├── Bag of Tokens.cpp
│   │   ├── DI String Match.cpp
│   │   ├── Delete Columns to Make Sorted.cpp
│   │   ├── Minimum Increment to Make Array Unique.cpp
│   │   ├── Most Stones Removed with Same Row or Column.cpp
│   │   ├── Valid Mountain Array.cpp
│   │   └── Validate Stack Sequences.cpp
│   ├── 951-960/
│   │   ├── Check Completeness of a Binary Tree.cpp
│   │   ├── Prison Cells After N Days.cpp
│   │   ├── Regions Cut By Slashes.cpp
│   │   └── Verifying an Alien Dictionary.cpp
│   ├── 961-970/
│   │   ├── N-Repeated Element in Size 2N Array.cpp
│   │   └── Pancake Sorting.cpp
│   ├── 971-980/
│   │   ├── Distribute Coins in Binary Tree.cpp
│   │   ├── K Closest Points to Origin.cpp
│   │   ├── Largest Perimeter Triangle.cpp
│   │   ├── Longest Turbulent Subarray.cpp
│   │   ├── Squares of a Sorted Array.cpp
│   │   ├── Subarray Sums Divisible by K.cpp
│   │   └── Unique Paths III.cpp
│   ├── 981-990/
│   │   ├── Add to Array-Form of Integer.cpp
│   │   ├── Interval List Intersections.cpp
│   │   ├── Satisfiability of Equality Equations.cpp
│   │   ├── String Without AAA or BBB.cpp
│   │   └── Time Based Key-Value Store.cpp
│   └── 991-1000/
│       ├── Broken Calculator.cpp
│       ├── Cousins in Binary Tree.cpp
│       ├── Find the Town Judge.cpp
│       ├── Maximum Binary Tree II.cpp
│       ├── Minimum Number of K Consecutive Bit Flips.cpp
│       ├── Number of Squareful Arrays.cpp
│       └── Rotting Oranges.cpp
├── golang/
│   └── 001-010/
│       ├── Add Two Numbers.go
│       ├── Longest Substring Without Repeating Characters.go
│       └── Two Sum.go
├── java/
│   ├── 201-210/
│   │   └── Happy Number.java
│   ├── 291-300/
│   │   └── Nim Game.java
│   └── 331-340/
│       ├── Counting Bits.java
│       └── Nested List Weight Sum.java
├── python/
│   ├── 001-010/
│   │   └── Median of Two Sorted Arrays.py
│   ├── 011-020/
│   │   └── Valid Parentheses.py
│   ├── 021-030/
│   │   └── Reverse Nodes in k-Group.py
│   ├── 031-040/
│   │   ├── Combination Sum II.py
│   │   ├── Combination Sum.py
│   │   ├── Next Permutation.py
│   │   ├── Search Insert Position.py
│   │   ├── Search for a Range.py
│   │   ├── Sudoku Solver.py
│   │   └── Valid Sudoku.py
│   ├── 041-050/
│   │   ├── Jump Game II.py
│   │   └── Rotate Image.py
│   ├── 051-060/
│   │   ├── Jump Game.py
│   │   └── Permutation Sequence.py
│   ├── 061-070/
│   │   ├── Minimum Path Sum.py
│   │   ├── Sqrt(x).py
│   │   ├── Unique Paths II.py
│   │   ├── Unique Paths.py
│   │   └── Valid Number.py
│   ├── 071-080/
│   │   └── Edit Distance.py
│   ├── 081-090/
│   │   ├── Largest Rectangle in Histogram.py
│   │   ├── Maximal Rectangle.py
│   │   ├── Remove Duplicates from Sorted List II.py
│   │   └── Remove Duplicates from Sorted List.py
│   ├── 091-100/
│   │   ├── Decode Ways.py
│   │   └── Interleaving String.py
│   ├── 101-110/
│   │   └── Symmetric Tree.py
│   ├── 111-120/
│   │   ├── Path Sum.py
│   │   ├── Populating Next Right Pointers in Each Node II.py
│   │   └── Populating Next Right Pointers in Each Node.py
│   ├── 121-130/
│   │   ├── Best Time to Buy and Sell Stock.py
│   │   ├── Binary Tree Maximum Path Sum.py
│   │   ├── Word Ladder II.py
│   │   └── Word Ladder.py
│   ├── 131-140/
│   │   ├── Candy.py
│   │   ├── Clone Graph.py
│   │   └── Single Number II.py
│   ├── 141-150/
│   │   ├── Binary Tree Postorder Traversal.py
│   │   └── LRU Cache.py
│   ├── 151-160/
│   │   ├── Find Minimum in Rotated Sorted Array II.py
│   │   └── Find Minimum in Rotated Sorted Array.py
│   ├── 161-170/
│   │   ├── Majority Element.py
│   │   └── Maximum Gap.py
│   ├── 171-180/
│   │   └── Largest Number.py
│   ├── 181-190/
│   │   ├── Best Time to Buy and Sell Stock IV.py
│   │   └── Repeated DNA Sequences.py
│   ├── 191-200/
│   │   ├── Binary Tree Right Side View.py
│   │   └── House Robber.py
│   ├── 201-210/
│   │   ├── Count Primes.py
│   │   └── Implement Trie (Prefix Tree).py
│   ├── 211-220/
│   │   └── House Robber II.py
│   ├── 221-230/
│   │   └── Maximal Square.py
│   └── 231-240/
│       ├── Palindrome Linked List.py
│       ├── Product of Array Except Self.py
│       └── a.py
└── scala/
    ├── 0001-0010/
    │   ├── Add Two Numbers.scala
    │   ├── Longest Substring Without Repeating Characters.scala
    │   ├── Palindrome Number.scala
    │   └── Two Sum.scala
    └── 0011-0020/
        ├── Longest Common Prefix.scala
        └── Roman to Integer.scala

SYMBOL INDEX (3070 symbols across 1131 files)

FILE: Solve the Equation.cpp
  class Solution (line 2) | class Solution {
    method string (line 4) | string solveEquation(string equation) {
    method coef (line 20) | pair<int, int> coef(string s) {

FILE: cpp/001-010/Add Two Numbers.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 3) | ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {

FILE: cpp/001-010/Longest Palindromic Substring.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string longestPalindrome(string s) {

FILE: cpp/001-010/Longest Substring Without Repeating Characters.cpp
  class Solution (line 1) | class Solution {
    method lengthOfLongestSubstring (line 3) | int lengthOfLongestSubstring(string s) {

FILE: cpp/001-010/Median of Two Sorted Arrays.cpp
  class Solution (line 1) | class Solution {
    method findMedianSortedArrays (line 3) | double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
    method findKthElement (line 12) | double findKthElement(int k, const vector<int>& nums1, int idx1, const...

FILE: cpp/001-010/Palindrome Number.cpp
  class Solution (line 1) | class Solution {
    method isPalindrome (line 3) | bool isPalindrome(int x) {

FILE: cpp/001-010/Regular Expression Matching.cpp
  class Solution (line 1) | class Solution {
    method isMatch (line 3) | bool isMatch(const string& s, int sidx, const string& p, int pidx) {
    method isMatch (line 21) | bool isMatch(string s, string p) {

FILE: cpp/001-010/Reverse Integer.cpp
  class Solution (line 1) | class Solution {
    method reverse (line 3) | int reverse(int x) {

FILE: cpp/001-010/String to Integer (atoi).cpp
  class Solution (line 1) | class Solution {
    method myAtoi (line 3) | int myAtoi(string str) {

FILE: cpp/001-010/Two Sum.cpp
  class Solution (line 1) | class Solution {
    method twoSum (line 3) | vector<int> twoSum(vector<int> &numbers, int target) {

FILE: cpp/001-010/ZigZag Conversion.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string convert(string s, int numRows) {

FILE: cpp/011-020/3Sum Closest.cpp
  class Solution (line 1) | class Solution {
    method threeSumClosest (line 3) | int threeSumClosest(vector<int>& nums, int target) {

FILE: cpp/011-020/3Sum.cpp
  class Solution (line 1) | class Solution {
    method threeSum (line 3) | vector<vector<int>> threeSum(vector<int>& nums) {

FILE: cpp/011-020/4Sum.cpp
  class Solution (line 1) | class Solution {
    method fourSum (line 4) | vector<vector<int> > fourSum(vector<int> &num, int target) {

FILE: cpp/011-020/Container With Most Water.cpp
  class Solution (line 1) | class Solution {
    method maxArea (line 3) | int maxArea(vector<int>& height) {

FILE: cpp/011-020/Integer to Roman.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string intToRoman(int num) {

FILE: cpp/011-020/Letter Combinations of a Phone Number.cpp
  class Solution (line 1) | class Solution {
    method letterCombinations (line 4) | vector<string> letterCombinations(string digits) {

FILE: cpp/011-020/Longest Common Prefix.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string longestCommonPrefix(vector<string>& strs) {

FILE: cpp/011-020/Remove Nth Node From End of List.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 3) | ListNode* removeNthFromEnd(ListNode* head, int n) {

FILE: cpp/011-020/Roman to Integer.cpp
  class Solution (line 1) | class Solution {
    method romanToInt (line 4) | int romanToInt(string s) {

FILE: cpp/011-020/Valid Parentheses.cpp
  class Solution (line 1) | class Solution {
    method isValid (line 3) | bool isValid(string s) {

FILE: cpp/021-030/Divide Two Integers.cpp
  class Solution (line 5) | class Solution {
    method divide (line 7) | int divide(int dividend, int divisor) {
    method divide (line 45) | int divide(int dividend, int divisor) {
  class Solution (line 43) | class Solution {
    method divide (line 7) | int divide(int dividend, int divisor) {
    method divide (line 45) | int divide(int dividend, int divisor) {

FILE: cpp/021-030/Generate Parentheses.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | void dfs(string s, int open, int close, vector<string>& parentheses) {
    method generateParenthesis (line 19) | vector<string> generateParenthesis(int n) {

FILE: cpp/021-030/Implement strStr().cpp
  class Solution (line 1) | class Solution {
    method strStr (line 3) | int strStr(string haystack, string needle) {

FILE: cpp/021-030/Merge Two Sorted Lists.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 3) | ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {

FILE: cpp/021-030/Merge k Sorted Lists.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 3) | ListNode *mergeKLists(vector<ListNode *> &lists) {

FILE: cpp/021-030/Remove Duplicates from Sorted Array.cpp
  class Solution (line 1) | class Solution {
    method removeDuplicates (line 3) | int removeDuplicates(vector<int>& nums) {

FILE: cpp/021-030/Remove Element.cpp
  class Solution (line 1) | class Solution {
    method removeElement (line 3) | int removeElement(vector<int>& nums, int val) {

FILE: cpp/021-030/Reverse Nodes in k-Group.cpp
  class Solution (line 1) | class Solution {
    method length (line 3) | int length(ListNode* head) {
    method ListNode (line 12) | ListNode* dfs(ListNode* head, int len, int k) {
    method ListNode (line 31) | ListNode* reverseKGroup(ListNode* head, int k) {

FILE: cpp/021-030/Substring with Concatenation of All Words.cpp
  class Solution (line 1) | class Solution {
    method findSubstring (line 3) | vector<int> findSubstring(string s, vector<string>& words) {

FILE: cpp/021-030/Swap Nodes in Pairs.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 3) | ListNode* swapPairs(ListNode* head) {

FILE: cpp/031-040/Combination Sum II.cpp
  class Solution (line 9) | class Solution {
    method help (line 11) | void help(vector<int>& now, vector<int>&candidates, int index, int tar...
    method combinationSum2 (line 31) | vector<vector<int> > combinationSum2(vector<int> &candidates, int targ...
  function main (line 41) | int main()

FILE: cpp/031-040/Combination Sum.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | void help(vector<int>& now, vector<int>&candidates, int index, int tar...
    method combinationSum (line 21) | vector<vector<int> > combinationSum(vector<int> &candidates, int targe...

FILE: cpp/031-040/Count and Say.cpp
  class Solution (line 9) | class Solution {
    method string (line 11) | string process(string &s)
    method string (line 30) | string countAndSay(int n) {
  function main (line 40) | int main()

FILE: cpp/031-040/Longest Valid Parentheses.cpp
  class Solution (line 2) | class Solution {
    method longestValidParentheses (line 4) | int longestValidParentheses(string s) {
    method longestValidParentheses (line 30) | int longestValidParentheses(string s) {
  class Solution (line 28) | class Solution {
    method longestValidParentheses (line 4) | int longestValidParentheses(string s) {
    method longestValidParentheses (line 30) | int longestValidParentheses(string s) {

FILE: cpp/031-040/Next Permutation.cpp
  class Solution (line 1) | class Solution {
    method nextPermutation (line 3) | void nextPermutation(vector<int> &num) {

FILE: cpp/031-040/Search Insert Position.cpp
  class Solution (line 1) | class Solution {
    method searchInsert (line 3) | int searchInsert(vector<int>& nums, int target) {

FILE: cpp/031-040/Search for a Range.cpp
  class Solution (line 1) | class Solution {
    method searchRange (line 3) | vector<int> searchRange(vector<int>& nums, int target) {
    method FindFirst (line 23) | int FindFirst(const vector<int>& nums, int target) {
    method FindLast (line 44) | int FindLast(const vector<int>& nums, int target) {
    method searchRange (line 66) | vector<int> searchRange(vector<int>& nums, int target) {
  class Solution (line 21) | class Solution {
    method searchRange (line 3) | vector<int> searchRange(vector<int>& nums, int target) {
    method FindFirst (line 23) | int FindFirst(const vector<int>& nums, int target) {
    method FindLast (line 44) | int FindLast(const vector<int>& nums, int target) {
    method searchRange (line 66) | vector<int> searchRange(vector<int>& nums, int target) {

FILE: cpp/031-040/Search in Rotated Sorted Array.cpp
  class Solution (line 1) | class Solution {
    method search (line 3) | int search(vector<int>& nums, int target) {

FILE: cpp/031-040/Sudoku Solver.cpp
  class Solution (line 1) | class Solution {
    method help (line 7) | bool help(vector<vector<char> > &board, int i, int j) {
    method solveSudoku (line 38) | void solveSudoku(vector<vector<char> > &board) {

FILE: cpp/031-040/Valid Sudoku.cpp
  class Solution (line 1) | class Solution {
    method isValidSudoku (line 3) | bool isValidSudoku(vector<vector<char> > &board) {

FILE: cpp/041-050/First Missing Positive.cpp
  class Solution (line 1) | class Solution {
    method firstMissingPositive (line 3) | int firstMissingPositive(vector<int>& nums) {

FILE: cpp/041-050/Group Anagrams.cpp
  class Solution (line 1) | class Solution {
    method groupAnagrams (line 3) | vector<vector<string>> groupAnagrams(vector<string>& strs) {

FILE: cpp/041-050/Jump Game II.cpp
  class Solution (line 1) | class Solution {
    method jump (line 3) | int jump(vector<int>& nums) {

FILE: cpp/041-050/Multiply Strings.cpp
  class Solution (line 1) | class Solution {
    method string (line 4) | string multiply(string num1, string num2) {

FILE: cpp/041-050/Permutations II.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | void help(vector<vector<int>>& result, int begin, vector<int> num) {
    method permuteUnique (line 17) | vector<vector<int> > permuteUnique(vector<int> &num) {

FILE: cpp/041-050/Permutations.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | void help(vector<vector<int>>& result, int begin, vector<int> &num)
    method permute (line 19) | vector<vector<int> > permute(vector<int> &num) {

FILE: cpp/041-050/Pow.cpp
  class Solution (line 1) | class Solution {
    method myPow (line 3) | double myPow(double x, int n) {

FILE: cpp/041-050/Rotate Image.cpp
  class Solution (line 1) | class Solution {
    method rotate (line 3) | void rotate(vector<vector<int> > &matrix) {

FILE: cpp/041-050/Trapping Rain Water.cpp
  class Solution (line 1) | class Solution {
    method trap (line 3) | int trap(vector<int>& height) {

FILE: cpp/041-050/Wildcard Matching.cpp
  class Solution (line 1) | class Solution {
    method isMatch (line 3) | bool isMatch(string s, string p) {

FILE: cpp/051-060/Insert Interval.cpp
  class Solution (line 1) | class Solution {
    method merge (line 3) | vector<Interval> merge(vector<Interval> &intervals) {
    method insert (line 26) | vector<Interval> insert(vector<Interval> &intervals, Interval newInter...

FILE: cpp/051-060/Jump Game.cpp
  class Solution (line 1) | class Solution {
    method canJump (line 3) | bool canJump(vector<int>& nums) {

FILE: cpp/051-060/Length of Last Word.cpp
  class Solution (line 1) | class Solution {
    method lengthOfLastWord (line 3) | int lengthOfLastWord(string s) {

FILE: cpp/051-060/Maximum_Subarray.cpp
  class Solution (line 21) | class Solution {
    method maxSubArray (line 23) | int maxSubArray(std::vector<int>& A) {
  function main (line 42) | int main() {

FILE: cpp/051-060/Merge Intervals.cpp
  class Solution (line 1) | class Solution {
    method merge (line 3) | vector<vector<int>> merge(vector<vector<int>> &intervals) {

FILE: cpp/051-060/N-Queens II.cpp
  class Solution (line 1) | class Solution {
    method valid (line 8) | bool valid(int i, int j) {
    method help (line 14) | void help(int i, int &res) {
    method totalNQueens (line 30) | int totalNQueens(int n) {

FILE: cpp/051-060/N-Queens.cpp
  class Solution (line 1) | class Solution {
    method valid (line 8) | bool valid(int i, int j)
    method help (line 15) | void help(vector<vector<string>> &result, vector<pair<int, int>> &tmp,...
    method solveNQueens (line 41) | vector<vector<string> > solveNQueens(int n) {

FILE: cpp/051-060/Permutation Sequence.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string getPermutation(int n, int k) {

FILE: cpp/051-060/Spiral Matrix II.cpp
  class Solution (line 9) | class Solution {
    method generateMatrix (line 11) | vector<vector<int> > generateMatrix(int n) {
  function main (line 57) | int main()

FILE: cpp/051-060/Spiral Matrix.cpp
  class Solution (line 9) | class Solution {
    method spiralOrder (line 11) | vector<int> spiralOrder(vector<vector<int> > &matrix) {
  function main (line 52) | int main()

FILE: cpp/061-070/Add Binary.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string addBinary(string a, string b) {

FILE: cpp/061-070/Climbing Stairs.cpp
  class Solution (line 1) | class Solution {
    method climbStairs (line 3) | int climbStairs(int n) {

FILE: cpp/061-070/Plus One.cpp
  class Solution (line 1) | class Solution {
    method plusOne (line 3) | vector<int> plusOne(vector<int>& digits) {

FILE: cpp/061-070/Rotate List.cpp
  class Solution (line 9) | class Solution {
    method ListNode (line 11) | ListNode *rotateRight(ListNode *head, int k) {

FILE: cpp/061-070/Sqrt.cpp
  class Solution (line 1) | class Solution {
    method mySqrt (line 3) | int mySqrt(int x) {
    method mySqrt (line 24) | int mySqrt(int x) {
  class Solution (line 22) | class Solution {
    method mySqrt (line 3) | int mySqrt(int x) {
    method mySqrt (line 24) | int mySqrt(int x) {

FILE: cpp/061-070/Text Justification.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | vector<int> help(vector<string> &words, int start, int end, int L)
    method fullJustify (line 24) | vector<string> fullJustify(vector<string> &words, int L) {

FILE: cpp/061-070/Unique Paths II .cpp
  class Solution (line 1) | class Solution {
    method uniquePathsWithObstacles (line 3) | int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {

FILE: cpp/061-070/Unique Paths.cpp
  class Solution (line 1) | class Solution {
    method uniquePaths (line 3) | int uniquePaths(int m, int n) {

FILE: cpp/061-070/Valid Number.cpp
  class Solution (line 1) | class Solution {
    method isNumber (line 3) | bool isNumber(string str) {

FILE: cpp/071-080/Combinations.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | void help(int n, int k, int index, vector<int>&tmp, vector<vector<int>...
    method combine (line 20) | vector<vector<int> > combine(int n, int k) {

FILE: cpp/071-080/Edit Distance.cpp
  class Solution (line 1) | class Solution {
    method minDistance (line 3) | int minDistance(string word1, string word2) {

FILE: cpp/071-080/Minimum Window Substring.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string minWindow(string s, string t) {

FILE: cpp/071-080/Remove Duplicates from Sorted Array II.cpp
  class Solution (line 1) | class Solution {
    method removeDuplicates (line 3) | int removeDuplicates(vector<int>& nums) {

FILE: cpp/071-080/Search a 2D Matrix.cpp
  class Solution (line 1) | class Solution {
    method searchMatrix (line 3) | bool searchMatrix(vector<vector<int> > &matrix, int target) {

FILE: cpp/071-080/Set Matrix Zeroes.cpp
  class Solution (line 1) | class Solution {
    method setZeroes (line 3) | void setZeroes(vector<vector<int> > &matrix) {

FILE: cpp/071-080/Simplify Path.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string simplifyPath(string path) {

FILE: cpp/071-080/Sort Colors.cpp
  class Solution (line 1) | class Solution {
    method sortColors (line 3) | void sortColors(vector<int>& nums) {

FILE: cpp/071-080/Subsets.cpp
  class Solution (line 1) | class Solution {
    method subsets (line 3) | vector<vector<int> > subsets(vector<int> &S) {

FILE: cpp/071-080/Word Search.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | bool dfs(vector<vector<char>>& board, const string &word, int i, int j...
    method exist (line 20) | bool exist(vector<vector<char>>& board, string word) {

FILE: cpp/081-090/Gray Code.cpp
  class Solution (line 1) | class Solution {
    method grayCode (line 3) | vector<int> grayCode(int n) {

FILE: cpp/081-090/Largest Rectangle in Histogram.cpp
  class Solution (line 1) | class Solution {
    method largestRectangleArea (line 3) | int largestRectangleArea(vector<int> &hist) {

FILE: cpp/081-090/Maximal Rectangle.cpp
  class Solution (line 1) | class Solution {
    method maximalRectangle (line 3) | int maximalRectangle(vector<vector<char>>& matrix) {

FILE: cpp/081-090/Merge Sorted Array.cpp
  class Solution (line 1) | class Solution {
    method merge (line 3) | void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {

FILE: cpp/081-090/Partition List.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 3) | ListNode *partition(ListNode *head, int x) {

FILE: cpp/081-090/Remove Duplicates from Sorted List II.cpp
  type ListNode (line 11) | struct ListNode {
    method ListNode (line 14) | ListNode(int x) : val(x), next(NULL) {}
  class Solution (line 17) | class Solution {
    method ListNode (line 19) | ListNode *deleteDuplicates(ListNode *head) {
  function main (line 44) | int main()

FILE: cpp/081-090/Remove Duplicates from Sorted List.cpp
  type ListNode (line 11) | struct ListNode {
    method ListNode (line 14) | ListNode(int x) : val(x), next(NULL) {}
  class Solution (line 17) | class Solution {
    method ListNode (line 19) | ListNode* deleteDuplicates(ListNode* head) {
  function main (line 35) | int main()

FILE: cpp/081-090/Scramble String.cpp
  class Solution (line 1) | class Solution {
    method isScramble (line 4) | bool isScramble(string s1, string s2) {

FILE: cpp/081-090/Search in Rotated Sorted Array II.cpp
  class Solution (line 1) | class Solution {
    method search (line 3) | bool search(vector<int>& nums, int target) {

FILE: cpp/081-090/Subsets II.cpp
  class Solution (line 1) | class Solution {
    method subsetsWithDup (line 3) | vector<vector<int>> subsetsWithDup(vector<int>& nums) {

FILE: cpp/091-100/Binary Tree Inorder Traversal.cpp
  class Solution (line 1) | class Solution {
    method inorderTraversal (line 3) | vector<int> inorderTraversal(TreeNode* root) {

FILE: cpp/091-100/Decode Ways.cpp
  class Solution (line 1) | class Solution {
    method valid (line 3) | bool valid(char ch1, char ch2)
    method numDecodings (line 17) | int numDecodings(string s) {

FILE: cpp/091-100/Interleaving String.cpp
  class Solution (line 1) | class Solution {
    method isInterleave (line 4) | bool isInterleave(string s1, string s2, string s3) {

FILE: cpp/091-100/Recover Binary Search Tree.cpp
  class Solution (line 1) | class Solution {
    method recoverTree (line 3) | void recoverTree(TreeNode* root) {

FILE: cpp/091-100/Restore IP Addresses.cpp
  class Solution (line 1) | class Solution {
    method restoreIpAddresses (line 3) | vector<string> restoreIpAddresses(string s) {

FILE: cpp/091-100/Reverse Linked List II.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 3) | ListNode *reverseBetween(ListNode *head, int m, int n) {

FILE: cpp/091-100/Same Tree.cpp
  class Solution (line 1) | class Solution {
    method isSameTree (line 3) | bool isSameTree(TreeNode* p, TreeNode* q) {

FILE: cpp/091-100/Unique Binary Search Trees II.cpp
  class Solution (line 10) | class Solution {
    method generate (line 12) | vector<TreeNode *> generate(int beg, int end) {
    method generateTrees (line 36) | vector<TreeNode *> generateTrees(int n) {

FILE: cpp/091-100/Unique Binary Search Trees.cpp
  class Solution (line 1) | class Solution {
    method numTrees (line 3) | int numTrees(int n) {

FILE: cpp/091-100/Validate Binary Search Tree.cpp
  class Solution (line 1) | class Solution {
    method isValidBST (line 3) | bool isValidBST(TreeNode* root) {

FILE: cpp/1001-10000/1001-1010/Construct Binary Search Tree from Preorder Traversal.cpp
  class Solution (line 10) | class Solution {
    method TreeNode (line 12) | TreeNode* dfs(int& i, vector<int>& preorder, int lower, int upper) {
    method TreeNode (line 31) | TreeNode* bstFromPreorder(vector<int>& preorder) {

FILE: cpp/1001-10000/1011-1020/Best Sightseeing Pair.cpp
  class Solution (line 1) | class Solution {
    method maxScoreSightseeingPair (line 3) | int maxScoreSightseeingPair(vector<int>& A) {

FILE: cpp/1001-10000/1011-1020/Binary Prefix Divisible By 5.cpp
  class Solution (line 1) | class Solution {
    method prefixesDivBy5 (line 3) | vector<bool> prefixesDivBy5(vector<int>& A) {

FILE: cpp/1001-10000/1011-1020/Binary String With Substrings Representing 1 To N.cpp
  class Solution (line 1) | class Solution {
    method queryString (line 3) | bool queryString(string S, int N) {

FILE: cpp/1001-10000/1011-1020/Convert to Base -2.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string baseNeg2(int N) {

FILE: cpp/1001-10000/1011-1020/Next Greater Node In Linked List.cpp
  class Solution (line 9) | class Solution {
    method nextLargerNodes (line 11) | vector<int> nextLargerNodes(ListNode* head) {

FILE: cpp/1001-10000/1011-1020/Number of Enclaves.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 8) | void dfs(vector<vector<int>>& A, int i, int j) {
    method numEnclaves (line 20) | int numEnclaves(vector<vector<int>>& A) {

FILE: cpp/1001-10000/1011-1020/Partition Array Into Three Parts With Equal Sum.cpp
  class Solution (line 1) | class Solution {
    method canThreePartsEqualSum (line 3) | bool canThreePartsEqualSum(vector<int>& A) {

FILE: cpp/1001-10000/1021-1030/Camelcase Matching.cpp
  class Solution (line 1) | class Solution {
    method camelMatch (line 3) | vector<bool> camelMatch(vector<string>& queries, string pattern) {

FILE: cpp/1001-10000/1021-1030/Divisor Game.cpp
  class Solution (line 1) | class Solution {
    method divisorGame (line 4) | bool divisorGame(int N) {

FILE: cpp/1001-10000/1021-1030/Longest Arithmetic Sequence.cpp
  class Solution (line 1) | class Solution {
    method longestArithSeqLength (line 3) | int longestArithSeqLength(vector<int>& A) {

FILE: cpp/1001-10000/1021-1030/Matrix Cells in Distance Order.cpp
  class Solution (line 1) | class Solution {
    method allCellsDistOrder (line 3) | vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0) {

FILE: cpp/1001-10000/1021-1030/Maximum Difference Between Node and Ancestor.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | int dfs(TreeNode* root, int min_, int max_) {
    method maxAncestorDiff (line 24) | int maxAncestorDiff(TreeNode* root) {

FILE: cpp/1001-10000/1021-1030/Recover a Tree From Preorder Traversal.cpp
  class Solution (line 10) | class Solution {
    method TreeNode (line 12) | TreeNode* dfs(const string& S, int& i, int d) {
    method TreeNode (line 38) | TreeNode* recoverFromPreorder(string S) {

FILE: cpp/1001-10000/1021-1030/Remove Outermost Parentheses.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string removeOuterParentheses(string S) {

FILE: cpp/1001-10000/1021-1030/Sum of Root To Leaf Binary Numbers.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | int dfs(TreeNode* root, int carry) {
    method sumRootToLeaf (line 23) | int sumRootToLeaf(TreeNode* root) {

FILE: cpp/1001-10000/1021-1030/Two City Scheduling.cpp
  class Solution (line 1) | class Solution {
    method twoCitySchedCost (line 3) | int twoCitySchedCost(vector<vector<int>>& costs) {

FILE: cpp/1001-10000/1021-1030/Video Stitching.cpp
  class Solution (line 1) | class Solution {
    method videoStitching (line 3) | int videoStitching(vector<vector<int>>& clips, int T) {

FILE: cpp/1001-10000/1031-1040/Binary Search Tree to Greater Sum Tree.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | void dfs(TreeNode* root, int& v) {
    method TreeNode (line 21) | TreeNode* bstToGst(TreeNode* root) {

FILE: cpp/1001-10000/1031-1040/Coloring A Border.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 9) | void dfs(vector<vector<int>>& grid, int i, int j, vector<vector<bool>>...
    method colorBorder (line 32) | vector<vector<int>> colorBorder(vector<vector<int>>& grid, int r0, int...

FILE: cpp/1001-10000/1031-1040/Escape a Large Maze.cpp
  class Solution (line 1) | class Solution {
    method isEscapePossibleInternal (line 7) | bool isEscapePossibleInternal(vector<vector<int>>& blocked, vector<int...
    method isEscapePossible (line 39) | bool isEscapePossible(vector<vector<int>>& blocked, vector<int>& sourc...

FILE: cpp/1001-10000/1031-1040/Maximum Sum of Two Non-Overlapping Subarrays.cpp
  class Solution (line 1) | class Solution {
    method maxSumTwoNoOverlap (line 3) | int maxSumTwoNoOverlap(vector<int>& A, int L, int M) {
    method help (line 9) | int help(const vector<int>& sum, int L, int M) {

FILE: cpp/1001-10000/1031-1040/Minimum Score Triangulation of Polygon.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | int dfs(vector<int>& A, map<pair<int, int>, int>& cache, int start_ind...
    method minScoreTriangulation (line 27) | int minScoreTriangulation(vector<int>& A) {

FILE: cpp/1001-10000/1031-1040/Moving Stones Until Consecutive.cpp
  class Solution (line 1) | class Solution {
    method numMovesStones (line 3) | vector<int> numMovesStones(int a, int b, int c) {

FILE: cpp/1001-10000/1031-1040/Stream of Characters.cpp
  type TrieNode (line 1) | struct TrieNode {
    method TrieNode (line 5) | TrieNode(): word(false) {
  class Trie (line 10) | class Trie {
    method Trie (line 13) | Trie() {
    method insert (line 18) | void insert(const string& s) {
    method eat (line 30) | bool eat(char ch) {
  class StreamChecker (line 58) | class StreamChecker {
    method StreamChecker (line 61) | StreamChecker(vector<string>& words) {
    method query (line 67) | bool query(char letter) {

FILE: cpp/1001-10000/1031-1040/Uncrossed Lines.cpp
  class Solution (line 1) | class Solution {
    method maxUncrossedLines (line 3) | int maxUncrossedLines(vector<int>& A, vector<int>& B) {

FILE: cpp/1001-10000/1031-1040/Valid Boomerang.cpp
  class Solution (line 1) | class Solution {
    method isBoomerang (line 3) | bool isBoomerang(vector<vector<int>>& points) {

FILE: cpp/1001-10000/1041-1050/Flower Planting With No Adjacent.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 4) | void dfs(int u, map<int, vector<int>>& edges) {
    method gardenNoAdj (line 27) | vector<int> gardenNoAdj(int N, vector<vector<int>>& paths) {

FILE: cpp/1001-10000/1041-1050/Last Stone Weight II.cpp
  class Solution (line 1) | class Solution {
    method lastStoneWeightII (line 4) | int lastStoneWeightII(vector<int>& stones) {

FILE: cpp/1001-10000/1041-1050/Last Stone Weight.cpp
  class Solution (line 1) | class Solution {
    method lastStoneWeight (line 3) | int lastStoneWeight(vector<int>& stones) {

FILE: cpp/1001-10000/1041-1050/Longest String Chain.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | int dfs(const string& word, const unordered_set<string>& dictionary, u...
    method longestStrChain (line 20) | int longestStrChain(vector<string>& words) {

FILE: cpp/1001-10000/1041-1050/Partition Array for Maximum Sum.cpp
  class Solution (line 1) | class Solution {
    method maxSumAfterPartitioning (line 3) | int maxSumAfterPartitioning(vector<int>& A, int K) {

FILE: cpp/1001-10000/1041-1050/Remove All Adjacent Duplicates In String.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string removeDuplicates(string S) {

FILE: cpp/1001-10000/1041-1050/Robot Bounded In Circle.cpp
  class Solution (line 1) | class Solution {
    method getNextDirection (line 3) | pair<int, int> getNextDirection(pair<int, int> d, char ch) {
    method string (line 34) | string GetKey(int x, int y, pair<int, int> d) {
    method isRobotBounded (line 39) | bool isRobotBounded(string instructions) {

FILE: cpp/1001-10000/1051-1060/Distant Barcodes.cpp
  class Solution (line 1) | class Solution {
    method rearrangeBarcodes (line 3) | vector<int> rearrangeBarcodes(vector<int>& barcodes) {

FILE: cpp/1001-10000/1051-1060/Grumpy Bookstore Owner.cpp
  class Solution (line 1) | class Solution {
    method maxSatisfied (line 3) | int maxSatisfied(vector<int>& customers, vector<int>& grumpy, int X) {

FILE: cpp/1001-10000/1051-1060/Height Checker.cpp
  class Solution (line 1) | class Solution {
    method heightChecker (line 3) | int heightChecker(vector<int>& heights) {

FILE: cpp/1001-10000/1051-1060/Previous Permutation With One Swap.cpp
  class Solution (line 1) | class Solution {
    method prevPermOpt1 (line 3) | vector<int> prevPermOpt1(vector<int>& A) {

FILE: cpp/1001-10000/1071-1080/Adding Two Negabinary Numbers.cpp
  class Solution (line 1) | class Solution {
    method addNegabinary (line 3) | vector<int> addNegabinary(vector<int>& arr1, vector<int>& arr2) {

FILE: cpp/1001-10000/1071-1080/Flip Columns For Maximum Number of Equal Rows.cpp
  class Solution (line 1) | class Solution {
    method process (line 3) | void process(map<string, int>& mymap, const vector<int>& vec) {
    method maxEqualRowsAfterFlips (line 14) | int maxEqualRowsAfterFlips(vector<vector<int>>& matrix) {

FILE: cpp/1001-10000/1071-1080/Greatest Common Divisor of Strings.cpp
  class Solution (line 1) | class Solution {
    method IsValid (line 3) | bool IsValid(const string& str, const string& candidate) {
    method string (line 13) | string gcdOfStrings(string str1, string str2) {

FILE: cpp/1001-10000/1071-1080/Insufficient Nodes in Root to Leaf Paths.cpp
  class Solution (line 10) | class Solution {
    method TreeNode (line 12) | TreeNode* sufficientSubset(TreeNode* root, int limit) {

FILE: cpp/1001-10000/1071-1080/Letter Tile Possibilities.cpp
  class Solution (line 1) | class Solution {
    method uniquePerms (line 5) | int uniquePerms(const string& s) {
    method dfs (line 13) | int dfs(const string& s, string seq = "", int pos = 0) {
    method numTilePossibilities (line 21) | int numTilePossibilities(string tiles) {

FILE: cpp/1001-10000/1071-1080/Number of Submatrices That Sum to Target.cpp
  class Solution (line 1) | class Solution {
    method numSubmatrixSumTarget (line 3) | int numSubmatrixSumTarget(vector<vector<int>>& matrix, int target) {

FILE: cpp/1001-10000/1071-1080/Occurrences After Bigram.cpp
  class Solution (line 1) | class Solution {
    method findOcurrences (line 3) | vector<string> findOcurrences(string text, string first, string second) {

FILE: cpp/1001-10000/1081-1090/Duplicate Zeros.cpp
  class Solution (line 1) | class Solution {
    method duplicateZeros (line 3) | void duplicateZeros(vector<int>& arr) {

FILE: cpp/1001-10000/1081-1090/Largest Values From Labels.cpp
  class Solution (line 1) | class Solution {
    method largestValsFromLabels (line 3) | int largestValsFromLabels(vector<int>& values, vector<int>& labels, in...

FILE: cpp/1001-10000/1081-1090/Smallest Subsequence of Distinct Characters.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string smallestSubsequence(string text) {

FILE: cpp/1001-10000/1091-1100/Brace Expansion II.cpp
  class Solution (line 1) | class Solution {
    method merge (line 3) | set<string> merge(const set<string>& set1, const set<string>& set2) {
    method process (line 13) | void process(stack<set<string>>& mystack, stack<char>& ops) {
    method braceExpansionII (line 30) | vector<string> braceExpansionII(string expression) {

FILE: cpp/1001-10000/1091-1100/Car Pooling.cpp
  class Solution (line 1) | class Solution {
    method carPooling (line 3) | bool carPooling(vector<vector<int>>& trips, int capacity) {

FILE: cpp/1001-10000/1091-1100/Find in Mountain Array.cpp
  class Solution (line 10) | class Solution {
    method findInMountainArray (line 13) | int findInMountainArray(int target, MountainArray &mountainArr) {

FILE: cpp/1001-10000/1091-1100/Shortest Common Supersequence.cpp
  class Solution (line 1) | class Solution {
    method string (line 4) | string shortestCommonSupersequence(string str1, string str2) {

FILE: cpp/1001-10000/1091-1100/Shortest Path in Binary Matrix.cpp
  class Solution (line 1) | class Solution {
    method shortestPathBinaryMatrix (line 3) | int shortestPathBinaryMatrix(vector<vector<int>>& grid) {

FILE: cpp/1001-10000/1091-1100/Statistics from a Large Sample.cpp
  class Solution (line 1) | class Solution {
    method sampleStats (line 3) | vector<double> sampleStats(vector<int>& count) {

FILE: cpp/1001-10000/1091-1100/Two Sum Less Than K.cpp
  class Solution (line 1) | class Solution {
    method twoSumLessThanK (line 3) | int twoSumLessThanK(vector<int>& A, int K) {

FILE: cpp/1001-10000/1101-1110/Corporate Flight Bookings.cpp
  class Solution (line 1) | class Solution {
    method corpFlightBookings (line 3) | vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {

FILE: cpp/1001-10000/1101-1110/Defanging an IP Address.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string defangIPaddr(string address) {

FILE: cpp/1001-10000/1101-1110/Delete Nodes And Return Forest.cpp
  class Solution (line 10) | class Solution {
    method TreeNode (line 14) | TreeNode* dfs (TreeNode* root, set<int>& to_deleted, bool is_root) {
    method delNodes (line 35) | vector<TreeNode*> delNodes(TreeNode* root, vector<int>& to_delete) {

FILE: cpp/1001-10000/1101-1110/Distribute Candies to People.cpp
  class Solution (line 1) | class Solution {
    method distributeCandies (line 3) | vector<int> distributeCandies(int candies, int num_people) {

FILE: cpp/1001-10000/1101-1110/Filling Bookcase Shelves.cpp
  class Solution (line 1) | class Solution {
    method minHeightShelves (line 3) | int minHeightShelves(vector<vector<int>>& books, int shelf_width) {
    method dfs (line 28) | int dfs(vector<vector<int>>& books, int shelf_width, int ind, int rema...
    method minHeightShelves (line 45) | int minHeightShelves(vector<vector<int>>& books, int shelf_width) {
  class Solution (line 26) | class Solution {
    method minHeightShelves (line 3) | int minHeightShelves(vector<vector<int>>& books, int shelf_width) {
    method dfs (line 28) | int dfs(vector<vector<int>>& books, int shelf_width, int ind, int rema...
    method minHeightShelves (line 45) | int minHeightShelves(vector<vector<int>>& books, int shelf_width) {

FILE: cpp/1001-10000/1101-1110/Parsing A Boolean Expression.cpp
  class Solution (line 1) | class Solution {
    method parseBoolExpr (line 3) | bool parseBoolExpr(string expression) {

FILE: cpp/1001-10000/1101-1110/Path In Zigzag Labelled Binary Tree.cpp
  class Solution (line 1) | class Solution {
    method pathInZigZagTree (line 3) | vector<int> pathInZigZagTree(int label) {

FILE: cpp/1001-10000/1111-1120/Maximum Nesting Depth of Two Valid Parentheses Strings.cpp
  class Solution (line 1) | class Solution {
    method maxDepthAfterSplit (line 3) | vector<int> maxDepthAfterSplit(string seq) {

FILE: cpp/1001-10000/1111-1120/Print FooBar Alternately.cpp
  class FooBar (line 1) | class FooBar {
    method FooBar (line 7) | FooBar(int n) {
    method foo (line 12) | void foo(function<void()> printFoo) {
    method bar (line 24) | void bar(function<void()> printBar) {

FILE: cpp/1001-10000/1111-1120/Print in Order.cpp
  class Foo (line 1) | class Foo {
    method Foo (line 7) | Foo() {
    method first (line 11) | void first(function<void()> printFirst) {
    method second (line 17) | void second(function<void()> printSecond) {
    method third (line 24) | void third(function<void()> printThird) {

FILE: cpp/1001-10000/1121-1130/Lowest Common Ancestor of Deepest Leaves.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | pair<int, TreeNode*>  dfs(TreeNode* root) {
    method TreeNode (line 30) | TreeNode* lcaDeepestLeaves(TreeNode* root) {

FILE: cpp/1001-10000/1121-1130/Minimum Cost Tree From Leaf Values.cpp
  class Solution (line 1) | class Solution {
    method mctFromLeafValues (line 3) | int mctFromLeafValues(vector<int>& arr) {

FILE: cpp/1001-10000/1121-1130/Number of Equivalent Domino Pairs.cpp
  class Solution (line 1) | class Solution {
    method numEquivDominoPairs (line 3) | int numEquivDominoPairs(vector<vector<int>>& dominoes) {

FILE: cpp/1001-10000/1121-1130/Relative Sort Array.cpp
  class Solution (line 1) | class Solution {
    method relativeSortArray (line 3) | vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {

FILE: cpp/1001-10000/1121-1130/Smallest Sufficient Team.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 7) | bool dfs(int need_skills, int n, vector<bool>& used, map<string, bool>...
    method smallestSufficientTeam (line 53) | vector<int> smallestSufficientTeam(vector<string>& req_skills, vector<...

FILE: cpp/1001-10000/1131-1140/N-th Tribonacci Number.cpp
  class Solution (line 1) | class Solution {
    method tribonacci (line 3) | int tribonacci(int n) {

FILE: cpp/1001-10000/1141-1150/Binary Tree Coloring Game.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 15) | int dfs(TreeNode* root, int x) {
    method btreeGameWinningMove (line 31) | bool btreeGameWinningMove(TreeNode* root, int n, int x) {

FILE: cpp/1001-10000/1141-1150/Decrease Elements To Make Array Zigzag.cpp
  class Solution (line 1) | class Solution {
    method movesToMakeZigzag (line 3) | int movesToMakeZigzag(vector<int>& nums) {

FILE: cpp/1001-10000/1141-1150/Longest Chunked Palindrome Decomposition.cpp
  class Solution (line 1) | class Solution {
    method longestDecomposition (line 3) | int longestDecomposition(string text) {

FILE: cpp/1001-10000/1141-1150/Longest Common Subsequence.cpp
  class Solution (line 1) | class Solution {
    method longestCommonSubsequence (line 3) | int longestCommonSubsequence(string text1, string text2) {

FILE: cpp/1001-10000/1141-1150/Snapshot Array.cpp
  class SnapshotArray (line 1) | class SnapshotArray {
    method SnapshotArray (line 6) | SnapshotArray(int length) {
    method set (line 10) | void set(int index, int val) {
    method snap (line 15) | int snap() {
    method get (line 20) | int get(int index, int snap_id) {

FILE: cpp/1001-10000/1151-1160/Day of the Year.cpp
  class Solution (line 1) | class Solution {
    method dayOfYear (line 3) | int dayOfYear(string date) {

FILE: cpp/1001-10000/1151-1160/Find Words That Can Be Formed by Characters.cpp
  class Solution (line 1) | class Solution {
    method countCharacters (line 3) | int countCharacters(vector<string>& words, string chars) {

FILE: cpp/1001-10000/1151-1160/Number of Dice Rolls With Target Sum.cpp
  class Solution (line 1) | class Solution {
    method numRollsToTarget (line 4) | int numRollsToTarget(int d, int f, int target) {

FILE: cpp/1001-10000/1161-1170/As Far from Land as Possible.cpp
  class Solution (line 1) | class Solution {
    method maxDistance (line 3) | int maxDistance(vector<vector<int>>& grid) {

FILE: cpp/1001-10000/1161-1170/Compare Strings by Frequency of the Smallest Character.cpp
  class Solution (line 1) | class Solution {
    method getF (line 3) | int getF(const string& word) {
    method numSmallerByFrequency (line 15) | vector<int> numSmallerByFrequency(vector<string>& queries, vector<stri...

FILE: cpp/1001-10000/1161-1170/Design File System.cpp
  class FileSystem (line 1) | class FileSystem {
    method FileSystem (line 4) | FileSystem() {
    method create (line 8) | bool create(string path, int value) {
    method get (line 20) | int get(string path) {

FILE: cpp/1001-10000/1161-1170/Invalid Transactions.cpp
  class Solution (line 1) | class Solution {
    method split (line 3) | vector<string> split(const string &s, char delim) {
    method invalidTransactions (line 16) | vector<string> invalidTransactions(vector<string>& transactions) {

FILE: cpp/1001-10000/1161-1170/Maximum Level Sum of a Binary Tree.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 14) | void dfs(TreeNode* root, int level) {
    method maxLevelSum (line 22) | int maxLevelSum(TreeNode* root) {

FILE: cpp/1001-10000/1161-1170/Minimum Cost to Connect Sticks.cpp
  class Solution (line 1) | class Solution {
    method connectSticks (line 3) | int connectSticks(vector<int>& sticks) {

FILE: cpp/1001-10000/1161-1170/Optimize Water Distribution in a Village.cpp
  class UF (line 1) | class UF {
    method UF (line 11) | UF(int N) : parent(N), rank(N, 0), N(N), count(N) {
    method find (line 17) | int find(int p) {
    method connected (line 25) | bool connected(int p, int q) {
    method Union (line 29) | void Union(int p, int q) {
  class Solution (line 46) | class Solution {
    method minCostToSupplyWater (line 48) | int minCostToSupplyWater(int n, vector<int>& wells, vector<vector<int>...

FILE: cpp/1001-10000/1161-1170/Single-Row Keyboard.cpp
  class Solution (line 1) | class Solution {
    method calculateTime (line 3) | int calculateTime(string keyboard, string word) {

FILE: cpp/1001-10000/1171-1180/Can Make Palindrome from Substring.cpp
  class Solution (line 1) | class Solution {
    method canMakePaliQueries (line 3) | vector<bool> canMakePaliQueries(string s, vector<vector<int>>& queries) {

FILE: cpp/1001-10000/1171-1180/Count Substrings with Only One Distinct Letter.cpp
  class Solution (line 1) | class Solution {
    method countLetters (line 3) | int countLetters(string S) {

FILE: cpp/1001-10000/1171-1180/Diet Plan Performance.cpp
  class Solution (line 1) | class Solution {
    method dietPlanPerformance (line 3) | int dietPlanPerformance(vector<int>& calories, int k, int lower, int u...

FILE: cpp/1001-10000/1171-1180/Dinner Plate Stacks.cpp
  class DinnerPlates (line 1) | class DinnerPlates {
    method DinnerPlates (line 8) | DinnerPlates(int capacity) {
    method push (line 13) | void push(int val) {
    method pop (line 28) | int pop() {
    method popAtStack (line 43) | int popAtStack(int index) {

FILE: cpp/1001-10000/1171-1180/Prime Arrangements.cpp
  class Solution (line 1) | class Solution {
    method isPrime (line 3) | bool isPrime(int k) {
    method numPrimeArrangements (line 14) | int numPrimeArrangements(int n) {

FILE: cpp/1001-10000/1171-1180/Remove Zero Sum Consecutive Nodes from Linked List.cpp
  class Solution (line 9) | class Solution {
    method ListNode (line 11) | ListNode* removeZeroSumSublists(ListNode* head) {

FILE: cpp/1001-10000/1181-1190/Before and After Puzzle.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string getfirst(string& s) {
    method string (line 9) | string getlast(string& s) {
    method beforeAndAfterPuzzles (line 16) | vector<string> beforeAndAfterPuzzles(vector<string>& phrases) {

FILE: cpp/1001-10000/1181-1190/Day of the Week.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string dayOfTheWeek(int day, int month, int year) {

FILE: cpp/1001-10000/1181-1190/Design Bounded Blocking Queue.cpp
  class BoundedBlockingQueue (line 2) | class BoundedBlockingQueue {
    method BoundedBlockingQueue (line 10) | BoundedBlockingQueue(int capacity) {
    method enqueue (line 15) | void enqueue(int element) {
    method dequeue (line 32) | int dequeue() {
    method size (line 50) | int size() {

FILE: cpp/1001-10000/1181-1190/Distance Between Bus Stops.cpp
  class Solution (line 1) | class Solution {
    method distanceBetweenBusStops (line 3) | int distanceBetweenBusStops(vector<int>& distance, int start, int dest...

FILE: cpp/1001-10000/1181-1190/Make Array Strictly Increasing.cpp
  class Solution (line 1) | class Solution {
    method makeArrayIncreasing (line 4) | int makeArrayIncreasing(vector<int>& arr1, vector<int>& arr2) {
    method dfs (line 13) | int dfs(vector<int>& arr1, vector<int>& arr2, int i, int prev) {

FILE: cpp/1001-10000/1181-1190/Maximum Subarray Sum with One Deletion.cpp
  class Solution (line 1) | class Solution {
    method getV (line 3) | int getV(vector<int>& dp, int i) {
    method maximumSum (line 9) | int maximumSum(vector<int>& arr) {

FILE: cpp/1001-10000/1181-1190/Shortest Distance to Target Color.cpp
  class Solution (line 1) | class Solution {
    method shortestDistanceColor (line 3) | vector<int> shortestDistanceColor(vector<int>& colors, vector<vector<i...

FILE: cpp/1001-10000/1191-1200/Minimum Knight Moves.cpp
  class Solution (line 1) | class Solution {
    method minKnightMoves (line 3) | int minKnightMoves(int x, int y) {

FILE: cpp/1001-10000/1201-1210/Design Skiplist.cpp
  class Skiplist (line 1) | class Skiplist {
    type Node (line 3) | struct Node {
      method Node (line 6) | Node(Node *right, Node *down, int val): right(right), down(down), va...
    method Skiplist (line 12) | Skiplist() {
    method search (line 16) | bool search(int num) {
    method add (line 32) | void add(int num) {
    method erase (line 60) | bool erase(int num) {

FILE: cpp/1001-10000/1201-1210/Smallest String With Swaps.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | void dfs(int node, vector<int>& group, vector<int>& colors, map<int, v...
    method string (line 15) | string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {

FILE: cpp/1001-10000/1221-1230/Dice Roll Simulation.cpp
  class Solution (line 1) | class Solution {
    method dieSimulator (line 3) | int dieSimulator(int n, vector<int>& rollMax) {

FILE: cpp/1001-10000/1221-1230/Queens That Can Attack the King.cpp
  class Solution (line 1) | class Solution {
    method queensAttacktheKing (line 3) | vector<vector<int>> queensAttacktheKing(vector<vector<int>>& queens, v...

FILE: cpp/1001-10000/1221-1230/Split a String in Balanced Strings.cpp
  class Solution (line 1) | class Solution {
    method balancedStringSplit (line 3) | int balancedStringSplit(string s) {

FILE: cpp/1001-10000/1231-1240/Maximum Profit in Job Scheduling.cpp
  type Entry (line 1) | struct Entry {
  class Solution (line 7) | class Solution {
    method jobScheduling (line 9) | int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector...

FILE: cpp/1001-10000/1231-1240/Replace the Substring for Balanced String.cpp
  class Solution (line 1) | class Solution {
    method balancedString (line 4) | int balancedString(string s) {

FILE: cpp/1001-10000/1241-1250/Minimum Remove to Make Valid Parentheses.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string minRemoveToMakeValid(string s) {

FILE: cpp/1001-10000/1241-1250/Web Crawler Multithreaded.cpp
  class Solution (line 9) | class Solution {
    method string (line 21) | string extractHostName(const string& url){
    method startWorker (line 31) | void startWorker(HtmlParser* parser){
    method crawl (line 67) | vector<string> crawl(string startUrl, HtmlParser htmlParser) {

FILE: cpp/1001-10000/1261-1270/Greatest Sum Divisible by Three.cpp
  class Solution (line 1) | class Solution {
    method maxSumDivThree (line 3) | int maxSumDivThree(vector<int>& nums) {

FILE: cpp/1001-10000/1281-1290/Convert Binary Number in a Linked List to Integer.cpp
  class Solution (line 9) | class Solution {
    method getDecimalValue (line 11) | int getDecimalValue(ListNode* head) {

FILE: cpp/1001-10000/1281-1290/Element Appearing More Than 25% In Sorted Array.cpp
  class Solution (line 1) | class Solution {
    method findSpecialInteger (line 3) | int findSpecialInteger(vector<int>& arr) {

FILE: cpp/1001-10000/1281-1290/Remove Covered Intervals.cpp
  class Solution (line 1) | class Solution {
    method removeCoveredIntervals (line 3) | int removeCoveredIntervals(vector<vector<int>>& intervals) {

FILE: cpp/1001-10000/1291-1300/Maximum Side Length of a Square with Sum Less than or Equal to Threshold.cpp
  class Solution (line 1) | class Solution {
    method check (line 3) | bool check(const vector<vector<long>>& sum, int side_length, int m, in...
    method maxSideLength (line 16) | int maxSideLength(vector<vector<int>>& mat, int threshold) {

FILE: cpp/1001-10000/1291-1300/Sequential Digits.cpp
  class Solution (line 1) | class Solution {
    method sequentialDigits (line 3) | vector<int> sequentialDigits(int low, int high) {

FILE: cpp/1001-10000/1311-1320/Minimum Distance to Type a Word Using Two Fingers.cpp
  class Solution (line 1) | class Solution {
    method distance (line 3) | int distance(int from, int to) {
    method dfs (line 12) | int dfs(vector<vector<vector<int>>>& dp, const string& word, int index...
    method minimumDistance (line 24) | int minimumDistance(string word) {

FILE: cpp/1001-10000/1411-1420/Minimum Value to Get Positive Step by Step Sum.cpp
  class Solution (line 1) | class Solution {
    method minStartValue (line 3) | int minStartValue(vector<int>& nums) {

FILE: cpp/1001-10000/1421-1430/Leftmost Column with at Least a One.cpp
  class Solution (line 11) | class Solution {
    method leftMostColumnWithOne (line 13) | int leftMostColumnWithOne(BinaryMatrix &binaryMatrix) {

FILE: cpp/1001-10000/1481-1490/Avoid Flood in The City.cpp
  class Solution (line 1) | class Solution {
    method avoidFlood (line 3) | vector<int> avoidFlood(vector<int>& rains) {

FILE: cpp/1001-10000/1481-1490/Find Critical and Pseudo-Critical Edges in Minimum Spanning Tree.cpp
  class UF (line 1) | class UF {
    method UF (line 11) | UF(int N) : parent(N), rank(N, 0), N(N), count(N) {
    method find (line 17) | int find(int p) {
    method getCount (line 25) | int getCount() const {
    method connected (line 29) | bool connected(int p, int q) {
    method Union (line 33) | void Union(int p, int q) {
  class Solution (line 51) | class Solution {
    method findCriticalAndPseudoCriticalEdges (line 53) | vector<vector<int>> findCriticalAndPseudoCriticalEdges(int n, vector<v...

FILE: cpp/1001-10000/1481-1490/Making File Names Unique.cpp
  class Solution (line 1) | class Solution {
    method getFolderNames (line 3) | vector<string> getFolderNames(vector<string>& names) {

FILE: cpp/1001-10000/1481-1490/XOR Operation in an Array.cpp
  class Solution (line 1) | class Solution {
    method xorOperation (line 3) | int xorOperation(int n, int start) {

FILE: cpp/1001-10000/1501-1510/Stone Game IV.cpp
  class Solution (line 1) | class Solution {
    method winnerSquareGame (line 3) | bool winnerSquareGame(int n) {

FILE: cpp/1001-10000/1541-1550/Minimum Insertions to Balance a Parentheses String.cpp
  class Solution (line 1) | class Solution {
    method minInsertions (line 3) | int minInsertions(string s) {

FILE: cpp/1001-10000/1561-1570/Dot Product of Two Sparse Vectors.cpp
  class SparseVector (line 1) | class SparseVector {
    method SparseVector (line 6) | SparseVector(vector<int> &nums) {
    method dotProduct (line 15) | int dotProduct(SparseVector& vec) {

FILE: cpp/1001-10000/1621-1630/Arithmetic Subarrays.cpp
  class Solution (line 1) | class Solution {
    method check (line 3) | bool check(const vector<int>& vec) {
    method checkArithmeticSubarrays (line 11) | vector<bool> checkArithmeticSubarrays(vector<int>& nums, vector<int>& ...

FILE: cpp/1001-10000/1621-1630/Slowest Key.cpp
  class Solution (line 1) | class Solution {
    method slowestKey (line 3) | char slowestKey(vector<int>& releaseTimes, string keysPressed) {

FILE: cpp/1001-10000/1631-1640/Check Array Formation Through Concatenation.cpp
  class Solution (line 1) | class Solution {
    method canFormArray (line 3) | bool canFormArray(vector<int>& arr, vector<vector<int>>& pieces) {

FILE: cpp/1001-10000/1631-1640/Number of Ways to Form a Target String Given a Dictionary.cpp
  class Solution (line 1) | class Solution {
    method numWays (line 3) | int numWays(vector<string>& words, string target) {

FILE: cpp/1001-10000/1631-1640/Path With Minimum Effort.cpp
  class Solution (line 1) | class Solution {
    method minimumEffortPath (line 3) | int minimumEffortPath(vector<vector<int>>& heights) {

FILE: cpp/1001-10000/1631-1640/Rank Transform of a Matrix.cpp
  class UF (line 1) | class UF {
    method validate (line 9) | bool validate(int p) {
    method UF (line 15) | UF(int N) : parent(N), rank(N, 0), N(N), count(N) {
    method find (line 21) | int find(int p) {
    method getCount (line 30) | int getCount() const {
    method connected (line 34) | bool connected(int p, int q) {
    method Union (line 38) | void Union(int p, int q) {
  class Solution (line 56) | class Solution {
    method group (line 58) | vector<vector<pair<int, int>>> group(const vector<pair<int, int>>& pos...
    method matrixRankTransform (line 96) | vector<vector<int>> matrixRankTransform(vector<vector<int>>& matrix) {

FILE: cpp/1001-10000/1641-1650/Count Sorted Vowel Strings.cpp
  class Solution (line 1) | class Solution {
    method countVowelStrings (line 3) | int countVowelStrings(int n) {

FILE: cpp/1001-10000/1641-1650/Create Sorted Array through Instructions.cpp
  class Solution (line 2) | class Solution {
    method left (line 6) | int left(int i) { return 2 * i + 1; }
    method right (line 7) | int right(int i) { return 2 * i + 2; }
    method query (line 9) | int query(int v_min, int v_max, int l, int r, int root) {
    method update (line 21) | void update(int v, int l, int r, int root) {
    method createSortedArray (line 39) | int createSortedArray(vector<int>& instructions) {
    method left (line 66) | int left(int i) { return 2 * i + 1; }
    method right (line 67) | int right(int i) { return 2 * i + 2; }
    method query (line 69) | int query(int v_min, int v_max, int l, int r, int root) {
    method update (line 81) | void update(int v, int l, int r, int root) {
    method createSortedArray (line 99) | int createSortedArray(vector<int>& instructions) {
  class Solution (line 62) | class Solution {
    method left (line 6) | int left(int i) { return 2 * i + 1; }
    method right (line 7) | int right(int i) { return 2 * i + 2; }
    method query (line 9) | int query(int v_min, int v_max, int l, int r, int root) {
    method update (line 21) | void update(int v, int l, int r, int root) {
    method createSortedArray (line 39) | int createSortedArray(vector<int>& instructions) {
    method left (line 66) | int left(int i) { return 2 * i + 1; }
    method right (line 67) | int right(int i) { return 2 * i + 2; }
    method query (line 69) | int query(int v_min, int v_max, int l, int r, int root) {
    method update (line 81) | void update(int v, int l, int r, int root) {
    method createSortedArray (line 99) | int createSortedArray(vector<int>& instructions) {

FILE: cpp/1001-10000/1641-1650/Furthest Building You Can Reach.cpp
  class Solution (line 1) | class Solution {
    method furthestBuilding (line 3) | int furthestBuilding(vector<int>& heights, int bricks, int ladders) {

FILE: cpp/1001-10000/1641-1650/Get Maximum in Generated Array.cpp
  class Solution (line 1) | class Solution {
    method getMaximumGenerated (line 3) | int getMaximumGenerated(int n) {

FILE: cpp/1001-10000/1641-1650/Kth Smallest Instructions.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string kthSmallestPath(vector<int>& destination, int k) {

FILE: cpp/1001-10000/1641-1650/Lowest Common Ancestor of a Binary Tree II.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | pair<TreeNode*, int> dfs(TreeNode* root, TreeNode* p, TreeNode* q) {
    method TreeNode (line 32) | TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* ...

FILE: cpp/1001-10000/1641-1650/Lowest Common Ancestor of a Binary Tree III.cpp
  class Solution (line 12) | class Solution {
    method Node (line 14) | Node* lowestCommonAncestor(Node* p, Node * q) {

FILE: cpp/1001-10000/1641-1650/Minimum Deletions to Make Character Frequencies Unique.cpp
  class Solution (line 1) | class Solution {
    method minDeletions (line 3) | int minDeletions(string s) {

FILE: cpp/1001-10000/1641-1650/Sell Diminishing-Valued Colored Balls.cpp
  class Solution (line 1) | class Solution {
    method get (line 3) | long get(long a, long b) {
    method maxProfit (line 8) | int maxProfit(vector<int>& inventory, int orders) {

FILE: cpp/1001-10000/1671-1680/Lowest Common Ancestor of a Binary Tree IV.cpp
  class Solution (line 12) | class Solution {
    method TreeNode (line 14) | TreeNode* lowestCommonAncestor(TreeNode* root, const set<TreeNode*>& n...
    method TreeNode (line 34) | TreeNode* lowestCommonAncestor(TreeNode* root, vector<TreeNode*> &node...

FILE: cpp/1001-10000/1671-1680/Minimum Moves to Make Array Complementary.cpp
  class Solution (line 1) | class Solution {
    method minMoves (line 3) | int minMoves(vector<int>& nums, int limit) {

FILE: cpp/1001-10000/1681-1690/Delivering Boxes from Storage to Ports.cpp
  class Solution (line 1) | class Solution {
    method boxDelivering (line 3) | int boxDelivering(vector<vector<int>>& boxes, int portsCount, int maxB...

FILE: cpp/1001-10000/1681-1690/Stone Game VI.cpp
  class Solution (line 1) | class Solution {
    method stoneGameVI (line 3) | int stoneGameVI(vector<int>& aliceValues, vector<int>& bobValues) {

FILE: cpp/1001-10000/1681-1690/Sum of Absolute Differences in a Sorted Array.cpp
  class Solution (line 1) | class Solution {
    method getSumAbsoluteDifferences (line 3) | vector<int> getSumAbsoluteDifferences(vector<int>& nums) {

FILE: cpp/1001-10000/1701-1710/Determine if String Halves Are Alike.cpp
  class Solution (line 1) | class Solution {
    method halvesAreAlike (line 3) | bool halvesAreAlike(string s) {

FILE: cpp/1001-10000/1701-1710/Maximum Number of Eaten Apples.cpp
  class Solution (line 1) | class Solution {
    method eatenApples (line 3) | int eatenApples(vector<int>& apples, vector<int>& days) {

FILE: cpp/1001-10000/1701-1710/Maximum Units on a Truck.cpp
  class Solution (line 1) | class Solution {
    method maximumUnits (line 3) | int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {

FILE: cpp/1001-10000/1701-1710/Maximum XOR With an Element From Array.cpp
  class Solution (line 1) | class Solution {
    class TreeNode (line 3) | class TreeNode {
      method TreeNode (line 6) | TreeNode () {next[0] = nullptr; next[1] = nullptr;}
    method TreeNode (line 8) | TreeNode* buildTree(vector<int>& nums) {
      method TreeNode (line 6) | TreeNode () {next[0] = nullptr; next[1] = nullptr;}
    method dfs (line 24) | int dfs(TreeNode* root, int x, int limit, int value, int height) {
    method maximizeXor (line 44) | vector<int> maximizeXor(vector<int>& nums, vector<vector<int>>& querie...

FILE: cpp/1001-10000/1701-1710/Where Will the Ball Fall.cpp
  class Solution (line 1) | class Solution {
    method findBall (line 4) | vector<int> findBall(vector<vector<int>>& grid) {

FILE: cpp/1001-10000/1711-1720/Count Good Meals.cpp
  class Solution (line 1) | class Solution {
    method countPairs (line 3) | int countPairs(vector<int>& deliciousness) {

FILE: cpp/1001-10000/1711-1720/Decode XORed Array.cpp
  class Solution (line 1) | class Solution {
    method decode (line 3) | vector<int> decode(vector<int>& encoded, int first) {

FILE: cpp/1001-10000/1711-1720/Minimum Operations to Make a Subsequence.cpp
  class Solution (line 1) | class Solution {
    method lengthOfLIS (line 3) | int lengthOfLIS(vector<int>& nums) {
    method minOperations (line 14) | int minOperations(vector<int>& target, vector<int>& arr) {

FILE: cpp/1001-10000/1711-1720/Ways to Split Array Into Three Subarrays.cpp
  class Solution (line 1) | class Solution {
    method waysToSplit (line 3) | int waysToSplit(vector<int>& nums) {
    method waysToSplit (line 47) | int waysToSplit(vector<int>& nums) {
  class Solution (line 45) | class Solution {
    method waysToSplit (line 3) | int waysToSplit(vector<int>& nums) {
    method waysToSplit (line 47) | int waysToSplit(vector<int>& nums) {

FILE: cpp/1001-10000/1721-1730/Find Minimum Time to Finish All Jobs.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 5) | void dfs(vector<int>& jobs, int k, vector<int>& workers, int curr) {
    method minimumTimeRequired (line 24) | int minimumTimeRequired(vector<int>& jobs, int k) {

FILE: cpp/1001-10000/1721-1730/Largest Submatrix With Rearrangements.cpp
  class Solution (line 1) | class Solution {
    method largestSubmatrix (line 3) | int largestSubmatrix(vector<vector<int>>& matrix) {

FILE: cpp/1001-10000/1721-1730/Minimize Hamming Distance After Swap Operations.cpp
  class UF (line 1) | class UF {
    method validate (line 9) | bool validate(int p) {
    method UF (line 15) | UF(int N) : parent(N), rank(N, 0), N(N), count(N) {
    method find (line 21) | int find(int p) {
    method getCount (line 30) | int getCount() const {
    method connected (line 34) | bool connected(int p, int q) {
    method Union (line 38) | void Union(int p, int q) {
  class Solution (line 56) | class Solution {
    method minimumHammingDistance (line 58) | int minimumHammingDistance(vector<int>& source, vector<int>& target, v...

FILE: cpp/1001-10000/1721-1730/Number Of Rectangles That Can Form The Largest Square.cpp
  class Solution (line 1) | class Solution {
    method countGoodRectangles (line 3) | int countGoodRectangles(vector<vector<int>>& rectangles) {

FILE: cpp/1001-10000/1721-1730/Swapping Nodes in a Linked List.cpp
  class Solution (line 11) | class Solution {
    method ListNode (line 13) | ListNode* swapNodes(ListNode* head, int k) {

FILE: cpp/1001-10000/1721-1730/Tuple with Same Product.cpp
  class Solution (line 1) | class Solution {
    method tupleSameProduct (line 3) | int tupleSameProduct(vector<int>& nums) {

FILE: cpp/1001-10000/1731-1740/Building Boxes.cpp
  class Solution (line 1) | class Solution {
    method minimumBoxes (line 3) | int minimumBoxes(int n) {

FILE: cpp/1001-10000/1751-1760/Closest Subsequence Sum.cpp
  class Solution (line 1) | class Solution {
    method maxValue (line 4) | int maxValue(vector<vector<int>>& events, int k) {

FILE: cpp/1001-10000/1751-1760/Largest Merge Of Two Strings.cpp
  class Solution (line 1) | class Solution {
    method string (line 4) | string largestMerge(string word1, string word2) {

FILE: cpp/1001-10000/1751-1760/Maximum Number of Events That Can Be Attended II.cpp
  class Solution (line 1) | class Solution {
    method maxValue (line 4) | int maxValue(vector<vector<int>>& events, int k) {

FILE: cpp/1001-10000/1751-1760/Minimum Limit of Balls in a Bag.cpp
  class Solution (line 1) | class Solution {
    method check (line 3) | bool check(const vector<int>& nums, int maxOperations, int penalty) {
    method minimumSize (line 12) | int minimumSize(vector<int>& nums, int maxOperations) {

FILE: cpp/1001-10000/1761-1770/Form Array by Concatenating Subarrays of Another Array.cpp
  class Solution (line 1) | class Solution {
    method MatchGroup (line 3) | int MatchGroup(const vector<int>& group, const vector<int>& nums,  int...
    method canChoose (line 22) | bool canChoose(vector<vector<int>>& groups, vector<int>& nums) {

FILE: cpp/1001-10000/1761-1770/Map of Highest Peak.cpp
  class Solution (line 1) | class Solution {
    method highestPeak (line 3) | vector<vector<int>> highestPeak(vector<vector<int>>& isWater) {

FILE: cpp/1001-10000/1761-1770/Maximum Score from Performing Multiplication Operations.cpp
  class Solution (line 1) | class Solution {
    method maximumScore (line 3) | int maximumScore(vector<int>& nums, vector<int>& multipliers) {

FILE: cpp/1001-10000/1761-1770/Minimum Degree of a Connected Trio in a Graph.cpp
  class Solution (line 1) | class Solution {
    method minTrioDegree (line 3) | int minTrioDegree(int n, vector<vector<int>>& edges) {

FILE: cpp/1001-10000/1761-1770/Tree of Coprimes.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | void dfs(int node, const vector<int>& nums, const vector<vector<int>>&...
    method getCoprimes (line 33) | vector<int> getCoprimes(vector<int>& nums, vector<vector<int>>& edges) {

FILE: cpp/1001-10000/1771-1780/Car Fleet II.cpp
  class Solution (line 1) | class Solution {
    method getCollisionTimes (line 3) | vector<double> getCollisionTimes(vector<vector<int>>& cars) {

FILE: cpp/1001-10000/1771-1780/Check if Number is a Sum of Powers of Three.cpp
  class Solution (line 1) | class Solution {
    method checkPowersOfThree (line 3) | bool checkPowersOfThree(int n) {

FILE: cpp/1001-10000/1771-1780/Closest Dessert Cost.cpp
  class Solution (line 1) | class Solution {
    method closestCost (line 3) | int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int...

FILE: cpp/1001-10000/1771-1780/Equal Sum Arrays With Minimum Number of Operations.cpp
  class Solution (line 1) | class Solution {
    method process (line 3) | int process(int* table1, int* table2, int diff) {
    method minOperations (line 24) | int minOperations(vector<int>& nums1, vector<int>& nums2) {

FILE: cpp/1001-10000/1771-1780/Find Nearest Point That Has the Same X or Y Coordinate.cpp
  class Solution (line 1) | class Solution {
    method nearestValidPoint (line 3) | int nearestValidPoint(int x, int y, vector<vector<int>>& points) {

FILE: cpp/1001-10000/1771-1780/Maximize Palindrome Length From Subsequences.cpp
  class Solution (line 1) | class Solution {
    method longestPalindrome (line 3) | int longestPalindrome(string word1, string word2) {

FILE: cpp/1001-10000/1771-1780/Shortest Path in a Hidden Grid.cpp
  class Solution (line 12) | class Solution {
    method ConstructGrid (line 15) | void ConstructGrid(vector<vector<int>>& grid, GridMaster &master, int ...
    method findShortestPath (line 40) | int findShortestPath(GridMaster &master) {

FILE: cpp/1001-10000/1781-1790/Check if Binary String Has at Most One Segment of Ones.cpp
  class Solution (line 1) | class Solution {
    method checkOnesSegment (line 3) | bool checkOnesSegment(string s) {

FILE: cpp/1001-10000/1781-1790/Check if One String Swap Can Make Strings Equal.cpp
  class Solution (line 1) | class Solution {
    method areAlmostEqual (line 3) | bool areAlmostEqual(string s1, string s2) {

FILE: cpp/1001-10000/1781-1790/Count Pairs Of Nodes.cpp
  class Solution (line 1) | class Solution {
    method countPairs (line 3) | vector<int> countPairs(int n, vector<vector<int>>& edges, vector<int>&...

FILE: cpp/1001-10000/1781-1790/Make the XOR of All Segments Equal to Zero.cpp
  class Solution (line 1) | class Solution {
    method minChanges (line 3) | int minChanges(vector<int>& nums, int k) {

FILE: cpp/1001-10000/1781-1790/Maximize the Beauty of the Garden.cpp
  class Solution (line 1) | class Solution {
    method maximumBeauty (line 3) | int maximumBeauty(vector<int>& flowers) {

FILE: cpp/1001-10000/1781-1790/Minimum Elements to Add to Form a Given Sum.cpp
  class Solution (line 1) | class Solution {
    method minElements (line 3) | int minElements(vector<int>& nums, int limit, int goal) {

FILE: cpp/1001-10000/1781-1790/Number of Restricted Paths From First to Last Node.cpp
  class Solution (line 1) | class Solution {
    method bfs (line 4) | void bfs(int n, const vector<vector<pair<int, int>>>& graph, vector<in...
    method countRestrictedPaths (line 33) | int countRestrictedPaths(int n, vector<vector<int>>& edges) {

FILE: cpp/1001-10000/1781-1790/Sum of Beauty of All Substrings.cpp
  class Solution (line 1) | class Solution {
    method beautySum (line 3) | int beautySum(string s) {

FILE: cpp/1001-10000/1791-1800/Count Pairs of Equal Substrings With Minimum Difference.cpp
  class Solution (line 1) | class Solution {
    method countQuadruples (line 3) | int countQuadruples(string firstString, string secondString) {

FILE: cpp/1001-10000/1791-1800/Design Authentication Manager.cpp
  class AuthenticationManager (line 1) | class AuthenticationManager {
    method AuthenticationManager (line 5) | AuthenticationManager(int timeToLive) {
    method generate (line 9) | void generate(string tokenId, int currentTime) {
    method renew (line 13) | void renew(string tokenId, int currentTime) {
    method countUnexpiredTokens (line 25) | int countUnexpiredTokens(int currentTime) {

FILE: cpp/1001-10000/1791-1800/Find Center of Star Graph.cpp
  class Solution (line 1) | class Solution {
    method findCenter (line 3) | int findCenter(vector<vector<int>>& edges) {

FILE: cpp/1001-10000/1791-1800/Maximize Score After N Operations.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 2) | int dfs(const vector<int>& nums, int round, int state, unordered_map<i...
    method maxScore (line 23) | int maxScore(vector<int>& nums) {

FILE: cpp/1001-10000/1791-1800/Maximum Ascending Subarray Sum.cpp
  class Solution (line 1) | class Solution {
    method maxAscendingSum (line 3) | int maxAscendingSum(vector<int>& nums) {

FILE: cpp/1001-10000/1791-1800/Maximum Average Pass Ratio.cpp
  class Solution (line 4) | class Solution {
    method maxAverageRatio (line 6) | double maxAverageRatio(vector<vector<int>>& classes, int extraStudents) {
    method GetIncrease (line 45) | double GetIncrease(int dividend, int divisor) {
    method maxAverageRatio (line 51) | double maxAverageRatio(vector<vector<int>>& classes, int extraStudents) {
  class Solution (line 44) | class Solution {
    method maxAverageRatio (line 6) | double maxAverageRatio(vector<vector<int>>& classes, int extraStudents) {
    method GetIncrease (line 45) | double GetIncrease(int dividend, int divisor) {
    method maxAverageRatio (line 51) | double maxAverageRatio(vector<vector<int>>& classes, int extraStudents) {

FILE: cpp/1001-10000/1791-1800/Maximum Number of Consecutive Values You Can Make.cpp
  class Solution (line 1) | class Solution {
    method getMaximumConsecutive (line 3) | int getMaximumConsecutive(vector<int>& coins) {

FILE: cpp/1001-10000/1791-1800/Maximum Score of a Good Subarray.cpp
  class Solution (line 1) | class Solution {
    method maximumScore (line 3) | int maximumScore(vector<int>& nums, int k) {

FILE: cpp/1001-10000/1791-1800/Second Largest Digit in a String.cpp
  class Solution (line 1) | class Solution {
    method secondHighest (line 3) | int secondHighest(string s) {

FILE: cpp/1001-10000/1801-1810/Count Pairs With XOR in a Range.cpp
  class Solution (line 1) | class Solution {
    class TreeNode (line 5) | class TreeNode {
      method TreeNode (line 9) | TreeNode () {
    method insert (line 16) | void insert(TreeNode* root, int num) {
    method GetCount (line 27) | int GetCount(TreeNode* root, int num, int limit) {
    method countPairs (line 52) | int countPairs(vector<int>& nums, int low, int high) {

FILE: cpp/1001-10000/1801-1810/Evaluate the Bracket Pairs of a String.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string evaluate(string s, vector<vector<string>>& knowledge) {

FILE: cpp/1001-10000/1801-1810/Implement Trie II (Prefix Tree).cpp
  class Trie (line 1) | class Trie {
    type TrieNode (line 3) | struct TrieNode {
      method TrieNode (line 8) | TrieNode() {
    method Trie (line 18) | Trie() {
    method insert (line 22) | void insert(string word) {
    method countWordsEqualTo (line 35) | int countWordsEqualTo(string word) {
    method countWordsStartingWith (line 47) | int countWordsStartingWith(string prefix) {
    method erase (line 59) | void erase(string word) {

FILE: cpp/1001-10000/1801-1810/Maximize Number of Nice Divisors.cpp
  class Solution (line 1) | class Solution {
    method maxNiceDivisors (line 6) | int maxNiceDivisors(int primeFactors) {

FILE: cpp/1001-10000/1801-1810/Maximum Value at a Given Index in a Bounded Array.cpp
  class Solution (line 1) | class Solution {
    method getSumInRange (line 3) | long getSumInRange(long peak, int length) {
    method check (line 15) | bool check(int n, int index, int maxSum, int peak) {
    method maxValue (line 21) | int maxValue(int n, int index, int maxSum) {

FILE: cpp/1001-10000/1801-1810/Minimum Path Cost in a Hidden Grid.cpp
  class Solution (line 12) | class Solution {
    method ConstructGrid (line 16) | void ConstructGrid(vector<vector<int>>& grid, GridMaster &master, int ...
    method findShortestPath (line 42) | int findShortestPath(GridMaster &master) {

FILE: cpp/1001-10000/1801-1810/Number of Different Integers in a String.cpp
  class Solution (line 1) | class Solution {
    method numDifferentIntegers (line 3) | int numDifferentIntegers(string word) {

FILE: cpp/1001-10000/1801-1810/Number of Orders in the Backlog.cpp
  class Solution (line 1) | class Solution {
    method getNumberOfBacklogOrders (line 3) | int getNumberOfBacklogOrders(vector<vector<int>>& orders) {

FILE: cpp/1001-10000/1811-1820/Count Nice Pairs in an Array.cpp
  class Solution (line 1) | class Solution {
    method reverse (line 3) | int reverse(int x) {
    method countNicePairs (line 12) | int countNicePairs(vector<int>& nums) {

FILE: cpp/1001-10000/1811-1820/Determine Color of a Chessboard Square.cpp
  class Solution (line 1) | class Solution {
    method squareIsWhite (line 3) | bool squareIsWhite(string coordinates) {

FILE: cpp/1001-10000/1811-1820/Finding the Users Active Minutes.cpp
  class Solution (line 1) | class Solution {
    method findingUsersActiveMinutes (line 3) | vector<int> findingUsersActiveMinutes(vector<vector<int>>& logs, int k) {

FILE: cpp/1001-10000/1811-1820/Maximum Number of Accepted Invitations.cpp
  class Solution (line 1) | class Solution {
    method BipartiteMatch (line 4) | bool BipartiteMatch(const vector<vector<int>>& grid, int u, vector<boo...
    method maximumInvitations (line 20) | int maximumInvitations(vector<vector<int>>& grid) {

FILE: cpp/1001-10000/1811-1820/Maximum Number of Groups Getting Fresh Donuts.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string GetKey(const vector<int>& cnts) {
    method dfs (line 11) | int dfs(vector<int>& cnts, int remain, int batchSize, unordered_map<st...
    method maxHappyGroups (line 30) | int maxHappyGroups(int batchSize, vector<int>& groups) {

FILE: cpp/1001-10000/1811-1820/Minimum Absolute Sum Difference.cpp
  class Solution (line 1) | class Solution {
    method minAbsoluteSumDiff (line 3) | int minAbsoluteSumDiff(vector<int>& nums1, vector<int>& nums2) {

FILE: cpp/1001-10000/1811-1820/Number of Different Subsequences GCDs.cpp
  class Solution (line 1) | class Solution {
    method countDifferentSubsequenceGCDs (line 3) | int countDifferentSubsequenceGCDs(vector<int>& nums) {

FILE: cpp/1001-10000/1811-1820/Sentence Similarity III.cpp
  class Solution (line 1) | class Solution {
    method split (line 3) | vector<string> split(const string &s, char delim) {
    method areSentencesSimilar (line 15) | bool areSentencesSimilar(string sentence1, string sentence2) {

FILE: cpp/1001-10000/1811-1820/Truncate Sentence.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string truncateSentence(string s, int k) {

FILE: cpp/1001-10000/1821-1830/Faulty Sensor.cpp
  class Solution (line 1) | class Solution {
    method badSensor (line 3) | int badSensor(vector<int>& sensor1, vector<int>& sensor2) {

FILE: cpp/1001-10000/1821-1830/Finding MK Average.cpp
  class MKAverage (line 1) | class MKAverage {
    method InitializeMultiset (line 12) | void InitializeMultiset() {
    method MKAverage (line 32) | MKAverage(int m, int k) {
    method AddElement (line 37) | void AddElement(int val) {
    method RemoveElement (line 62) | void RemoveElement() {
    method addElement (line 83) | void addElement(int num) {
    method calculateMKAverage (line 90) | int calculateMKAverage() {

FILE: cpp/1001-10000/1821-1830/Maximum XOR for Each Query.cpp
  class Solution (line 1) | class Solution {
    method getMaximumXor (line 3) | vector<int> getMaximumXor(vector<int>& nums, int maximumBit) {

FILE: cpp/1001-10000/1821-1830/Minimum Number of Operations to Make String Sorted.cpp
  class Solution (line 1) | class Solution {
    method pow (line 4) | long pow(long a, long p, long mod) {
    method makeStringSorted (line 17) | int makeStringSorted(string s) {

FILE: cpp/1001-10000/1821-1830/Minimum Operations to Make the Array Increasing.cpp
  class Solution (line 1) | class Solution {
    method minOperations (line 3) | int minOperations(vector<int>& nums) {

FILE: cpp/1001-10000/1821-1830/Minimum Sideway Jumps.cpp
  class Solution (line 1) | class Solution {
    method minSideJumps (line 3) | int minSideJumps(vector<int>& obstacles) {

FILE: cpp/1001-10000/1821-1830/Queries on Number of Points Inside a Circle.cpp
  class Solution (line 1) | class Solution {
    method countPoints (line 3) | vector<int> countPoints(vector<vector<int>>& points, vector<vector<int...

FILE: cpp/1001-10000/1821-1830/Sign of the Product of an Array.cpp
  class Solution (line 1) | class Solution {
    method arraySign (line 3) | int arraySign(vector<int>& nums) {

FILE: cpp/1001-10000/1831-1840/Check if the Sentence Is Pangram.cpp
  class Solution (line 1) | class Solution {
    method checkIfPangram (line 3) | bool checkIfPangram(string sentence) {

FILE: cpp/1001-10000/1831-1840/Find XOR Sum of All Pairs Bitwise AND.cpp
  class Solution (line 1) | class Solution {
    method getXORSum (line 3) | int getXORSum(vector<int>& arr1, vector<int>& arr2) {

FILE: cpp/1001-10000/1831-1840/Longest Substring Of All Vowels in Order.cpp
  class Solution (line 1) | class Solution {
    method longestBeautifulSubstring (line 3) | int longestBeautifulSubstring(string word) {

FILE: cpp/1001-10000/1831-1840/Maximum Building Height.cpp
  class Solution (line 1) | class Solution {
    method maxBuilding (line 3) | int maxBuilding(int n, vector<vector<int>>& restrictions) {

FILE: cpp/1001-10000/1831-1840/Maximum Ice Cream Bars.cpp
  class Solution (line 1) | class Solution {
    method maxIceCream (line 3) | int maxIceCream(vector<int>& costs, int coins) {

FILE: cpp/1001-10000/1831-1840/Remove Duplicates From an Unsorted Linked List.cpp
  class Solution (line 11) | class Solution {
    method ListNode (line 13) | ListNode* deleteDuplicatesUnsorted(ListNode* head) {

FILE: cpp/1001-10000/1831-1840/Single-Threaded CPU.cpp
  class Solution (line 1) | class Solution {
    method getOrder (line 3) | vector<int> getOrder(vector<vector<int>>& tasks) {

FILE: cpp/1001-10000/1831-1840/Sum of Digits in Base K.cpp
  class Solution (line 1) | class Solution {
    method sumBase (line 3) | int sumBase(int n, int k) {

FILE: cpp/1001-10000/1841-1850/Closest Room.cpp
  class Solution (line 1) | class Solution {
    method closestRoom (line 3) | vector<int> closestRoom(vector<vector<int>>& rooms, vector<vector<int>...

FILE: cpp/1001-10000/1841-1850/Minimum Adjacent Swaps to Reach the Kth Smallest Number.cpp
  class Solution (line 1) | class Solution {
    method getMinSwaps (line 3) | int getMinSwaps(string num, int k) {

FILE: cpp/1001-10000/1851-1860/Minimum Interval to Include Each Query.cpp
  class Solution (line 1) | class Solution {
    method minInterval (line 3) | vector<int> minInterval(vector<vector<int>>& intervals, vector<int>& q...

FILE: cpp/101-110/Balanced Binary Tree.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | int help(TreeNode *root, bool& flag) {
    method isBalanced (line 13) | bool isBalanced(TreeNode *root) {

FILE: cpp/101-110/Binary Tree Level Order Traversal II.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | void help(TreeNode *root, int level, vector<vector<int>>& results)
    method levelOrderBottom (line 19) | vector<vector<int> > levelOrderBottom(TreeNode *root) {

FILE: cpp/101-110/Binary Tree Level Order Traversal.cpp
  class Solution (line 10) | class Solution {
    method levelOrder (line 12) | vector<vector<int>> levelOrder(TreeNode* root) {

FILE: cpp/101-110/Binary Tree Zigzag Level Order Traversal.cpp
  class Solution (line 1) | class Solution {
    method zigzagLevelOrder (line 4) | vector<vector<int> > zigzagLevelOrder(TreeNode *root) {

FILE: cpp/101-110/Construct Binary Tree from Inorder and Postorder Traversal.cpp
  class Solution (line 1) | class Solution {
    method TreeNode (line 3) | TreeNode* helper(vector<int>& postorder,int i,int j,vector<int>& inord...
    method TreeNode (line 15) | TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {

FILE: cpp/101-110/Construct Binary Tree from Preorder and Inorder Traversal.cpp
  class Solution (line 1) | class Solution {
    method TreeNode (line 3) | TreeNode* helper(vector<int>& preorder,int i,int j,vector<int>& inorde...
    method TreeNode (line 15) | TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {

FILE: cpp/101-110/Convert Sorted Array to Binary Search Tree.cpp
  class Solution (line 1) | class Solution {
    method TreeNode (line 3) | TreeNode *help(vector<int>::iterator it1, vector<int>::iterator it2) {
    method TreeNode (line 16) | TreeNode *sortedArrayToBST(vector<int> &num) {

FILE: cpp/101-110/Convert Sorted List to Binary Search Tree.cpp
  class Solution (line 18) | class Solution {
    method len (line 22) | int len(ListNode *head)
    method TreeNode (line 32) | TreeNode *help(int n)
    method TreeNode (line 44) | TreeNode *sortedListToBST(ListNode *head) {

FILE: cpp/101-110/Maximum Depth of Binary Tree.cpp
  class Solution (line 1) | class Solution {
    method maxDepth (line 3) | int maxDepth(TreeNode *root) {

FILE: cpp/101-110/Symmetric Tree.cpp
  class Solution (line 1) | class Solution {
    method isSymmetric (line 3) | bool isSymmetric(TreeNode *root) {

FILE: cpp/111-120/Distinct Subsequences.cpp
  class Solution (line 1) | class Solution {
    method numDistinct (line 3) | int numDistinct(string s, string t) {

FILE: cpp/111-120/Flatten Binary Tree to Linked List.cpp
  class Solution (line 1) | class Solution {
    method TreeNode (line 3) | TreeNode* flatten(TreeNode* root, TreeNode* pre) {
    method flatten (line 14) | void flatten(TreeNode* root) {

FILE: cpp/111-120/Minimum Depth of Binary Tree.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | int help(TreeNode *root)
    method minDepth (line 16) | int minDepth(TreeNode *root) {

FILE: cpp/111-120/Pascal's Triangle II.cpp
  class Solution (line 1) | class Solution {
    method getRow (line 3) | vector<int> getRow(int rowIndex) {

FILE: cpp/111-120/Pascal's Triangle.cpp
  class Solution (line 1) | class Solution {
    method generate (line 3) | vector<vector<int> > generate(int numRows) {

FILE: cpp/111-120/Path Sum II.cpp
  class Solution (line 1) | class Solution {
    method pathSum (line 3) | vector<vector<int>> pathSum(TreeNode* root, int sum) {
    method findPaths (line 10) | void findPaths(TreeNode* node, int sum, vector<int>& path, vector<vect...

FILE: cpp/111-120/Path Sum.cpp
  class Solution (line 1) | class Solution {
    method hasPathSum (line 4) | bool hasPathSum(TreeNode *root, int sum) {

FILE: cpp/111-120/Populating Next Right Pointers in Each Node II.cpp
  class Solution (line 9) | class Solution {
    method connect (line 11) | void connect(TreeLinkNode *root) {

FILE: cpp/111-120/Populating Next Right Pointers in Each Node.cpp
  class Solution (line 1) | class Solution {
    method connect (line 3) | void connect(TreeLinkNode *root) {

FILE: cpp/111-120/Triangle.cpp
  class Solution (line 1) | class Solution {
    method minimumTotal (line 3) | int minimumTotal(vector<vector<int> > &triangle) {

FILE: cpp/121-130/Best Time to Buy and Sell Stock II.cpp
  class Solution (line 1) | class Solution {
    method maxProfit (line 3) | int maxProfit(vector<int> &prices) {

FILE: cpp/121-130/Best Time to Buy and Sell Stock III.cpp
  class Solution (line 1) | class Solution {
    method maxProfit (line 6) | int maxProfit(vector<int> &prices) {

FILE: cpp/121-130/Best Time to Buy and Sell Stock.cpp
  class Solution (line 1) | class Solution {
    method maxProfit (line 3) | int maxProfit(vector<int> &prices) {

FILE: cpp/121-130/Binary Tree Maximum Path Sum.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | int dfs(TreeNode *root, int& result) {
    method maxPathSum (line 16) | int maxPathSum(TreeNode *root) {

FILE: cpp/121-130/Longest Consecutive Sequence.cpp
  class Solution (line 1) | class Solution {
    method longestConsecutive (line 3) | int longestConsecutive(vector<int>& nums) {

FILE: cpp/121-130/Sum Root to Leaf Numbers.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | int help(TreeNode *root, int pVal)
    method sumNumbers (line 19) | int sumNumbers(TreeNode *root) {

FILE: cpp/121-130/Surrounded Regions.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | void help(vector<vector<char>> &board, int ii, int jj)
    method solve (line 31) | void solve(vector<vector<char>> &board) {

FILE: cpp/121-130/Valid Palindrome.cpp
  class Solution (line 1) | class Solution {
    method isPalindrome (line 4) | bool isPalindrome(string s) {

FILE: cpp/121-130/Word Ladder II.cpp
  class Solution (line 1) | class Solution {
    method findLadders (line 3) | vector<vector<string>> findLadders(string beginWord, string endWord, v...
    method helper (line 37) | void helper(string start, string end, unordered_map<string, vector<str...

FILE: cpp/121-130/Word Ladder.cpp
  class Solution (line 3) | class Solution {
    method ladderLength (line 5) | int ladderLength(string beginWord, string endWord, vector<string>& wor...

FILE: cpp/131-140/Candy.cpp
  class Solution (line 1) | class Solution {
    method candy (line 3) | int candy(vector<int>& ratings) {

FILE: cpp/131-140/Clone Graph.cpp
  class Solution (line 16) | class Solution {
    method Node (line 20) | Node* cloneGraph(Node* node) {

FILE: cpp/131-140/Copy List with Random Pointer.cpp
  class Solution (line 1) | class Solution {
    method RandomListNode (line 3) | RandomListNode *copyRandomList(RandomListNode *head) {

FILE: cpp/131-140/Gas Station.cpp
  class Solution (line 1) | class Solution {
    method canCompleteCircuit (line 3) | int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {

FILE: cpp/131-140/Palindrome Partitioning II.cpp
  class Solution (line 1) | class Solution {
    method minCut (line 3) | int minCut(string s) {

FILE: cpp/131-140/Palindrome Partitioning.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | void dfs(int index, string& s, vector<string>& path, vector<vector<str...
    method partition (line 19) | vector<vector<string>> partition(string s) {

FILE: cpp/131-140/Single Number II.cpp
  class Solution (line 1) | class Solution {
    method singleNumber (line 3) | int singleNumber(vector<int>& nums) {

FILE: cpp/131-140/Single Number.cpp
  class Solution (line 1) | class Solution {
    method singleNumber (line 3) | int singleNumber(vector<int>& nums) {

FILE: cpp/131-140/Word Break II.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 5) | vector<string> dfs(string s, unordered_set<string>& dict) {
    method wordBreak (line 28) | vector<string> wordBreak(string s, vector<string>& wordDict) {

FILE: cpp/131-140/Word Break.cpp
  class Solution (line 1) | class Solution {
    method wordBreak (line 3) | bool wordBreak(string s, vector<string>& wordDict) {

FILE: cpp/141-150/Binary Tree Postorder Traversal.cpp
  class Solution (line 1) | class Solution {
    method postorderTraversal (line 3) | vector<int> postorderTraversal(TreeNode* root) {

FILE: cpp/141-150/Evaluate Reverse Polish Notation.cpp
  class Solution (line 1) | class Solution {
    method evalRPN (line 3) | int evalRPN(vector<string> &tokens) {

FILE: cpp/141-150/Insertion Sort List.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 4) | ListNode *insertionSortList(ListNode *head) {

FILE: cpp/141-150/LRU Cache.cpp
  class LRUCache (line 1) | class LRUCache {
    method LRUCache (line 3) | LRUCache(int capacity) : _capacity(capacity) {}
    method get (line 5) | int get(int key) {
    method set (line 12) | void set(int key, int value) {
    method touch (line 30) | void touch(HIPII::iterator it) {

FILE: cpp/141-150/Linked List Cycle II.cpp
  class Solution (line 9) | class Solution {
    method ListNode (line 11) | ListNode *detectCycle(ListNode *head) {

FILE: cpp/141-150/Linked List Cycle.cpp
  class Solution (line 9) | class Solution {
    method hasCycle (line 11) | bool hasCycle(ListNode *head) {

FILE: cpp/141-150/Max Points on a Line.cpp
  class Solution (line 1) | class Solution {
    method maxPoints (line 3) | int maxPoints(vector<vector<int>> &points) {

FILE: cpp/141-150/Reorder List.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 3) | ListNode* reverse(ListNode *head)
    method reorderList (line 19) | void reorderList(ListNode *head) {

FILE: cpp/141-150/Sort List.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 5) | ListNode* merge(ListNode *node1, int n1, ListNode *node2, int n2, List...
    method lengthOfList (line 58) | int lengthOfList(ListNode *node)
    method ListNode (line 69) | ListNode* find(ListNode* node, int L)
    method ListNode (line 79) | ListNode *sortList(ListNode *head) {

FILE: cpp/141-150/Tree Preorder Traversal.cpp
  class Solution (line 1) | class Solution {
    method preorderTraversal (line 3) | vector<int> preorderTraversal(TreeNode *root) {

FILE: cpp/151-160/Binary Tree Upside Down.cpp
  class Solution (line 10) | class Solution {
    method TreeNode (line 14) | TreeNode* upsideDownBinaryTree(TreeNode* root) {

FILE: cpp/151-160/Find Minimum in Rotated Sorted Array II.cpp
  class Solution (line 1) | class Solution {
    method findMin (line 3) | int findMin(vector<int>& nums) {

FILE: cpp/151-160/Find Minimum in Rotated Sorted Array.cpp
  class Solution (line 1) | class Solution {
    method findMin (line 3) | int findMin(vector<int>& nums) {

FILE: cpp/151-160/Intersection of Two Linked Lists.cpp
  class Solution (line 1) | class Solution {
    method getLen (line 3) | int getLen(ListNode *head) {
    method ListNode (line 13) | ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

FILE: cpp/151-160/Longest Substring with At Most Two Distinct Characters.cpp
  class Solution (line 1) | class Solution {
    method lengthOfLongestSubstringTwoDistinct (line 3) | int lengthOfLongestSubstringTwoDistinct(string s) {

FILE: cpp/151-160/Maximum Product Subarray.cpp
  class Solution (line 1) | class Solution {
    method maxProduct (line 3) | int maxProduct(vector<int>& nums) {

FILE: cpp/151-160/Min Stack.cpp
  class MinStack (line 1) | class MinStack {
    method push (line 7) | void push(int x) {
    method pop (line 12) | void pop() {
    method top (line 19) | int top() {
    method getMin (line 23) | int getMin() {

FILE: cpp/151-160/Read N Characters Given Read4 II - Call multiple times.cpp
  class Solution (line 1) | class Solution {
    method read (line 12) | int read(char *buf, int n) {

FILE: cpp/151-160/Read N Characters Given Read4.cpp
  class Solution (line 6) | class Solution {
    method read (line 8) | int read(char *buf, int n) {

FILE: cpp/151-160/Reverse Words in a String.cpp
  class Solution (line 1) | class Solution {
    method reverseWords (line 3) | void reverseWords(string &s) {

FILE: cpp/161-170/Compare Version Numbers.cpp
  class Solution (line 1) | class Solution {
    method compareVersion (line 3) | int compareVersion(string version1, string version2) {

FILE: cpp/161-170/Excel Sheet Column Title.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string convertToTitle(int n) {

FILE: cpp/161-170/Find Peak Element.cpp
  class Solution (line 1) | class Solution {
    method findPeakElement (line 3) | int findPeakElement(const vector<int> &num)

FILE: cpp/161-170/Fraction to Recurring Decimal.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string fractionToDecimal(int64_t numerator, int64_t denominator) {

FILE: cpp/161-170/Majority Element.cpp
  class Solution (line 1) | class Solution {
    method majorityElement (line 3) | int majorityElement(vector<int> &num) {

FILE: cpp/161-170/Maximum Gap.cpp
  class Solution (line 1) | class Solution {
    method maximumGap (line 3) | int maximumGap(vector<int> &num) {

FILE: cpp/161-170/Missing Ranges.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | inline string get_range(int start, int end) {
    method findMissingRanges (line 9) | vector<string> findMissingRanges(vector<int>& nums, int lower, int upp...

FILE: cpp/161-170/One Edit Distance.cpp
  class Solution (line 1) | class Solution {
    method isOneEditDistance (line 4) | bool isOneEditDistance(string s, string t) {

FILE: cpp/161-170/Two Sum II - Input array is sorted.cpp
  class Solution (line 1) | class Solution {
    method twoSum (line 3) | vector<int> twoSum(vector<int>& numbers, int target) {

FILE: cpp/161-170/Two Sum III - Data structure design.cpp
  class TwoSum (line 1) | class TwoSum {
    method add (line 4) | void add(int number) {
    method find (line 7) | bool find(int value) {

FILE: cpp/171-180/Binary Search Tree Iterator.cpp
  class BSTIterator (line 1) | class BSTIterator {
    method BSTIterator (line 6) | BSTIterator(TreeNode *root) {
    method hasNext (line 17) | bool hasNext() {
    method next (line 22) | int next() {

FILE: cpp/171-180/Dungeon Game.cpp
  class Solution (line 1) | class Solution {
    method calculateMinimumHP (line 3) | int calculateMinimumHP(vector<vector<int> > &dungeon) {

FILE: cpp/171-180/Excel Sheet Column Number.cpp
  class Solution (line 1) | class Solution {
    method titleToNumber (line 3) | int titleToNumber(string s) {

FILE: cpp/171-180/Factorial Trailing Zeroes.cpp
  class Solution (line 1) | class Solution {
    method trailingZeroes (line 3) | int trailingZeroes(int n) {

FILE: cpp/171-180/Largest Number.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string largestNumber(vector<int>& nums) {

FILE: cpp/181-190/Best Time to Buy and Sell Stock IV.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | int help(vector<int> &prices)
    method maxProfit (line 13) | int maxProfit(int k, vector<int> &prices) {

FILE: cpp/181-190/Repeated DNA Sequences.cpp
  class Solution (line 1) | class Solution {
    method change (line 4) | inline int change(char ch) {
    method findRepeatedDnaSequences (line 12) | vector<string> findRepeatedDnaSequences(string s) {

FILE: cpp/181-190/Reverse Bits.cpp
  class Solution (line 1) | class Solution {
    method reverseBits (line 3) | uint32_t reverseBits(uint32_t n) {

FILE: cpp/181-190/Reverse Words in a String II.cpp
  class Solution (line 1) | class Solution {
    method reverseWords (line 3) | void reverseWords(string &s) {

FILE: cpp/181-190/Rotate Array.cpp
  class Solution (line 1) | class Solution {
    method rotate (line 3) | void rotate(vector<int>& nums, int k) {

FILE: cpp/191-200/Binary Tree Right Side View.cpp
  type TreeNode (line 8) | struct TreeNode {
    method TreeNode (line 12) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  class Solution (line 15) | class Solution {
    method rightSideView (line 17) | vector<int> rightSideView(TreeNode *root) {
  function main (line 43) | int main()

FILE: cpp/191-200/House Robber.cpp
  class Solution (line 1) | class Solution {
    method rob (line 3) | int rob(vector<int> &num) {

FILE: cpp/191-200/Number of 1 Bits.cpp
  class Solution (line 1) | class Solution {
    method hammingWeight (line 3) | int hammingWeight(uint32_t n) {

FILE: cpp/191-200/Number of Islands.cpp
  class Solution (line 1) | class Solution {
    method valid (line 3) | inline bool valid(int i, int j) {
    method mark (line 8) | void mark(vector<vector<char>> &grid, int i, int j) {
    method numIslands (line 21) | int numIslands(vector<vector<char>> &grid) {

FILE: cpp/191-200/Reverse Bits.cpp
  class Solution (line 7) | class Solution {
    method reverseBits (line 9) | uint32_t reverseBits(uint32_t n) {
  function main (line 21) | int main()

FILE: cpp/201-210/Bitwise AND of Numbers Range.cpp
  class Solution (line 1) | class Solution {
    method maxBit (line 3) | int maxBit(int num) {
    method rangeBitwiseAnd (line 14) | int rangeBitwiseAnd(int m, int n) {

FILE: cpp/201-210/Count Primes.cpp
  class Solution (line 9) | class Solution {
    method countPrimes (line 11) | int countPrimes(int n) {
  function main (line 38) | int main()

FILE: cpp/201-210/Course Schedule II.cpp
  type Node (line 1) | struct Node {
    method Node (line 4) | Node() : state(0) { }
  class Solution (line 7) | class Solution {
    method DFS_VISIT (line 11) | bool DFS_VISIT(int u, vector<int>& v) {
    method findOrder (line 28) | vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequi...

FILE: cpp/201-210/Course Schedule.cpp
  type Node (line 1) | struct Node {
    method Node (line 4) | Node() : state(0) { }
  class Solution (line 7) | class Solution {
    type Node (line 9) | struct Node
    method dfs_visit (line 11) | bool dfs_visit(int u) {
    method canFinish (line 27) | bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {

FILE: cpp/201-210/Happy Number.cpp
  class Solution (line 1) | class Solution {
    method SumSquare (line 3) | int SumSquare(int n)
    method isHappy (line 16) | bool isHappy(int n) {

FILE: cpp/201-210/Implement Trie (Prefix Tree).cpp
  type TrieNode (line 1) | struct TrieNode {
    method TrieNode (line 5) | TrieNode(): word(false) {
  class Trie (line 10) | class Trie {
    method Trie (line 13) | Trie() {
    method insert (line 18) | void insert(const string& s) {
    method search (line 31) | bool search(const string& key) const {
    method startsWith (line 45) | bool startsWith(const string& prefix) const {

FILE: cpp/201-210/Isomorphic Strings.cpp
  class Solution (line 1) | class Solution {
    method isIsomorphic (line 3) | bool isIsomorphic(string s, string t) {

FILE: cpp/201-210/Minimum Size Subarray Sum.cpp
  class Solution (line 1) | class Solution {
    method minSubArrayLen (line 3) | int minSubArrayLen(int s, vector<int>& nums) {

FILE: cpp/201-210/Remove Linked List Elements.cpp
  class Solution (line 1) | class Solution {
    method ListNode (line 3) | ListNode* removeElements(ListNode* head, int val) {

FILE: cpp/201-210/Reverse Linked List.cpp
  class Solution (line 9) | class Solution {
    method ListNode (line 11) | ListNode* reverseList(ListNode* head) {

FILE: cpp/211-220/Add and Search Word - Data structure design.cpp
  class TrieNode (line 1) | class TrieNode {
    method TrieNode (line 7) | TrieNode() {
  class Trie (line 14) | class Trie {
    method _search (line 16) | bool _search(string word, int offset, TrieNode *node) {
    method Trie (line 32) | Trie() {
    method insert (line 37) | void insert(string s) {
    method search (line 49) | bool search(string word) {
  class WordDictionary (line 57) | class WordDictionary {
    method addWord (line 64) | void addWord(string word) {
    method search (line 70) | bool search(string word) {

FILE: cpp/211-220/Combination Sum III.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | void help(vector<int>& now, int index, int num, int target, vector<vec...
    method combinationSum3 (line 22) | vector<vector<int>> combinationSum3(int k, int n) {

FILE: cpp/211-220/Contains Duplicate II.cpp
  class Solution (line 1) | class Solution {
    method containsNearbyDuplicate (line 3) | bool containsNearbyDuplicate(vector<int>& nums, int k)

FILE: cpp/211-220/Contains Duplicate III.cpp
  class Solution (line 1) | class Solution {
    method containsNearbyAlmostDuplicate (line 3) | bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {

FILE: cpp/211-220/Contains Duplicate.cpp
  class Solution (line 1) | class Solution {
    method containsDuplicate (line 3) | bool containsDuplicate(std::vector<int>& nums) {

FILE: cpp/211-220/House Robber II.cpp
  class Solution (line 1) | class Solution {
    method rob (line 3) | int rob(vector<int>& nums) {

FILE: cpp/211-220/Kth Largest Element in an Array.cpp
  class Solution (line 1) | class Solution {
    method kthSmallest (line 3) | int kthSmallest(vector<int>& arr, int l, int r, int k)
    method partition (line 19) | int partition(vector<int>& arr, int l, int r)
    method randomPartition (line 34) | int randomPartition(vector<int>& arr, int l, int r)
    method findKthLargest (line 43) | int findKthLargest(vector<int>& nums, int k) {

FILE: cpp/211-220/Shortest Palindrome.cpp
  class Solution (line 1) | class Solution {
    method string (line 4) | string preProcess(string s) {
    method string (line 16) | string shortestPalindrome(string s) {

FILE: cpp/211-220/The Skyline Problem.cpp
  class Solution (line 1) | class Solution {
    method getSkyline (line 3) | vector<pair<int, int>> getSkyline(vector<vector<int>>& buildings) {

FILE: cpp/211-220/Word Search II.cpp
  type TrieNode (line 3) | struct TrieNode{
    method TrieNode (line 8) | TrieNode() :isEndOfWord(false), father(NULL), ch(0)
  class Solution (line 15) | class Solution {
    method Solution (line 21) | Solution(){
    method insert (line 25) | void insert(string word){
    method string (line 41) | string getWord(TrieNode *curnode){
    method DFS (line 52) | void DFS(vector<vector<char>>& board, int r, int c, TrieNode *curnode){
    method findWords (line 82) | vector<string> findWords(vector<vector<char>>& board, vector<string>& ...

FILE: cpp/221-230/Basic Calculator II.cpp
  class Solution (line 1) | class Solution {
    method apply (line 3) | void apply(stack<int>& s, stack<char>& symbol) {
    method calculate (line 14) | int calculate(string s) {

FILE: cpp/221-230/Basic Calculator.cpp
  class Solution (line 1) | class Solution {
    method apply (line 3) | void apply(stack<int>& s, stack<char>& symbol) {
    method calculate (line 13) | int calculate(string s) {

FILE: cpp/221-230/Count Complete Tree Nodes.cpp
  class Solution (line 1) | class Solution {
    method countNodes (line 4) | int countNodes(TreeNode* root) {

FILE: cpp/221-230/Implement Stack using Queues.cpp
  class Stack (line 1) | class Stack {
    method push (line 9) | void push(int x) {
    method pop (line 18) | void pop() {
    method top (line 40) | int top() {
    method empty (line 45) | bool empty() {

FILE: cpp/221-230/Invert Binary Tree.cpp
  class Solution (line 1) | class Solution {
    method TreeNode (line 3) | TreeNode* invertTree(TreeNode* root) {

FILE: cpp/221-230/Kth Smallest Element in a BST.cpp
  class Solution (line 10) | class Solution {
    method kthSmallest (line 12) | int kthSmallest(TreeNode* root, int k) {

FILE: cpp/221-230/Majority Element II.cpp
  class Solution (line 1) | class Solution {
    method majorityElement (line 3) | vector<int> majorityElement(vector<int>& nums) {

FILE: cpp/221-230/Maximal Square.cpp
  class Solution (line 1) | class Solution {
    method maximalSquare (line 3) | int maximalSquare(vector<vector<char>>& matrix) {

FILE: cpp/221-230/Rectangle Area.cpp
  class Solution (line 1) | class Solution {
    method overlapLen (line 3) | int overlapLen(int a1, int a2, int b1, int b2) {
    method computeArea (line 12) | int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {

FILE: cpp/221-230/Summary Ranges.cpp
  class Solution (line 1) | class Solution {
    method summaryRanges (line 3) | vector<string> summaryRanges(vector<int>& nums) {

FILE: cpp/231-240/Delete Node in a Linked List.cpp
  class Solution (line 9) | class Solution {
    method deleteNode (line 11) | void deleteNode(ListNode* node) {

FILE: cpp/231-240/Implement Queue using Stacks.cpp
  class MyQueue (line 1) | class MyQueue {
    method MyQueue (line 6) | MyQueue() {
    method push (line 11) | void push(int x) {
    method pop (line 16) | int pop() {
    method peek (line 23) | int peek() {
    method transit (line 28) | void transit() {
    method empty (line 38) | bool empty() {

FILE: cpp/231-240/Lowest Common Ancestor of a Binary Search Tree.cpp
  class Solution (line 10) | class Solution {
    method TreeNode (line 12) | TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* ...

FILE: cpp/231-240/Lowest Common Ancestor of a Binary Tree.cpp
  class Solution (line 1) | class Solution {
    method TreeNode (line 3) | TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* ...

FILE: cpp/231-240/Number of Digit One.cpp
  class Solution (line 1) | class Solution {
    method countDigitOne (line 4) | int countDigitOne(int n) {

FILE: cpp/231-240/Palindrome Linked List.cpp
  class Solution (line 9) | class Solution {
    method isPalindrome (line 11) | bool isPalindrome(ListNode* head) {
    method ListNode (line 31) | ListNode* reverseList(ListNode* head) {

FILE: cpp/231-240/Power of Two.cpp
  class Solution (line 1) | class Solution {
    method isPowerOfTwo (line 3) | bool isPowerOfTwo(int n) {

FILE: cpp/231-240/Product of Array Except Self.cpp
  class Solution (line 1) | class Solution {
    method productExceptSelf (line 3) | vector<int> productExceptSelf(vector<int>& nums) {

FILE: cpp/231-240/Search a 2D Matrix II.cpp
  class Solution (line 1) | class Solution {
    method searchMatrix (line 3) | bool searchMatrix(vector<vector<int>>& matrix, int target) {

FILE: cpp/231-240/Sliding Window Maximum.cpp
  class Solution (line 1) | class Solution {
    method maxSlidingWindow (line 3) | vector<int> maxSlidingWindow(vector<int>& nums, int k) {

FILE: cpp/241-250/Count Univalue Subtrees.cpp
  class Solution (line 10) | class Solution {
    method help (line 14) | bool help(TreeNode* root)
    method countUnivalSubtrees (line 39) | int countUnivalSubtrees(TreeNode* root) {

FILE: cpp/241-250/Different Ways to Add Parentheses.cpp
  class Solution (line 1) | class Solution {
    method diffWaysToCompute (line 3) | vector<int> diffWaysToCompute(string input) {

FILE: cpp/241-250/Group Shifted Strings.cpp
  class Solution (line 1) | class Solution {
    method pattern_match (line 3) | bool pattern_match(const string &s1, const string &s2) {
    method groupStrings (line 16) | vector<vector<string>> groupStrings(vector<string>& strings) {

FILE: cpp/241-250/Shortest Word Distance II.cpp
  class WordDistance (line 1) | class WordDistance {
    method WordDistance (line 6) | WordDistance(vector<string>& words) {
    method shortest (line 12) | int shortest(string word1, string word2) {

FILE: cpp/241-250/Shortest Word Distance III.cpp
  class Solution (line 1) | class Solution {
    method shortestWordDistance (line 3) | int shortestWordDistance(vector<string>& words, string word1, string w...

FILE: cpp/241-250/Shortest Word Distance.cpp
  class Solution (line 1) | class Solution {
    method shortestDistance (line 3) | int shortestDistance(vector<string>& words, string word1, string word2) {

FILE: cpp/241-250/Strobogrammatic Number II.cpp
  class Solution (line 1) | class Solution {
    method findStrobogrammatic (line 3) | vector<string> findStrobogrammatic(int n) {
    method helper (line 6) | vector<string> helper(int m, int n){

FILE: cpp/241-250/Strobogrammatic Number III.cpp
  class Solution (line 1) | class Solution {
    method check (line 7) | bool check(const string& low, const string& high) {
    method help (line 13) | void help(string temp, int cur, int n, const string& low, const string...
    method strobogrammaticInRange (line 29) | int strobogrammaticInRange(string low, string high) {

FILE: cpp/241-250/Strobogrammatic Number.cpp
  class Solution (line 1) | class Solution {
    method isStrobogrammatic (line 4) | bool isStrobogrammatic(string num) {

FILE: cpp/241-250/Valid Anagram.cpp
  class Solution (line 1) | class Solution {
    method isAnagram (line 3) | bool isAnagram(string s, string t) {

FILE: cpp/251-260/3Sum Smaller.cpp
  class Solution (line 1) | class Solution {
    method threeSumSmaller (line 3) | int threeSumSmaller(vector<int>& nums, int target) {

FILE: cpp/251-260/Add Digits.cpp
  class Solution (line 1) | class Solution {
    method addDigits (line 3) | int addDigits(int num) {

FILE: cpp/251-260/Binary Tree Paths.cpp
  class Solution (line 10) | class Solution {
    method help (line 12) | void help(TreeNode* root, string path, vector<string>&paths)
    method binaryTreePaths (line 24) | vector<string> binaryTreePaths(TreeNode* root) {

FILE: cpp/251-260/Factor Combinations.cpp
  class Solution (line 1) | class Solution {
    method getFactors (line 5) | vector<vector<int>> getFactors(int n) {
    method getFHelp (line 10) | void getFHelp(int n, int bottom, vector<int> line) {

FILE: cpp/251-260/Flatten 2D Vector.cpp
  class Vector2D (line 1) | class Vector2D {
    method Vector2D (line 7) | Vector2D(vector<vector<int>>& vec2d) {
    method next (line 13) | int next() {
    method hasNext (line 18) | bool hasNext() {

FILE: cpp/251-260/Meeting Rooms II.cpp
  class Solution (line 10) | class Solution {
    method minMeetingRooms (line 12) | int minMeetingRooms(vector<Interval>& intervals) {

FILE: cpp/251-260/Meeting Rooms.cpp
  class Solution (line 10) | class Solution {
    method canAttendMeetings (line 12) | bool canAttendMeetings(vector<Interval>& intervals) {
    method overlap (line 22) | bool overlap(Interval& interval1, Interval& interval2) {

FILE: cpp/251-260/Paint House.cpp
  class Solution (line 1) | class Solution {
    method minCost (line 3) | int minCost(vector<vector<int>>& costs) {

FILE: cpp/251-260/Single Number III.cpp
  class Solution (line 1) | class Solution {
    method singleNumber (line 3) | vector<int> singleNumber(vector<int>& nums) {

FILE: cpp/251-260/Verify Preorder Sequence in Binary Search Tree.cpp
  class Solution (line 9) | class Solution {
    method verifyPreorder (line 11) | bool verifyPreorder(vector<int>& preorder) {

FILE: cpp/261-270/Alien Dictionary.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 2) | bool dfs(char ch,
    method string (line 24) | string alienOrder(vector<string>& words) {

FILE: cpp/261-270/Closest Binary Search Tree Value.cpp
  class Solution (line 10) | class Solution {
    method closestValue (line 12) | int closestValue(TreeNode* root, double target) {

FILE: cpp/261-270/Factor Combinations.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | void help(vector<vector<int>>& result, vector<int>& factors, vector<in...
    method getFactors (line 22) | vector<vector<int>> getFactors(int n) {

FILE: cpp/261-270/Graph Valid Tree.cpp
  class Solution (line 1) | class Solution {
    method findParent (line 3) | int findParent(const vector<int>& vec, int node) {
    method validTree (line 12) | bool validTree(int n, vector<vector<int>>& edges) {

FILE: cpp/261-270/Missing Number.cpp
  class Solution (line 1) | class Solution {
    method missingNumber (line 3) | int missingNumber(vector<int>& nums) {
    method missingNumber (line 13) | int missingNumber(vector<int>& nums) {
  class Solution (line 11) | class Solution {
    method missingNumber (line 3) | int missingNumber(vector<int>& nums) {
    method missingNumber (line 13) | int missingNumber(vector<int>& nums) {

FILE: cpp/261-270/Paint House II.cpp
  class Solution (line 1) | class Solution {
    method minCostII (line 3) | int minCostII(vector<vector<int>>& costs) {

FILE: cpp/261-270/Palindrome Permutation II.cpp
  class Solution (line 1) | class Solution {
    method help (line 7) | void help(vector<string>& result, string &temp, const string &s, int cur)
    method generatePalindromes (line 34) | vector<string> generatePalindromes(string s) {

FILE: cpp/261-270/Palindrome Permutation.cpp
  class Solution (line 1) | class Solution {
    method canPermutePalindrome (line 4) | bool canPermutePalindrome(string s) {

FILE: cpp/261-270/Ugly Number II.cpp
  class Solution (line 1) | class Solution {
    method nthUglyNumber (line 3) | int nthUglyNumber(int n) {

FILE: cpp/261-270/Ugly Number.cpp
  class Solution (line 1) | class Solution {
    method isUgly (line 3) | bool isUgly(int num) {

FILE: cpp/271-280/Closest Binary Search Tree Value II.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | void dfs(TreeNode* root, priority_queue<pair<double, int>>& pq, double...
    method closestKValues (line 25) | vector<int> closestKValues(TreeNode* root, double target, int k) {

FILE: cpp/271-280/Encode and Decode Strings.cpp
  class Codec (line 1) | class Codec {
    method string (line 5) | string encode(vector<string>& strs) {
    method decode (line 15) | vector<string> decode(string s) {

FILE: cpp/271-280/Find the Celebrity.cpp
  class Solution (line 4) | class Solution {
    method findCelebrity (line 6) | int findCelebrity(int n) {

FILE: cpp/271-280/First Bad Version.cpp
  class Solution (line 4) | class Solution {
    method firstBadVersion (line 6) | int firstBadVersion(int n) {

FILE: cpp/271-280/H-Index II.cpp
  class Solution (line 1) | class Solution {
    method hIndex (line 3) | int hIndex(vector<int>& citations) {

FILE: cpp/271-280/H-Index.cpp
  class Solution (line 1) | class Solution {
    method hIndex (line 3) | int hIndex(vector<int>& citations) {

FILE: cpp/271-280/Integer to English Words.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string hundredStr(int num){
    method string (line 12) | string numberToWords(int num) {

FILE: cpp/271-280/Paint Fence.cpp
  class Solution (line 1) | class Solution {
    method numWays (line 3) | int numWays(int n, int k) {

FILE: cpp/271-280/Perfect Squares.cpp
  class Solution (line 1) | class Solution {
    method numSquares (line 3) | int numSquares(int n) {

FILE: cpp/271-280/Wiggle Sort.cpp
  class Solution (line 1) | class Solution {
    method wiggleSort (line 3) | void wiggleSort(vector<int>& nums) {

FILE: cpp/281-290/Expression Add Operators.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | void help(vector<string>& result, string& num, int& target, int index,...
    method addOperators (line 20) | vector<string> addOperators(string num, int target) {

FILE: cpp/281-290/Find the Duplicate Number.cpp
  class Solution (line 1) | class Solution {
    method findDuplicate (line 3) | int findDuplicate(vector<int>& nums) {

FILE: cpp/281-290/Game of Life.cpp
  class Solution (line 1) | class Solution {
    method gameOfLife (line 3) | void gameOfLife(vector<vector<int>>& board) {

FILE: cpp/281-290/Inorder Successor in BST.cpp
  class Solution (line 10) | class Solution {
    method TreeNode (line 12) | TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {

FILE: cpp/281-290/Move Zeroes.cpp
  class Solution (line 1) | class Solution {
    method moveZeroes (line 3) | void moveZeroes(vector<int>& nums) {

FILE: cpp/281-290/Peeking Iterator.cpp
  class PeekingIterator (line 1) | class PeekingIterator : public Iterator {
    method PeekingIterator (line 7) | PeekingIterator(const vector<int>& num) : Iterator(num) {
    method peek (line 13) | int peek() {
    method next (line 23) | int next() {
    method hasNext (line 29) | bool hasNext() const {

FILE: cpp/281-290/Unique Word Abbreviation.cpp
  class ValidWordAbbr (line 1) | class ValidWordAbbr {
    method ValidWordAbbr (line 6) | ValidWordAbbr(vector<string> &dictionary) {
    method isUnique (line 14) | bool isUnique(string word) {

FILE: cpp/281-290/Walls and Gates.cpp
  type point (line 1) | struct point {
    method point (line 5) | point(int _i, int _j, int _v):i(_i), j(_j), v(_v) { }
  class mycomparison (line 8) | class mycomparison {
    method mycomparison (line 10) | mycomparison() { }
  class Solution (line 16) | class Solution {
    method wallsAndGates (line 21) | void wallsAndGates(vector<vector<int>>& rooms) {

FILE: cpp/281-290/Word Pattern.cpp
  class Solution (line 1) | class Solution {
    method wordPattern (line 3) | bool wordPattern(string pattern, string str) {

FILE: cpp/281-290/Zigzag Iterator.cpp
  class ZigzagIterator (line 1) | class ZigzagIterator {
    method ZigzagIterator (line 7) | ZigzagIterator(vector<int>& v1, vector<int>& v2) {
    method next (line 16) | int next() {
    method hasNext (line 25) | bool hasNext() {

FILE: cpp/291-300/Best Meeting Point.cpp
  class Solution (line 1) | class Solution {
    method minTotalDistance (line 4) | int minTotalDistance(vector<vector<int>>& grid) {

FILE: cpp/291-300/Binary Tree Longest Consecutive Sequence.cpp
  class Solution (line 10) | class Solution {
    method help (line 14) | void help(TreeNode* root, int h) {
    method longestConsecutive (line 32) | int longestConsecutive(TreeNode* root) {

FILE: cpp/291-300/Bulls and Cows.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string getHint(string secret, string guess) {

FILE: cpp/291-300/Find Median from Data Stream.cpp
  class MedianFinder (line 1) | class MedianFinder {
    method MedianFinder (line 6) | MedianFinder() {
    method addNum (line 10) | void addNum(int num) {
    method findMedian (line 22) | double findMedian() {

FILE: cpp/291-300/Flip Game II.cpp
  class Solution (line 1) | class Solution {
    method help (line 6) | bool help() {
    method canWin (line 20) | bool canWin(string s) {

FILE: cpp/291-300/Flip Game.cpp
  class Solution (line 1) | class Solution {
    method generatePossibleNextMoves (line 3) | vector<string> generatePossibleNextMoves(string s) {

FILE: cpp/291-300/Longest Increasing Subsequence.cpp
  class Solution (line 1) | class Solution {
    method lengthOfLIS (line 4) | int lengthOfLIS(vector<int>& nums) {

FILE: cpp/291-300/Nim Game.cpp
  class Solution (line 1) | class Solution {
    method canWinNim (line 4) | bool canWinNim(int n) {

FILE: cpp/291-300/Serialize and Deserialize Binary Tree.cpp
  class Codec (line 7) | class Codec {
    method readNext (line 9) | void readNext(stringstream& ss, int& val, bool &isnumber) {
    method TreeNode (line 21) | TreeNode* help(stringstream& ss) {
    method string (line 36) | string _serialize(TreeNode* root) {
    method string (line 44) | string serialize(TreeNode* root) {
    method TreeNode (line 50) | TreeNode* deserialize(string data) {
    method preorderDFS (line 64) | void preorderDFS(TreeNode* root, string& serialized_data) {
    method TreeNode (line 77) | inline TreeNode* reconstruct(const string& buffer, int& pos) {
    method string (line 100) | string serialize(TreeNode* root) {
    method TreeNode (line 107) | TreeNode* deserialize(string data) {
  class Codec (line 62) | class Codec {
    method readNext (line 9) | void readNext(stringstream& ss, int& val, bool &isnumber) {
    method TreeNode (line 21) | TreeNode* help(stringstream& ss) {
    method string (line 36) | string _serialize(TreeNode* root) {
    method string (line 44) | string serialize(TreeNode* root) {
    method TreeNode (line 50) | TreeNode* deserialize(string data) {
    method preorderDFS (line 64) | void preorderDFS(TreeNode* root, string& serialized_data) {
    method TreeNode (line 77) | inline TreeNode* reconstruct(const string& buffer, int& pos) {
    method string (line 100) | string serialize(TreeNode* root) {
    method TreeNode (line 107) | TreeNode* deserialize(string data) {

FILE: cpp/291-300/Word Pattern II.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | bool help(int pindex, int sindex, string &pattern, string &str, map<ch...
    method wordPatternMatch (line 37) | bool wordPatternMatch(string pattern, string str) {

FILE: cpp/301-310/Additive Number.cpp
  class Solution (line 1) | class Solution {
    method check (line 3) | bool check(string add1, string add2, int index, string &num) {
    method isAdditiveNumber (line 25) | bool isAdditiveNumber(string num) {

FILE: cpp/301-310/Best Time to Buy and Sell Stock with Cooldown.cpp
  class Solution (line 1) | class Solution {
    method maxProfit (line 3) | int maxProfit(vector<int>& prices) {

FILE: cpp/301-310/Minimum Height Trees.cpp
  class Solution (line 1) | class Solution {
    method findMinHeightTrees (line 4) | vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges) {

FILE: cpp/301-310/Number of Islands II.cpp
  class UF (line 1) | class UF {
    method UF (line 11) | UF(int N) {
    method find (line 22) | int find(int p) {
    method getCount (line 30) | int getCount() {
    method connected (line 34) | bool connected(int p, int q) {
    method Union (line 38) | void Union(int p, int q) {
  class Solution (line 54) | class Solution {
    method convert (line 56) | inline int convert(int m, int n, int col) {
    method numIslands2 (line 61) | vector<int> numIslands2(int m, int n, vector<pair<int, int>>& position...

FILE: cpp/301-310/Range Sum Query - Immutable.cpp
  class NumArray (line 1) | class NumArray {
    method NumArray (line 4) | NumArray(vector<int> &nums) {
    method sumRange (line 12) | int sumRange(int i, int j) {

FILE: cpp/301-310/Range Sum Query - Mutable.cpp
  class SegmentTreeNode (line 1) | class SegmentTreeNode {
    method SegmentTreeNode (line 6) | SegmentTreeNode(int start, int end, int sum) {
  class NumArray (line 14) | class NumArray {
    method SegmentTreeNode (line 18) | SegmentTreeNode * build(int start, int end, vector<int>& A) {
    method modify (line 35) | void modify(SegmentTreeNode *root, int i, int val) {
    method query (line 45) | int query(SegmentTreeNode *root, int i, int j) {
    method NumArray (line 59) | NumArray(vector<int> &nums) {
    method update (line 63) | void update(int i, int val) {
    method sumRange (line 67) | int sumRange(int i, int j) {

FILE: cpp/301-310/Range Sum Query 2D - Immutable.cpp
  class NumMatrix (line 1) | class NumMatrix {
    method NumMatrix (line 4) | NumMatrix(vector<vector<int>> &matrix) {
    method sumRegion (line 16) | int sumRegion(int row1, int col1, int row2, int col2) {

FILE: cpp/301-310/Range Sum Query 2D - Mutable.cpp
  class NumMatrix (line 1) | class NumMatrix {
    method NumMatrix (line 7) | NumMatrix(vector<vector<int>> &matrix) {
    method update (line 21) | void update(int row, int col, int val) {
    method sumRegion (line 29) | int sumRegion(int row1, int col1, int row2, int col2) {

FILE: cpp/301-310/Remove Invalid Parentheses.cpp
  class Solution (line 2) | class Solution {
    method GetErrors (line 4) | int GetErrors(const string &s) {
    method removeInvalidParentheses (line 23) | vector<string> removeInvalidParentheses(string s) {
    method GetErrors (line 73) | int GetErrors(const string &s) {
    method dfs (line 93) | void dfs(const string& s, int ind, int validLen, int leftCnt, int righ...
    method removeInvalidParentheses (line 124) | vector<string> removeInvalidParentheses(string s) {
  class Solution (line 71) | class Solution {
    method GetErrors (line 4) | int GetErrors(const string &s) {
    method removeInvalidParentheses (line 23) | vector<string> removeInvalidParentheses(string s) {
    method GetErrors (line 73) | int GetErrors(const string &s) {
    method dfs (line 93) | void dfs(const string& s, int ind, int validLen, int leftCnt, int righ...
    method removeInvalidParentheses (line 124) | vector<string> removeInvalidParentheses(string s) {

FILE: cpp/301-310/Smallest Rectangle Enclosing Black Pixels.cpp
  class Solution (line 1) | class Solution {
    method bfs (line 12) | void bfs(vector<vector<char>>& image, int x, int y) {
    method minArea (line 30) | int minArea(vector<vector<char>>& image, int x, int y) {

FILE: cpp/311-320/Binary Tree Vertical Order Traversal.cpp
  class Solution (line 10) | class Solution {
    method verticalOrder (line 13) | vector<vector<int>> verticalOrder(TreeNode* root) {

FILE: cpp/311-320/Bulb Switcher.cpp
  class Solution (line 1) | class Solution {
    method bulbSwitch (line 3) | int bulbSwitch(int n) {

FILE: cpp/311-320/Burst Balloons.cpp
  class Solution (line 1) | class Solution {
    method getValue (line 3) | int getValue(vector<int>& nums, int i) {
    method maxCoins (line 9) | int maxCoins(vector<int>& nums) {

FILE: cpp/311-320/Count of Smaller Numbers After Self.cpp
  type tree (line 1) | struct tree{
    method tree (line 6) | tree(int v):val(v),left(nullptr),right(nullptr),count(1){}
  class Solution (line 9) | class Solution {
    method countSmaller (line 11) | vector<int> countSmaller(vector<int>& nums) {

FILE: cpp/311-320/Generalized Abbreviation.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | void help(int i, string &word, vector<string>& result, int previous, s...
    method generateAbbreviations (line 17) | vector<string> generateAbbreviations(string word) {

FILE: cpp/311-320/Maximum Product of Word Lengths.cpp
  class Solution (line 1) | class Solution {
    method maxProduct (line 3) | int maxProduct(vector<string>& words) {

FILE: cpp/311-320/Remove Duplicate Letters.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string removeDuplicateLetters(string s) {

FILE: cpp/311-320/Shortest Distance from All Buildings.cpp
  type point (line 1) | struct point {
    method point (line 5) | point(int _i, int _j, int _v){i = _i; j = _j; v = _v;}
  class Solution (line 8) | class Solution {
    method BFS (line 10) | void BFS(int i, int j, vector<vector<int>>& grid, vector<vector<int>>&...
    method shortestDistance (line 50) | int shortestDistance(vector<vector<int>>& grid) {

FILE: cpp/311-320/Sparse Matrix Multiplication.cpp
  class Solution (line 1) | class Solution {
    method multiply (line 3) | vector<vector<int>> multiply(vector<vector<int>>& A, vector<vector<int...

FILE: cpp/311-320/Super Ugly Number.cpp
  class Solution (line 1) | class Solution {
    method nthSuperUglyNumber (line 3) | int nthSuperUglyNumber(int n, vector<int>& primes) {

FILE: cpp/321-330/Coin Change.cpp
  class Solution (line 1) | class Solution {
    method coinChange (line 4) | int coinChange(vector<int>& coins, int amount) {

FILE: cpp/321-330/Count of Range Sum.cpp
  type SegmentTreeNode (line 2) | struct SegmentTreeNode {
    method SegmentTreeNode (line 6) | SegmentTreeNode(LL L, LL R) :L(L), R(R), cnt(0), left(NULL), right(NUL...
  class SegmentTree (line 9) | class SegmentTree {
    method SegmentTreeNode (line 11) | SegmentTreeNode * buildTree(vector<LL> &nums, int L, int R) {
    method update (line 21) | void update(SegmentTreeNode * root, LL val) {
    method sum (line 29) | int sum(SegmentTreeNode * root, LL L, LL R) {
    method SegmentTree (line 36) | SegmentTree(vector<LL> &nums, int L, int R) { root = buildTree(nums, L...
    method sum (line 38) | int sum(LL L, LL R) {
    method update (line 42) | void update(LL val) {
  class Solution (line 47) | class Solution {
    method countRangeSum (line 49) | int countRangeSum(vector<int>& nums, int lower, int upper) {

FILE: cpp/321-330/Create Maximum Number.cpp
  class Solution (line 1) | class Solution {
    method merge (line 3) | vector<int> merge(vector<int> nums1, vector<int> nums2) {
    method getMax (line 25) | vector<int> getMax(const vector<int>& nums, int t) {
    method greater (line 41) | bool greater(const vector<int> &nums1, const vector<int> &nums2, int i...
    method maxNumber (line 52) | vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {

FILE: cpp/321-330/Longest Increasing Path in a Matrix.cpp
  class Solution (line 1) | class Solution {
    method dfsvisit (line 3) | int dfsvisit(int i, int j, vector<vector<bool>> &visited, vector<vecto...
    method longestIncreasingPath (line 21) | int longestIncreasingPath(vector<vector<int>>& matrix) {

FILE: cpp/321-330/Maximum Size Subarray Sum Equals k.cpp
  class Solution (line 7) | class Solution {
    method maxSubArrayLen (line 9) | int maxSubArrayLen(vector<int>& nums, int k) {

FILE: cpp/321-330/Number of Connected Components in an Undirected Graph.cpp
  class Solution (line 1) | class Solution {
    method findroot (line 3) | int findroot(int c, vector<int> &u)
    method countComponents (line 10) | int countComponents(int n, vector<pair<int, int>>& edges) {

FILE: cpp/321-330/Odd Even Linked List.cpp
  class Solution (line 9) | class Solution {
    method ListNode (line 11) | ListNode* oddEvenList(ListNode* head) {

FILE: cpp/321-330/Patching Array.cpp
  class Solution (line 1) | class Solution {
    method minPatches (line 3) | int minPatches(vector<int>& nums, int n) {

FILE: cpp/321-330/Power of Three.cpp
  class Solution (line 1) | class Solution {
    method isPowerOfThree (line 3) | bool isPowerOfThree(int n) {

FILE: cpp/321-330/Wiggle Sort II.cpp
  class Solution (line 1) | class Solution {
    method wiggleSort (line 3) | void wiggleSort(vector<int>& nums) {

FILE: cpp/331-340/Counting Bits.cpp
  class Solution (line 6) | class Solution {
    method countBits (line 8) | vector<int> countBits(int num) {

FILE: cpp/331-340/House Robber III.cpp
  class Solution (line 10) | class Solution {
    method help (line 12) | void help(TreeNode* root, int &a, int &b) {
    method rob (line 31) | int rob(TreeNode* root) {

FILE: cpp/331-340/Increasing Triplet Subsequence.cpp
  class Solution (line 1) | class Solution {
    method increasingTriplet (line 3) | bool increasingTriplet(vector<int>& nums) {

FILE: cpp/331-340/Largest BST Subtree.cpp
  class Solution (line 1) | class Solution {
    method isBST (line 3) | bool isBST(TreeNode* node, int& res, int& mini, int& maxi) {
    method largestBSTSubtree (line 30) | int largestBSTSubtree(TreeNode* root) {

FILE: cpp/331-340/Longest Substring with At Most K Distinct Characters.cpp
  class Solution (line 1) | class Solution {
    method lengthOfLongestSubstringKDistinct (line 3) | int lengthOfLongestSubstringKDistinct(string s, int k) {

FILE: cpp/331-340/Nested List Weight Sum.cpp
  class Solution (line 18) | class Solution {
    method DFS (line 20) | int DFS(vector<NestedInteger>& nestedList, int depth){
    method depthSum (line 32) | int depthSum(vector<NestedInteger>& nestedList) {

FILE: cpp/331-340/Palindrome Pairs.cpp
  class Solution (line 1) | class Solution {
    method isPalindrome (line 3) | bool isPalindrome(const string& s) {
    method palindromePairs (line 17) | vector<vector<int>> palindromePairs(vector<string>& words) {
    method palindromePairs (line 142) | vector<vector<int>> palindromePairs(vector<string>& words) {
  class Trie (line 64) | class Trie {
    method isPalindrome (line 65) | bool isPalindrome(const string& s) {
    type TrieNode (line 79) | struct TrieNode {
      method TrieNode (line 84) | TrieNode(): isWord(false) {
    method Trie (line 91) | Trie() {
    method insert (line 95) | void insert(string& s, int wordIndex) {
    method findPalindrome (line 113) | void findPalindrome(const vector<string>& words, int wordIndex, vector...
  class Solution (line 140) | class Solution {
    method isPalindrome (line 3) | bool isPalindrome(const string& s) {
    method palindromePairs (line 17) | vector<vector<int>> palindromePairs(vector<string>& words) {
    method palindromePairs (line 142) | vector<vector<int>> palindromePairs(vector<string>& words) {

FILE: cpp/331-340/Reconstruct Itinerary.cpp
  class Solution (line 1) | class Solution {
    method findItinerary (line 3) | vector<string> findItinerary(vector<pair<string, string>> tickets) {
    method dfs (line 15) | void dfs(string u, vector<string> &ans, unordered_map<string, multiset...

FILE: cpp/331-340/Self Crossing.cpp
  class Solution (line 1) | class Solution {
    method isSelfCrossing (line 3) | bool isSelfCrossing(vector<int>& x) {

FILE: cpp/331-340/Verify Preorder Serialization of a Binary Tree.cpp
  class Solution (line 1) | class Solution {
    method isValidSerialization (line 4) | bool isValidSerialization(string preorder) {

FILE: cpp/341-350/Design Tic-Tac-Toe.cpp
  class TicTacToe (line 1) | class TicTacToe {
    method TicTacToe (line 11) | TicTacToe(int n):total(n), rowJudge(n), colJudge(n),diag(0),anti(0){}
    method move (line 13) | int move(int row, int col, int player) {

FILE: cpp/341-350/Flatten Nested List Iterator.cpp
  class NestedIterator (line 18) | class NestedIterator {
    method NestedIterator (line 25) | NestedIterator(vector<NestedInteger> &nestedList) {
    method next (line 31) | int next() {
    method hasNext (line 37) | bool hasNext() {
    method NestedIterator (line 90) | NestedIterator(vector<NestedInteger> &nestedList) {
    method next (line 96) | int next() {
    method hasNext (line 102) | bool hasNext() {
  class NestedIterator (line 85) | class NestedIterator {
    method NestedIterator (line 25) | NestedIterator(vector<NestedInteger> &nestedList) {
    method next (line 31) | int next() {
    method hasNext (line 37) | bool hasNext() {
    method NestedIterator (line 90) | NestedIterator(vector<NestedInteger> &nestedList) {
    method next (line 96) | int next() {
    method hasNext (line 102) | bool hasNext() {

FILE: cpp/341-350/Integer Break.cpp
  class Solution (line 1) | class Solution {
    method integerBreak (line 3) | long long integerBreak(long long n) {

FILE: cpp/341-350/Intersection of Two Arrays II.cpp
  class Solution (line 1) | class Solution {
    method intersect (line 3) | vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {

FILE: cpp/341-350/Intersection of Two Arrays.cpp
  class Solution (line 1) | class Solution {
    method intersection (line 3) | vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {

FILE: cpp/341-350/Moving Average from Data Stream.cpp
  class MovingAverage (line 1) | class MovingAverage {
    method MovingAverage (line 9) | MovingAverage(int size) {
    method next (line 14) | double next(int val) {

FILE: cpp/341-350/Power of Four.cpp
  class Solution (line 1) | class Solution {
    method isPowerOfFour (line 3) | bool isPowerOfFour(int num) {

FILE: cpp/341-350/Reverse String.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string reverseString(string s) {

FILE: cpp/341-350/Reverse Vowels of a String.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string reverseVowels(string s) {

FILE: cpp/341-350/Top K Frequent Elements.cpp
  class Solution (line 1) | class Solution {
    type greater_than (line 3) | struct greater_than
    method topKFrequent (line 12) | vector<int> topKFrequent(vector<int>& nums, int k) {
    type greater_than (line 29) | struct greater_than{
    method topKFrequent (line 36) | vector<int> topKFrequent(vector<int>& nums, int k) {
  class Solution (line 28) | class Solution {
    type greater_than (line 3) | struct greater_than
    method topKFrequent (line 12) | vector<int> topKFrequent(vector<int>& nums, int k) {
    type greater_than (line 29) | struct greater_than{
    method topKFrequent (line 36) | vector<int> topKFrequent(vector<int>& nums, int k) {

FILE: cpp/351-360/Android Unlock Patterns.cpp
  class Solution (line 1) | class Solution {
    method DFS (line 3) | int DFS(vector<bool> &vis, vector<vector<int>> &skip, int cur, int rem...
    method numberOfPatterns (line 17) | int numberOfPatterns(int m, int n) {

FILE: cpp/351-360/Count Numbers with Unique Digits.cpp
  class Solution (line 1) | class Solution {
    method countNumbersWithUniqueDigits (line 3) | int countNumbersWithUniqueDigits(int n) {

FILE: cpp/351-360/Data Stream as Disjoint Intervals.cpp
  class SummaryRanges (line 10) | class SummaryRanges {
    method addNum (line 15) | void addNum(int val) {
    method getIntervals (line 29) | vector<Interval> getIntervals() {

FILE: cpp/351-360/Design Snake Game.cpp
  class SnakeGame (line 1) | class SnakeGame {
    method SnakeGame (line 21) | SnakeGame(int width, int height, vector<pair<int, int>> food) {
    method move (line 36) | int move(string direction) {

FILE: cpp/351-360/Design Twitter.cpp
  class Twitter (line 1) | class Twitter {
    method Twitter (line 10) | Twitter() {
    method postTweet (line 15) | void postTweet(int userId, int tweetId) {
    method getNewsFeed (line 25) | vector<int> getNewsFeed(int userId) {
    method follow (line 65) | void follow(int followerId, int followeeId) {
    method unfollow (line 81) | void unfollow(int followerId, int followeeId) {

FILE: cpp/351-360/Line Reflection.cpp
  class Solution (line 1) | class Solution {
    method isReflected (line 6) | bool isReflected(vector<pair<int, int>>& points) {

FILE: cpp/351-360/Logger Rate Limiter.cpp
  class Logger (line 1) | class Logger {
    method Logger (line 7) | Logger() {
    method shouldPrintMessage (line 12) | bool shouldPrintMessage(int timestamp, string message) {

FILE: cpp/351-360/Rearrange String k Distance Apart.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string rearrangeString(string str, int k) {

FILE: cpp/351-360/Russian Doll Envelopes.cpp
  class Solution (line 1) | class Solution {
    method maxEnvelopes (line 3) | int maxEnvelopes(vector<pair<int, int>>& envelopes) {

FILE: cpp/351-360/Sort Transformed Array.cpp
  class Solution (line 1) | class Solution {
    method transform (line 3) | int transform(int num, int a, int b, int c) {
    method sortTransformedArray (line 8) | vector<int> sortTransformedArray(vector<int>& nums, int a, int b, int ...

FILE: cpp/361-370/Bomb Enemy.cpp
  class Solution (line 1) | class Solution {
    method maxKilledEnemies (line 3) | int maxKilledEnemies(vector<vector<char>>& grid) {

FILE: cpp/361-370/Design Hit Counter.cpp
  class HitCounter (line 1) | class HitCounter {
    method HitCounter (line 8) | HitCounter() {
    method hit (line 14) | void hit(int timestamp) {
    method getHits (line 21) | int getHits(int timestamp) {

FILE: cpp/361-370/Find Leaves of Binary Tree.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | int dfs(TreeNode* root, vector<vector<int>> &myvec) {
    method findLeaves (line 25) | vector<vector<int>> findLeaves(TreeNode* root) {

FILE: cpp/361-370/Largest Divisible Subset.cpp
  class Solution (line 1) | class Solution {
    method largestDivisibleSubset (line 3) | vector<int> largestDivisibleSubset(vector<int>& nums) {

FILE: cpp/361-370/Max Sum of Rectangle No Larger Than K.cpp
  class Solution (line 1) | class Solution {
    method maxSumSubmatrix (line 4) | int maxSumSubmatrix(vector<vector<int>>& matrix, int k) {

FILE: cpp/361-370/Nested List Weight Sum II.cpp
  class Solution (line 18) | class Solution {
    method depthSumInverse (line 20) | int depthSumInverse(vector<NestedInteger>& nestedList) {

FILE: cpp/361-370/Plus One Linked List.cpp
  class Solution (line 9) | class Solution {
    method ListNode (line 11) | ListNode* reverseList(ListNode* head) {
    method ListNode (line 23) | ListNode* plusOne(ListNode* head) {

FILE: cpp/361-370/Range Addition.cpp
  class Solution (line 1) | class Solution {
    method getModifiedArray (line 3) | vector<int> getModifiedArray(int length, vector<vector<int>>& updates) {

FILE: cpp/361-370/Valid Perfect Square.cpp
  class Solution (line 1) | class Solution {
    method isPerfectSquare (line 3) | bool isPerfectSquare(int num) {

FILE: cpp/361-370/Water and Jug Problem.cpp
  class Solution (line 1) | class Solution {
    method canMeasureWater (line 3) | bool canMeasureWater(int x, int y, int z) {
    method gcd (line 11) | int gcd(int a, int b){

FILE: cpp/371-380/Combination Sum IV.cpp
  class Solution (line 1) | class Solution {
    method combinationSum4 (line 3) | int combinationSum4(vector<int>& nums, int target) {

FILE: cpp/371-380/Design Phone Directory.cpp
  class PhoneDirectory (line 1) | class PhoneDirectory {
    method PhoneDirectory (line 7) | PhoneDirectory(int maxNumbers) {
    method get (line 17) | int get() {
    method check (line 28) | bool check(int number) {
    method release (line 33) | void release(int number) {

FILE: cpp/371-380/Find K Pairs with Smallest Sums.cpp
  class Solution (line 1) | class Solution {
    method kSmallestPairs (line 6) | vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nu...

FILE: cpp/371-380/Guess Number Higher or Lower II.cpp
  class Solution (line 1) | class Solution {
    method getMoneyAmount (line 3) | int getMoneyAmount(int n) {

FILE: cpp/371-380/Guess Number Higher or Lower.cpp
  class Solution (line 6) | class Solution {
    method guessNumber (line 8) | int guessNumber(int n) {

FILE: cpp/371-380/Insert Delete GetRandom O(1).cpp
  class RandomizedSet (line 1) | class RandomizedSet {
    method RandomizedSet (line 6) | RandomizedSet() {
    method insert (line 11) | bool insert(int val) {
    method remove (line 21) | bool remove(int val) {
    method getRandom (line 34) | int getRandom() {

FILE: cpp/371-380/Kth Smallest Element in a Sorted Matrix.cpp
  class Solution (line 1) | class Solution {
    method kthSmallest (line 3) | int kthSmallest(vector<vector<int>>& matrix, int k) {
    method search_lower_than_mid (line 14) | int search_lower_than_mid(const vector<vector<int>>& matrix, int x) {

FILE: cpp/371-380/Sum of Two Integers.cpp
  class Solution (line 1) | class Solution {
    method getSum (line 4) | int getSum(int a, int b) {

FILE: cpp/371-380/Super Pow.cpp
  class Solution (line 1) | class Solution {
    method help (line 3) | int help(int a, int b) {
    method superPow (line 13) | int superPow(int a, vector<int>& b) {

FILE: cpp/371-380/Wiggle Subsequence.cpp
  class Solution (line 1) | class Solution {
    method wiggleMaxLength (line 3) | int wiggleMaxLength(vector<int>& nums) {

FILE: cpp/381-390/Elimination Game.cpp
  class Solution (line 6) | class Solution {
    method lastRemaining (line 13) | int lastRemaining(int n) {

FILE: cpp/381-390/Find the Difference.cpp
  class Solution (line 1) | class Solution {
    method findTheDifference (line 3) | char findTheDifference(string s, string t) {

FILE: cpp/381-390/First Unique Character in a String.cpp
  class Solution (line 1) | class Solution {
    method firstUniqChar (line 3) | int firstUniqChar(string s) {

FILE: cpp/381-390/Insert Delete GetRandom O(1) - Duplicates allowed.cpp
  class RandomizedCollection (line 1) | class RandomizedCollection {
    method RandomizedCollection (line 6) | RandomizedCollection() {
    method insert (line 11) | bool insert(int val) {
    method remove (line 22) | bool remove(int val) {
    method getRandom (line 36) | int getRandom() {

FILE: cpp/381-390/Lexicographical Numbers.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | void dfs(int curr, int n, vector<int>& result, int& index) {
    method lexicalOrder (line 16) | vector<int> lexicalOrder(int n) {

FILE: cpp/381-390/Linked List Random Node.cpp
  class Solution (line 1) | class Solution {
    method Solution (line 5) | Solution(ListNode* head) {
    method getRandom (line 13) | int getRandom() {

FILE: cpp/381-390/Longest Absolute File Path.cpp
  class Solution (line 1) | class Solution {
    method lengthLongestPath (line 3) | int lengthLongestPath(string input) {

FILE: cpp/381-390/Mini Parser.cpp
  class Solution (line 30) | class Solution {
    method NestedInteger (line 32) | NestedInteger deserialize(string s) {

FILE: cpp/381-390/Ransom Note.cpp
  class Solution (line 1) | class Solution {
    method canConstruct (line 3) | bool canConstruct(string ransomNote, string magazine) {

FILE: cpp/381-390/Shuffle an Array.cpp
  class Solution (line 1) | class Solution {
    method Solution (line 4) | Solution(vector<int> nums) {
    method reset (line 9) | vector<int> reset() {
    method shuffle (line 14) | vector<int> shuffle() {

FILE: cpp/391-400/Decode String.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string solve(const string& s, int& i) {
    method string (line 25) | string decodeString(string s) {

FILE: cpp/391-400/Evaluate Division.cpp
  class Solution (line 1) | class Solution {
    method calcEquation (line 3) | vector<double> calcEquation(vector<pair<string, string>> equations, ve...
    method findRoot (line 52) | int findRoot(vector<int>& par, vector<double>& parEq, int v, double& t) {

FILE: cpp/391-400/Integer Replacement.cpp
  class Solution (line 1) | class Solution
    method integerReplacement (line 4) | int integerReplacement(int n) {

FILE: cpp/391-400/Is Subsequence.cpp
  class Solution (line 1) | class Solution {
    method isSubsequence (line 3) | bool isSubsequence(string s, string t) {

FILE: cpp/391-400/Longest Substring with At Least K Repeating Characters.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | int dfs(const string& s, int k, int start, int end) {
    method longestSubstring (line 24) | int longestSubstring(string s, int k) {

FILE: cpp/391-400/Nth Digit.cpp
  class Solution (line 1) | class Solution {
    method process (line 3) | int process(long long num, long long n) {
    method findNthDigit (line 12) | int findNthDigit(int n) {

FILE: cpp/391-400/Perfect Rectangle.cpp
  class Solution (line 1) | class Solution {
    method isRectangleCover (line 3) | bool isRectangleCover(vector<vector<int>>& rectangles) {

FILE: cpp/391-400/Random Pick Index.cpp
  class Solution (line 1) | class Solution {
    method Solution (line 4) | Solution(vector<int> nums)  {
    method pick (line 8) | int pick(int target) {

FILE: cpp/391-400/Rotate Function.cpp
  class Solution (line 1) | class Solution {
    method maxRotateFunction (line 4) | int maxRotateFunction(vector<int>& A) {

FILE: cpp/391-400/UTF-8 Validation.cpp
  class Solution (line 1) | class Solution {
    method validUtf8 (line 3) | bool validUtf8(vector<int>& data) {

FILE: cpp/401-410/Binary Watch.cpp
  class Solution (line 1) | class Solution {
    method readBinaryWatch (line 3) | vector<string> readBinaryWatch(int num) {

FILE: cpp/401-410/Convert a Number to Hexadecimal.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string toHex(int num) {

FILE: cpp/401-410/Frog Jump.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | bool dfs(const vector<int>& stones, int stone_index, int speed, unorde...
    method canCross (line 23) | bool canCross(vector<int>& stones) {

FILE: cpp/401-410/Longest Palindrome.cpp
  class Solution (line 1) | class Solution {
    method longestPalindrome (line 3) | int longestPalindrome(string s) {

FILE: cpp/401-410/Queue Reconstruction by Height.cpp
  class Solution (line 1) | class Solution {
    method reconstructQueue (line 3) | vector<pair<int, int>> reconstructQueue(vector<pair<int, int>>& people) {

FILE: cpp/401-410/Remove K Digits.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string removeKdigits(string num, int k) {

FILE: cpp/401-410/Split Array Largest Sum.cpp
  class Solution (line 1) | class Solution {
    method canSplit (line 5) | bool canSplit(vector<int>& nums, int m, ll sum) {
    method splitArray (line 18) | int splitArray(vector<int>& nums, int m) {

FILE: cpp/401-410/Sum of Left Leaves.cpp
  class Solution (line 10) | class Solution {
    method sumOfLeftLeaves (line 12) | int sumOfLeftLeaves(TreeNode* root) {

FILE: cpp/401-410/Trapping Rain Water II.cpp
  class Solution (line 1) | class Solution {
    method trapRainWater (line 3) | int trapRainWater(vector<vector<int>>& heightMap) {

FILE: cpp/401-410/Valid Word Abbreviation.cpp
  class Solution (line 1) | class Solution {
    method validWordAbbreviation (line 3) | bool validWordAbbreviation(string word, string abbr) {

FILE: cpp/411-420/Add Strings.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string addStrings(string num1, string num2) {

FILE: cpp/411-420/Arithmetic Slices.cpp
  class Solution (line 1) | class Solution {
    method numberOfArithmeticSlices (line 3) | int numberOfArithmeticSlices(vector<int>& A) {

FILE: cpp/411-420/Battleships in a Board.cpp
  class Solution (line 1) | class Solution {
    method countBattleships (line 3) | int countBattleships(vector<vector<char>>& board) {

FILE: cpp/411-420/Fizz Buzz.cpp
  class Solution (line 1) | class Solution {
    method fizzBuzz (line 3) | vector<string> fizzBuzz(int n) {

FILE: cpp/411-420/Minimum Unique Word Abbreviation.cpp
  class Solution (line 1) | class Solution {
    type TrieNode (line 2) | struct TrieNode {
      method TrieNode (line 4) | TrieNode () {
    method string (line 9) | string minAbbreviation(string target, vector<string>& dictionary) {
    method generate_abb (line 33) | void generate_abb(vector<string>& abbrs, string& s, string cur, int po...
    method TrieNode (line 58) | TrieNode* build(vector<string>& dic) {
      method TrieNode (line 4) | TrieNode () {
    method valid (line 71) | bool valid(TrieNode* root, const string& s, int i) {
    method string (line 87) | string encode(const string& s) {

FILE: cpp/411-420/Pacific Atlantic Water Flow.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 5) | void dfs(vector<vector<int>>& matrix, int x, int y, int pre, int preval){
    method pacificAtlantic (line 17) | vector<pair<int, int>> pacificAtlantic(vector<vector<int>>& matrix) {

FILE: cpp/411-420/Partition Equal Subset Sum.cpp
  class Solution (line 1) | class Solution {
    method canPartition (line 4) | bool canPartition(vector<int>& nums) {

FILE: cpp/411-420/Sentence Screen Fitting.cpp
  class Solution (line 1) | class Solution {
    method wordsTyping (line 3) | int wordsTyping(vector<string>& sentence, int rows, int cols) {

FILE: cpp/411-420/Third Maximum Number.cpp
  class Solution (line 1) | class Solution {
    method thirdMax (line 3) | int thirdMax(vector<int>& nums) {

FILE: cpp/421-430/Convert Binary Search Tree to Sorted Doubly Linked List.cpp
  class Solution (line 1) | class Solution {
    method inorder (line 3) | void inorder(Node* cur, Node*& prev, Node*& head) {
    method Node (line 27) | Node* treeToDoublyList(Node* root) {

FILE: cpp/421-430/Maximum XOR of Two Numbers in an Array.cpp
  class Solution (line 1) | class Solution {
    class TreeNode (line 3) | class TreeNode {
      method TreeNode (line 6) | TreeNode () {next[0] = NULL; next[1] = NULL;}
    method TreeNode (line 8) | TreeNode* buildTree(vector<int>& nums) {
      method TreeNode (line 6) | TreeNode () {next[0] = NULL; next[1] = NULL;}
    method helper (line 24) | int helper(TreeNode* cur, int num) {
    method findMaximumXOR (line 41) | int findMaximumXOR(vector<int>& nums) {

FILE: cpp/421-430/Serialize and Deserialize N-ary Tree.cpp
  class Codec (line 21) | class Codec {
    method string (line 26) | string serialize(Node* root) {
    method encode_dfs (line 32) | void encode_dfs(Node* root, string& data){
    method Node (line 41) | Node* deserialize(string data) {
    method Node (line 46) | Node* decode(stringstream& ss) {

FILE: cpp/421-430/Valid Word Square.cpp
  class Solution (line 1) | class Solution {
    method validWordSquare (line 3) | bool validWordSquare(vector<string>& words) {

FILE: cpp/421-430/Word Squares.cpp
  class Solution (line 1) | class Solution {
    type TrieNode (line 3) | struct TrieNode {
      method TrieNode (line 6) | TrieNode(): children(26, nullptr) { }
    method TrieNode (line 9) | TrieNode* buildTrie(const vector<string>& words) {
      method TrieNode (line 6) | TrieNode(): children(26, nullptr) { }
    method backtrack (line 25) | void backtrack(const vector<string>& words, int level, TrieNode* root) {
    method wordSquares (line 42) | vector<vector<string>> wordSquares(vector<string>& words) {

FILE: cpp/431-440/All O`one Data Structure.cpp
  class AllOne (line 1) | class AllOne {
    method inc (line 4) | void inc(string key) {
    method dec (line 23) | void dec(string key) {
    method string (line 46) | string getMaxKey() {
    method string (line 50) | string getMinKey() {
    type Bucket (line 55) | struct Bucket { int value; unordered_set<string> keys; }

FILE: cpp/431-440/Find All Anagrams in a String.cpp
  class Solution (line 1) | class Solution {
    method findAnagrams (line 3) | vector<int> findAnagrams(string s, string p) {

FILE: cpp/431-440/Find Right Interval.cpp
  class Solution (line 10) | class Solution {
    method findRightInterval (line 12) | vector<int> findRightInterval(vector<Interval>& intervals) {

FILE: cpp/431-440/K-th Smallest in Lexicographical Order.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | int dfs(string prefix, int n) {
    method findKthNumber (line 32) | int findKthNumber(int n, int k) {

FILE: cpp/431-440/Minimum Genetic Mutation.cpp
  class Solution (line 1) | class Solution {
    method minMutation (line 3) | int minMutation(string start, string end, vector<string>& bank) {
    method addWord (line 25) | void addWord(string word, unordered_set<string>& dict, queue<string>& ...

FILE: cpp/431-440/Number of Segments in a String.cpp
  class Solution (line 1) | class Solution {
    method countSegments (line 3) | int countSegments(string s) {

FILE: cpp/431-440/Path Sum III.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 13) | void dfs(TreeNode* root, map<int, int>& mymap, int currentSum, int tar...
    method pathSum (line 24) | int pathSum(TreeNode* root, int sum) {

FILE: cpp/431-440/Ternary Expression Parser.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string parseTernary(string expression) {

FILE: cpp/441-450/Add Two Numbers II.cpp
  class Solution (line 9) | class Solution {
    method ListNode (line 11) | ListNode* addToFront(int val, ListNode* head){
    method length (line 17) | int length(ListNode* head) {
    method ListNode (line 27) | ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {

FILE: cpp/441-450/Arithmetic Slices II - Subsequence.cpp
  class Solution (line 1) | class Solution {
    method numberOfArithmeticSlices (line 3) | int numberOfArithmeticSlices(vector<int>& A) {

FILE: cpp/441-450/Arranging Coins.cpp
  class Solution (line 1) | class Solution {
    method arrangeCoins (line 3) | int arrangeCoins(int n) {

FILE: cpp/441-450/Delete Node in a BST.cpp
  class Solution (line 11) | class Solution {
    method TreeNode (line 13) | TreeNode* deleteNode(TreeNode* root, int key) {

FILE: cpp/441-450/Find All Duplicates in an Array.cpp
  class Solution (line 1) | class Solution {
    method findDuplicates (line 3) | vector<int> findDuplicates(vector<int>& nums) {

FILE: cpp/441-450/Number of Boomerangs.cpp
  class Solution (line 1) | class Solution {
    method numberOfBoomerangs (line 3) | int numberOfBoomerangs(vector<pair<int, int>>& points) {

FILE: cpp/441-450/Sequence Reconstruction.cpp
  class Solution (line 1) | class Solution {
    method sequenceReconstruction (line 3) | bool sequenceReconstruction(vector<int>& org, vector<vector<int>>& seq...

FILE: cpp/441-450/Serialize and Deserialize BST.cpp
  class Codec (line 1) | class Codec {
    method string (line 5) | string serialize(TreeNode* root) {
    method preorderDFS (line 11) | void preorderDFS(TreeNode* root, string& order) {
    method TreeNode (line 21) | TreeNode* deserialize(string data) {
    method TreeNode (line 26) | inline TreeNode* reconstruct(const string& buffer, int& pos, int minVa...

FILE: cpp/441-450/String Compression.cpp
  class Solution (line 1) | class Solution {
    method compress (line 3) | int compress(vector<char>& chars) {

FILE: cpp/451-460/132 Pattern.cpp
  class Solution (line 1) | class Solution {
    method find132pattern (line 3) | bool find132pattern(vector<int>& nums) {

FILE: cpp/451-460/4Sum II.cpp
  class Solution (line 1) | class Solution {
    method fillMap (line 3) | void fillMap(const vector<int>& A, const vector<int>& B, unordered_map...
    method fourSumCount (line 10) | int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vecto...

FILE: cpp/451-460/Assign Cookies.cpp
  class Solution (line 1) | class Solution {
    method findContentChildren (line 3) | int findContentChildren(vector<int>& g, vector<int>& s) {

FILE: cpp/451-460/LFU Cache.cpp
  class LFUCache (line 1) | class LFUCache {
    method LFUCache (line 12) | LFUCache(int capacity) {
    method get (line 17) | int get(int key) {
    method put (line 31) | void put(int key, int value) {

FILE: cpp/451-460/Minimum Moves to Equal Array Elements.cpp
  class Solution (line 1) | class Solution {
    method minMoves (line 3) | int minMoves(vector<int>& nums) {

FILE: cpp/451-460/Minimum Number of Arrows to Burst Balloons.cpp
  class Solution (line 1) | class Solution {
    method findMinArrowShots (line 3) | int findMinArrowShots(vector<pair<int, int>>& points) {

FILE: cpp/451-460/Repeated Substring Pattern.cpp
  class Solution (line 1) | class Solution {
    method repeatedSubstringPattern (line 3) | bool repeatedSubstringPattern(string str) {

FILE: cpp/451-460/Sort Characters By Frequency.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string frequencySort(string s) {

FILE: cpp/461-470/Can I Win.cpp
  class Solution (line 1) | class Solution {
    method buildkey (line 3) | int buildkey (bool *nums, int N) {
    method caniwin (line 9) | bool caniwin (bool *nums, int N, int desiredTotal, map<int, bool> &cac...
    method canIWin (line 33) | bool canIWin(int maxChoosableInteger, int desiredTotal) {

FILE: cpp/461-470/Convex Polygon.cpp
  class Solution (line 1) | class Solution {
    method isConvex (line 3) | bool isConvex(vector<vector<int>>& points) {

FILE: cpp/461-470/Count The Repetitions.cpp
  class Solution (line 52) | class Solution {
    method getMaxRepetitions (line 54) | int getMaxRepetitions(string s1, int n1, string s2, int n2) {

FILE: cpp/461-470/Hamming Distance.cpp
  class Solution (line 1) | class Solution {
    method hammingDistance (line 3) | int hammingDistance(int x, int y) {

FILE: cpp/461-470/Island Perimeter.cpp
  class Solution (line 1) | class Solution {
    method islandPerimeter (line 3) | int islandPerimeter(vector<vector<int>>& grid) {

FILE: cpp/461-470/Minimum Moves to Equal Array Elements II.cpp
  class Solution (line 1) | class Solution {
    method minMoves2 (line 3) | int minMoves2(vector<int>& nums) {

FILE: cpp/461-470/Optimal Account Balancing.cpp
  class Solution (line 1) | class Solution {
    method helper (line 3) | int helper(vector<int>& a, int start, int n) {
    method minTransfers (line 17) | int minTransfers(vector<vector<int>>& transactions) {

FILE: cpp/461-470/Unique Substrings in Wraparound String.cpp
  class Solution (line 1) | class Solution {
    method findSubstringInWraproundString (line 3) | int findSubstringInWraproundString(string p) {

FILE: cpp/461-470/Validate IP Address.cpp
  class Solution (line 1) | class Solution {
    method split (line 3) | void split(const std::string &s, char delim, std::vector<std::string> ...
    method split (line 12) | std::vector<std::string> split(const std::string &s, char delim) {
    method validateV4num (line 18) | static bool validateV4num(const string& num) {
    method validateV6num (line 28) | static bool validateV6num(const string& num) {
    method string (line 39) | string checkV4(const string& IP) {
    method string (line 46) | string checkV6(const string& IP) {
    method string (line 54) | string validIPAddress(string IP) {

FILE: cpp/471-480/Concatenated Words.cpp
  class Solution (line 1) | class Solution {
    method findAllConcatenatedWordsInADict (line 3) | vector<string> findAllConcatenatedWordsInADict(vector<string>& words) {
    method wordBreak (line 17) | bool wordBreak(const string& s, const unordered_set<string>& wordDict) {

FILE: cpp/471-480/Encode String with Shortest Length.cpp
  class Solution (line 1) | class Solution {
    method numRepetition (line 2) | int numRepetition(const string &s, const string &t) {
    method string (line 12) | string dfs(const string& s, unordered_map<string, string> &m) {
    method string (line 30) | string encode(string s) {

FILE: cpp/471-480/Heaters.cpp
  class Solution (line 1) | class Solution {
    method findRadius (line 3) | int findRadius(vector<int>& houses, vector<int>& heaters) {

FILE: cpp/471-480/Largest Palindrome Product.cpp
  class Solution (line 1) | class Solution {
    method largestPalindrome (line 3) | int largestPalindrome(int n) {
    method buildPalindrome (line 18) | long buildPalindrome(int n) {

FILE: cpp/471-480/Matchsticks to Square.cpp
  class Solution (line 1) | class Solution {
    method genKey (line 5) | int genKey(const vector<int>& nums) {
    method dfs (line 14) | bool dfs(vector<int>& nums, int sidelength, int remain, int sideidx, i...
    method makesquare (line 42) | bool makesquare(vector<int>& nums) {

FILE: cpp/471-480/Number Complement.cpp
  class Solution (line 1) | class Solution {
    method findComplement (line 3) | int findComplement(int num) {

FILE: cpp/471-480/Ones and Zeroes.cpp
  class Solution (line 1) | class Solution {
    method count (line 3) | pair<int, int> count(const string& str) {
    method findMaxForm (line 13) | int findMaxForm(vector<string>& strs, int m, int n) {

FILE: cpp/471-480/Sliding Window Median.cpp
  class Solution (line 1) | class Solution {
    method medianSlidingWindow (line 3) | vector<double> medianSlidingWindow(vector<int>& nums, int k) {

FILE: cpp/471-480/Total Hamming Distance.cpp
  class Solution (line 1) | class Solution {
    method totalHammingDistance (line 3) | int totalHammingDistance(vector<int>& nums) {

FILE: cpp/481-490/Find Permutation.cpp
  class Solution (line 1) | class Solution {
    method findPermutation (line 3) | vector<int> findPermutation(string s) {

FILE: cpp/481-490/License Key Formatting.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string licenseKeyFormatting(string S, int K) {

FILE: cpp/481-490/Magical String.cpp
  class Solution (line 1) | class Solution {
    method magicalString (line 3) | int magicalString(int n) {

FILE: cpp/481-490/Max Consecutive Ones II.cpp
  class Solution (line 1) | class Solution {
    method findMaxConsecutiveOnes (line 3) | int findMaxConsecutiveOnes(vector<int>& nums) {

FILE: cpp/481-490/Max Consecutive Ones.cpp
  class Solution (line 1) | class Solution {
    method findMaxConsecutiveOnes (line 3) | int findMaxConsecutiveOnes(vector<int>& nums) {

FILE: cpp/481-490/Predict the Winner.cpp
  class Solution (line 1) | class Solution {
    method PredictTheWinner (line 4) | bool PredictTheWinner(vector<int>& nums) {

FILE: cpp/481-490/Robot Room Cleaner.cpp
  class Solution (line 20) | class Solution {
    method dfs (line 22) | void dfs(Robot &robot, set<pair<int, int>>& visited, int i, int j, int...
    method cleanRoom (line 43) | void cleanRoom(Robot& robot) {

FILE: cpp/481-490/Smallest Good Base.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string smallestGoodBase(string n) {

FILE: cpp/481-490/The Maze.cpp
  class Solution (line 1) | class Solution {
    method isStone (line 3) | int isStone(vector<vector<int>>& maze, int i, int j) {
    method hasPath (line 11) | bool hasPath(vector<vector<int>>& maze, vector<int>& start, vector<int...

FILE: cpp/481-490/Zuma Game.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | int dfs(string board, string hand, unordered_map<string, int>& cache) {
    method findMinStep (line 41) | int findMinStep(string board, string hand) {
    method simplify (line 52) | void simplify(string& str) {

FILE: cpp/491-500/Construct the Rectangle.cpp
  class Solution (line 1) | class Solution {
    method constructRectangle (line 3) | vector<int> constructRectangle(int area) {

FILE: cpp/491-500/Diagonal Traverse.cpp
  class Solution (line 1) | class Solution {
    method findDiagonalOrder (line 3) | vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {

FILE: cpp/491-500/Increasing Subsequences.cpp
  class Solution (line 1) | class Solution {
    method findSubsequences (line 3) | void findSubsequences(const vector<int> &nums, vector<int> &subsequenc...
    method findSubsequences (line 17) | vector<vector<int>> findSubsequences(vector<int>& nums) {

FILE: cpp/491-500/Keyboard Row.cpp
  class Solution (line 1) | class Solution {
    method findWords (line 3) | vector<string> findWords(vector<string>& words) {

FILE: cpp/491-500/Next Greater Element I.cpp
  class Solution (line 1) | class Solution {
    method nextGreaterElement (line 3) | vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& num...

FILE: cpp/491-500/Reverse Pairs.cpp
  class Solution (line 1) | class Solution {
    method merge (line 6) | void merge(vector<int>& nums, int start, int mid, int end){
    method mergeSort (line 19) | void mergeSort(vector<int>& nums, int start, int end){
    method reversePairs (line 29) | int reversePairs(vector<int>& nums) {

FILE: cpp/491-500/Target Sum.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | int dfs(const vector<int>& nums, int i, int S, map<pair<int, int>, int...
    method findTargetSumWays (line 17) | int findTargetSumWays(vector<int>& nums, int S) {

FILE: cpp/491-500/Teemo Attacking.cpp
  class Solution (line 1) | class Solution {
    method findPoisonedDuration (line 3) | int findPoisonedDuration(vector<int>& timeSeries, int duration) {

FILE: cpp/491-500/The Maze III.cpp
  class Solution (line 1) | class Solution {
    method isStone (line 3) | int isStone(vector<vector<int>>& maze, int i, int j) {
    method string (line 12) | string findShortestWay(vector<vector<int>>& maze, vector<int>& ball, v...

FILE: cpp/501-510/Base 7.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string convertToBase7(int num) {

FILE: cpp/501-510/Find Mode in Binary Search Tree.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | void dfs(TreeNode* root, int& maximum_count, map<int, int>& mymap) {
    method findMode (line 22) | vector<int> findMode(TreeNode* root) {

FILE: cpp/501-510/IPO.cpp
  class Compare1 (line 1) | class Compare1 {
  class Compare2 (line 8) | class Compare2 {
  class Solution (line 15) | class Solution {
    method findMaximizedCapital (line 17) | int findMaximizedCapital(int k, int W, vector<int>& Profits, vector<in...

FILE: cpp/501-510/Most Frequent Subtree Sum.cpp
  class Solution (line 10) | class Solution {
    method findFrequentTreeSum (line 12) | vector<int> findFrequentTreeSum(TreeNode* root) {
    method countSubtreeSums (line 24) | int countSubtreeSums(TreeNode *r, unordered_map<int,int> &counts, int&...

FILE: cpp/501-510/Next Greater Element II.cpp
  class Solution (line 1) | class Solution {
    method nextGreaterElements (line 3) | vector<int> nextGreaterElements(vector<int>& nums) {

FILE: cpp/501-510/Perfect Number.cpp
  class Solution (line 1) | class Solution {
    method checkPerfectNumber (line 3) | bool checkPerfectNumber(int num) {

FILE: cpp/501-510/Relative Ranks.cpp
  class Solution (line 1) | class Solution {
    method findRelativeRanks (line 3) | vector<string> findRelativeRanks(vector<int>& nums) {

FILE: cpp/501-510/The Maze II.cpp
  class Solution (line 1) | class Solution {
    method isStone (line 3) | int isStone(vector<vector<int>>& maze, int i, int j) {
    method shortestDistance (line 11) | int shortestDistance(vector<vector<int>>& maze, vector<int>& start, ve...

FILE: cpp/511-520/Coin Change 2.cpp
  class Solution (line 1) | class Solution {
    method change (line 3) | int change(int amount, vector<int>& coins) {

FILE: cpp/511-520/Detect Capital.cpp
  class Solution (line 1) | class Solution {
    method detectCapitalUse (line 3) | bool detectCapitalUse(string word) {

FILE: cpp/511-520/Find Bottom Left Tree Value.cpp
  class Solution (line 10) | class Solution {
    method findBottomLeftValue (line 12) | int findBottomLeftValue(TreeNode* root) {

FILE: cpp/511-520/Find Largest Value in Each Tree Row.cpp
  class Solution (line 10) | class Solution {
    method largestValues (line 12) | vector<int> largestValues(TreeNode* root) {

FILE: cpp/511-520/Freedom Trail.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | int dfs(const string& ring, const string& key, int index, map<string, ...
    method findRotateSteps (line 24) | int findRotateSteps(string ring, string key) {

FILE: cpp/511-520/Longest Palindromic Subsequence.cpp
  class Solution (line 1) | class Solution {
    method longestPalindromeSubseq (line 3) | int longestPalindromeSubseq(string s) {

FILE: cpp/511-520/Super Washing Machines.cpp
  class Solution (line 1) | class Solution {
    method findMinMoves (line 3) | int findMinMoves(vector<int>& machines) {

FILE: cpp/521-530/Beautiful Arrangement.cpp
  class Solution (line 1) | class Solution {
    method countArrangement (line 3) | int countArrangement(int N) {
    method counts (line 8) | int counts(int n, vector<int>& vs) {

FILE: cpp/521-530/Contiguous Array.cpp
  class Solution (line 1) | class Solution {
    method get (line 3) | int get(int v) {
    method findMaxLength (line 8) | int findMaxLength(vector<int>& nums) {

FILE: cpp/521-530/Continuous Subarray Sum.cpp
  class Solution (line 1) | class Solution {
    method checkSubarraySum (line 3) | bool checkSubarraySum(vector<int>& nums, int k) {

FILE: cpp/521-530/Longest Uncommon Subsequence I.cpp
  class Solution (line 1) | class Solution {
    method findLUSlength (line 3) | int findLUSlength(string a, string b) {

FILE: cpp/521-530/Longest Uncommon Subsequence II.cpp
  class Solution (line 1) | class Solution {
    method isS1subsOfS2 (line 3) | bool isS1subsOfS2(const string &s1, const string &s2){
    method findLUSlength (line 16) | int findLUSlength(vector<string>& strs) {

FILE: cpp/521-530/Longest Word in Dictionary through Deleting.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string findLongestWord(string s, vector<string>& d) {

FILE: cpp/521-530/Minimum Distance Between BST Nodes.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | void dfs(TreeNode* root, int &pv, int& result) {
    method getMinimumDifference (line 21) | int getMinimumDifference(TreeNode* root) {

FILE: cpp/521-530/Word Abbreviation.cpp
  class Solution (line 1) | class Solution {
    method wordsAbbreviation (line 3) | vector<string> wordsAbbreviation(vector<string>& dict) {
    method string (line 32) | string abbreviate(const string& s, int len) {

FILE: cpp/531-540/Complex Number Multiplication.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string complexNumberMultiply(string a, string b) {

FILE: cpp/531-540/Convert BST to Greater Tree.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | void dfs(TreeNode* root, int& sum) {
    method TreeNode (line 21) | TreeNode* convertBST(TreeNode* root) {

FILE: cpp/531-540/Encode and Decode TinyURL.cpp
  class Solution (line 1) | class Solution {
    method string (line 9) | string encode(string longUrl) {
    method string (line 17) | string decode(string shortUrl) {

FILE: cpp/531-540/Lonely Pixel I.cpp
  class Solution (line 1) | class Solution {
    method findLonelyPixel (line 3) | int findLonelyPixel(vector<vector<char>>& picture) {

FILE: cpp/531-540/Lonely Pixel II.cpp
  class Solution (line 1) | class Solution {
    method findBlackPixel (line 3) | int findBlackPixel(vector<vector<char>>& picture, int N) {

FILE: cpp/531-540/Single Element in a Sorted Array.cpp
  class Solution (line 1) | class Solution {
    method singleNonDuplicate (line 3) | int singleNonDuplicate(vector<int>& nums) {

FILE: cpp/541-550/01 Matrix.cpp
  class Solution (line 1) | class Solution {
    type point (line 3) | struct point {
      method point (line 7) | point (int _i, int _j, int _d): i(_i), j(_j), d(_d) { }
    method updateMatrix (line 11) | vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {

FILE: cpp/541-550/Binary Tree Longest Consecutive Sequence II.cpp
  class Solution (line 10) | class Solution {
    method longestConsecutive (line 12) | int longestConsecutive(TreeNode* root) {
    method dfs (line 18) | pair<int, int> dfs(TreeNode * node, TreeNode * parent, int & longest) {

FILE: cpp/541-550/Boundary of Binary Tree.cpp
  class Solution (line 10) | class Solution {
    method leftBoundary (line 12) | void leftBoundary(TreeNode* root, vector<int>& nodes) {
    method rightBoundary (line 19) | void rightBoundary(TreeNode* root, vector<int>& nodes) {
    method leaves (line 26) | void leaves(TreeNode* root, vector<int>& nodes) {
    method boundaryOfBinaryTree (line 37) | vector<int> boundaryOfBinaryTree(TreeNode* root) {

FILE: cpp/541-550/Diameter of Binary Tree.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 12) | int dfs(TreeNode* root, int& ans) {
    method diameterOfBinaryTree (line 22) | int diameterOfBinaryTree(TreeNode* root) {

FILE: cpp/541-550/Friend Circles.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 3) | void dfs(int i, vector<vector<int>>& M, vector<int>& colors) {
    method findCircleNum (line 14) | int findCircleNum(vector<vector<int>>& M) {

FILE: cpp/541-550/Output Contest Matches.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string findContestMatch(int n) {

FILE: cpp/541-550/Reverse String II.cpp
  class Solution (line 1) | class Solution {
    method _reverse (line 3) | void _reverse(string &str, int i, int j) {
    method string (line 8) | string reverseStr(string s, int k) {

FILE: cpp/541-550/Split Array with Equal Sum.cpp
  class Solution (line 1) | class Solution {
    method splitArray (line 3) | bool splitArray(vector<int>& nums) {

FILE: cpp/551-560/Brick Wall.cpp
  class Solution (line 1) | class Solution {
    method leastBricks (line 3) | int leastBricks(vector<vector<int>>& wall) {

FILE: cpp/551-560/Next Greater Element III.cpp
  class Solution (line 1) | class Solution {
    method nextPermutation (line 3) | void nextPermutation(vector<int> &num) {
    method nextGreaterElement (line 25) | int nextGreaterElement(int n) {

FILE: cpp/551-560/Optimal Division.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string optimalDivision(vector<int>& nums) {

FILE: cpp/551-560/Reverse Words in a String III.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string reverseWords(string s) {

FILE: cpp/551-560/Split Concatenated Strings.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string splitLoopedString(vector<string>& strs) {

FILE: cpp/551-560/Student Attendance Record I.cpp
  class Solution (line 1) | class Solution {
    method checkRecord (line 3) | bool checkRecord(string s) {

FILE: cpp/551-560/Student Attendance Record II.cpp
  class Solution (line 1) | class Solution {
    method sum (line 5) | long sum(long nums[]) {
    method checkRecord (line 9) | int checkRecord(int n) {

FILE: cpp/551-560/Subarray Sum Equals K.cpp
  class Solution (line 1) | class Solution {
    method subarraySum (line 3) | int subarraySum(vector<int>& nums, int k) {

FILE: cpp/561-570/Array Nesting.cpp
  class Solution (line 1) | class Solution {
    method arrayNesting (line 3) | int arrayNesting(vector<int>& nums) {

FILE: cpp/561-570/Array Partition I.cpp
  class Solution (line 1) | class Solution {
    method arrayPairSum (line 3) | int arrayPairSum(vector<int>& nums) {

FILE: cpp/561-570/Binary Tree Tilt.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 11) | int dfs(TreeNode* root, int &result) {
    method findTilt (line 19) | int findTilt(TreeNode* root) {

FILE: cpp/561-570/Longest Line of Consecutive One in Matrix.cpp
  class Solution (line 1) | class Solution {
    method longestLine (line 3) | int longestLine(vector<vector<int>>& M) {

FILE: cpp/561-570/Maximum Vacation Days.cpp
  class Solution (line 1) | class Solution {
    method maxVacationDays (line 3) | int maxVacationDays(vector<vector<int>>& flights, vector<vector<int>>&...
    method dfs (line 10) | int dfs(int city, int week, vector<vector<int>>& dp, const vector<vect...

FILE: cpp/561-570/Permutation in String.cpp
  class Solution (line 1) | class Solution {
    method checkInclusion (line 3) | bool checkInclusion(string s1, string s2) {

FILE: cpp/561-570/Reshape the Matrix.cpp
  class Solution (line 1) | class Solution {
    method matrixReshape (line 3) | vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, in...

FILE: cpp/571-580/Distribute Candies.cpp
  class Solution (line 1) | class Solution {
    method distributeCandies (line 3) | int distributeCandies(vector<int>& candies) {

FILE: cpp/571-580/Out of Boundary Paths.cpp
  class Solution (line 1) | class Solution {
    method inBox (line 3) | bool inBox(int i, int j, int m, int n) {
    method get (line 8) | long get(int i, int j, int k, vector<vector<vector<long>>>& dp, int m,...
    method coeff (line 13) | int coeff(int i, int j, int m, int n) {
    method findPaths (line 23) | int findPaths(int m, int n, int N, int i, int j) {

FILE: cpp/571-580/Squirrel Simulation.cpp
  class Solution (line 1) | class Solution {
    method minDistance (line 3) | int minDistance(int height, int width, vector<int>& tree, vector<int>&...
    method dis (line 15) | int dis(int a1, int b1, int a2, int b2) {

FILE: cpp/571-580/Subtree of Another Tree.cpp
  class Solution (line 10) | class Solution {
    method string (line 12) | string serialize(TreeNode* root) {
    method string (line 17) | string serialize2(TreeNode* root, const string& target, bool &b) {
    method isSubtree (line 24) | bool isSubtree(TreeNode* s, TreeNode* t) {

FILE: cpp/581-590/Delete Operation for Two Strings.cpp
  class Solution (line 1) | class Solution {
    method lcs (line 2) | int lcs(const string& X, const string& Y) {
    method minDistance (line 21) | int minDistance(string word1, string word2) {

FILE: cpp/581-590/Design In-Memory File System.cpp
  class FileSystem (line 1) | class FileSystem {
    type TrieNode (line 3) | struct TrieNode {
      method TrieNode (line 7) | TrieNode() : isFile(false) {}
    method getPaths (line 12) | vector<string> getPaths(const string &path) {
    method FileSystem (line 25) | FileSystem() {
    method ls (line 29) | vector<string> ls(string path) {
    method mkdir (line 45) | void mkdir(string path) {
    method addContentToFile (line 55) | void addContentToFile(string filePath, string content) {
    method string (line 67) | string readContentFromFile(string filePath) {

FILE: cpp/581-590/Erect the Fence.cpp
  class Solution (line 11) | class Solution {
    method coord2_t (line 18) | coord2_t cross(const Point &O, const Point &A, const Point &B) {
    method cmp (line 23) | static bool cmp(Point &p1, Point &p2) {
    method equ (line 27) | static bool equ(Point &p1, Point &p2) { return p1.x == p2.x && p1.y ==...
    method outerTrees (line 30) | vector<Point> outerTrees(vector<Point> &P) {

FILE: cpp/581-590/Kill Process.cpp
  class Solution (line 1) | class Solution {
    method killProcess (line 3) | vector<int> killProcess(vector<int>& pid, vector<int>& ppid, int kill) {

FILE: cpp/581-590/Shortest Unsorted Continuous Subarray.cpp
  class Solution (line 1) | class Solution {
    method findUnsortedSubarray (line 3) | int findUnsortedSubarray(vector<int>& nums) {

FILE: cpp/591-600/Fraction Addition and Subtraction.cpp
  class Solution (line 2) | class Solution {
    method string (line 4) | string fractionAddition(string expression) {

FILE: cpp/591-600/Longest Harmonious Subsequence.cpp
  class Solution (line 1) | class Solution {
    method findLHS (line 3) | int findLHS(vector<int>& nums) {

FILE: cpp/591-600/Minimum Index Sum of Two Lists.cpp
  class Solution (line 1) | class Solution {
    method findRestaurant (line 3) | vector<string> findRestaurant(vector<string>& list1, vector<string>& l...

FILE: cpp/591-600/Non-negative Integers without Consecutive Ones.cpp
  class Solution (line 1) | class Solution {
    method help (line 2) | int help(int num, int highestPos) {
    method findIntegers (line 17) | int findIntegers(int num) {

FILE: cpp/591-600/Range Addition II.cpp
  class Solution (line 1) | class Solution {
    method maxCount (line 3) | int maxCount(int m, int n, vector<vector<int>>& ops) {

FILE: cpp/591-600/Tag Validator.cpp
  class Solution (line 1) | class Solution {
    method isValid (line 3) | bool isValid(string code)  {

FILE: cpp/591-600/Valid Square.cpp
  class Solution (line 1) | class Solution {
    method dSquare (line 2) | int dSquare(vector<int>& p1, vector<int>& p2) {
    method validSquare (line 7) | bool validSquare(vector<int>& p1, vector<int>& p2, vector<int>& p3, ve...

FILE: cpp/601-610/Can Place Flowers.cpp
  class Solution (line 1) | class Solution {
    method canPlaceFlowers (line 3) | bool canPlaceFlowers(vector<int>& flowerbed, int n) {

FILE: cpp/601-610/Construct String from Binary Tree.cpp
  class Solution (line 10) | class Solution {
    method string (line 12) | string tree2str(TreeNode* t) {

FILE: cpp/601-610/Design Compressed String Iterator.cpp
  class StringIterator (line 1) | class StringIterator {
    method StringIterator (line 7) | StringIterator(string compressedString) {
    method next (line 13) | char next() {
    method hasNext (line 21) | bool hasNext() {

FILE: cpp/601-610/Find Duplicate File in System.cpp
  class Solution (line 1) | class Solution {
    method findDuplicate (line 3) | vector<vector<string>> findDuplicate(vector<string>& paths) {

FILE: cpp/611-620/Add Bold Tag in String.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string addBoldTag(string s, vector<string>& dict) {
    method findpairs (line 14) | vector<pair<int, int>> findpairs(const string& s, const vector<string>...
    method merge (line 25) | vector<pair<int, int>> merge(vector<pair<int, int>>& a) {

FILE: cpp/611-620/Merge Two Binary Trees.cpp
  class Solution (line 10) | class Solution {
    method TreeNode (line 12) | TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {

FILE: cpp/611-620/Valid Triangle Number.cpp
  class Solution (line 1) | class Solution {
    method triangleNumber (line 3) | int triangleNumber(vector<int>& nums) {

FILE: cpp/621-630/Add One Row to Tree.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 11) | void dfs(TreeNode* root, TreeNode* parent, int v, int d, bool left) {
    method TreeNode (line 28) | TreeNode* addOneRow(TreeNode* root, int v, int d) {

FILE: cpp/621-630/Course Schedule III.cpp
  class Solution (line 1) | class Solution {
    method scheduleCourse (line 3) | int scheduleCourse(vector<vector<int>>& courses) {

FILE: cpp/621-630/Design Circular Queue.cpp
  class MyCircularQueue (line 1) | class MyCircularQueue {
    method MyCircularQueue (line 9) | MyCircularQueue(int k) {
    method enQueue (line 18) | bool enQueue(int value) {
    method deQueue (line 27) | bool deQueue() {
    method Front (line 35) | int Front() {
    method Rear (line 41) | int Rear() {
    method isEmpty (line 47) | bool isEmpty() {
    method isFull (line 52) | bool isFull() {

FILE: cpp/621-630/K Inverse Pairs Array.cpp
  class Solution (line 1) | class Solution {
    method kInversePairs (line 4) | int kInversePairs(int n, int k) {
    method dfs (line 9) | long dfs(int n, int k, vector<vector<int>>& dp) {

FILE: cpp/621-630/Maximum Distance in Arrays.cpp
  class Solution (line 1) | class Solution {
    method maxDistance (line 3) | int maxDistance(vector<vector<int>>& arrays) {

FILE: cpp/621-630/Maximum Product of Three Numbers.cpp
  class Solution (line 1) | class Solution {
    method maximumProduct (line 3) | int maximumProduct(vector<int>& nums) {

FILE: cpp/621-630/Minimum Factorization.cpp
  class Solution (line 1) | class Solution {
    method smallestFactorization (line 3) | int smallestFactorization(int a) {

FILE: cpp/621-630/Task Scheduler.cpp
  class Solution (line 1) | class Solution {
    method leastInterval (line 3) | int leastInterval(vector<char>& tasks, int n) {

FILE: cpp/631-640/Average of Levels in Binary Tree.cpp
  class Solution (line 10) | class Solution {
    method averageOfLevels (line 12) | vector<double> averageOfLevels(TreeNode* root) {

FILE: cpp/631-640/Decode Ways II.cpp
  class Solution (line 1) | class Solution {
    method ways (line 4) | int ways(char ch) {
    method ways (line 10) | int ways(char ch1, char ch2) {
    method numDecodings (line 30) | int numDecodings(string s) {

FILE: cpp/631-640/Design Excel Sum Formula.cpp
  class Excel (line 1) | class Excel {
    method c2i (line 5) | int c2i(char ch) { return ch - 'A'; }
    method parseNum (line 7) | pair<int, char> parseNum(const string& num) {
    method Excel (line 12) | Excel(int H, char W) {
    method set (line 16) | void set(int r, char c, int v) {
    method get (line 25) | int get(int r, char c) {
    method sum (line 57) | int sum(int r, char c, vector<string> strs) {

FILE: cpp/631-640/Design Log Storage System.cpp
  class LogSystem (line 1) | class LogSystem {
    method LogSystem (line 4) | LogSystem() {
    method put (line 8) | void put(int id, string timestamp) {
    method retrieve (line 12) | vector<int> retrieve(string s, string e, string gra) {

FILE: cpp/631-640/Exclusive Time of Functions.cpp
  class Solution (line 1) | class Solution {
    method split (line 2) | vector<string> split(const string &s, char delim) {
    method exclusiveTime (line 13) | vector<int> exclusiveTime(int n, vector<string>& logs) {

FILE: cpp/631-640/Find the Derangement of An Array.cpp
  class Solution (line 1) | class Solution {
    method findDerangement (line 4) | int findDerangement(int n) {

FILE: cpp/631-640/Shopping Offers.cpp
  class Solution (line 1) | class Solution {
    method dfs (line 2) | void dfs(int currentPrice, int offerIndex, vector<int>& price, vector<...
    method shoppingOffers (line 23) | int shoppingOffers(vector<int>& price, vector<vector<int>>& special, v...

FILE: cpp/631-640/Smallest Range.cpp
  class Solution (line 1) | class Solution {
    method smallestRange (line 3) | vector<int> smallestRange(vector<vector<int>>& nums) {

FILE: cpp/631-640/Solve the Equation.cpp
  class Solution (line 1) | class Solution {
    method parse (line 3) | pair<int, int> parse(string str) {
    method string (line 36) | string solveEquation(string equation) {

FILE: cpp/631-640/Sum of Square Numbers.cpp
  class Solution (line 1) | class Solution {
    method judgeSquareSum (line 3) | bool judgeSquareSum(int c) {

FILE: cpp/641-650/2 Keys Keyboard.cpp
  class Solution (line 1) | class Solution {
    method minSteps (line 3) | int minSteps(int n) {

FILE: cpp/641-650/Design Search Autocomplete System.cpp
  class AutocompleteSystem (line 1) | class AutocompleteSystem {
    method AutocompleteSystem (line 6) | AutocompleteSystem(vector<string> sentences, vector<int> times) {
    method input (line 11) | vector<string> input(char c) {

FILE: cpp/641-650/Dota2 Senate.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string predictPartyVictory(string senate) {

FILE: cpp/641-650/Maximum Average Subarray I.cpp
  class Solution (line 1) | class Solution {
    method findMaxAverage (line 3) | double findMaxAverage(vector<int>& nums, int k) {

FILE: cpp/641-650/Maximum Average Subarray II.cpp
  class Solution (line 1) | class Solution {
    method validate (line 2) | bool validate(const vector<int>& nums, int k, double mid) {
    method findMaxAverage (line 23) | double findMaxAverage(vector<int>& nums, int k) {

FILE: cpp/641-650/Maximum Length of Pair Chain.cpp
  class Solution (line 1) | class Solution {
    method findLongestChain (line 3) | int findLongestChain(vector<vector<int>>& pairs) {

FILE: cpp/641-650/Palindromic Substrings.cpp
  class Solution (line 1) | class Solution {
    method countSubstrings (line 3) | int countSubstrings(string s) {

FILE: cpp/641-650/Replace Words.cpp
  function split (line 1) | vector<string> split(const string &s, char delim) {
  type TrieNode (line 13) | struct TrieNode {
    method TrieNode (line 17) | TrieNode(): word(false) {
  class Trie (line 22) | class Trie {
    method Trie (line 25) | Trie() {
    method insert (line 30) | void insert(const string& s) {
    method string (line 43) | string findShortestRoot(const string& word) {
  class Solution (line 62) | class Solution {
    method string (line 64) | string replaceWords(vector<string>& dict, string sentence) {

FILE: cpp/641-650/Set Mismatch.cpp
  class Solution (line 1) | class Solution {
    method findErrorNums (line 3) | vector<int> findErrorNums(vector<int>& nums) {

FILE: cpp/651-660/4 Keys Keyboard.cpp
  class Solution (line 1) | class Solution {
    method maxA (line 4) | int maxA(int N) {

FILE: cpp/651-660/Coin Path.cpp
  class Solution (line 1) | class Solution {
    method cheapestJump (line 3) | vector<int> cheapestJump(vector<int>& A, int B) {

FILE: cpp/651-660/Find Duplicate Subtrees.cpp
  class Solution (line 10) | class Solution {
    method findDuplicateSubtrees (line 12) | vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
    method string (line 24) | string merkle(TreeNode* root, map<size_t, vector<TreeNode*>>& mymap) {

FILE: cpp/651-660/Find K Closest Elements.cpp
  class Solution (line 2) | class Solution {
    method findClosestElements (line 4) | vector<int> findClosestElements(vector<int>& arr, int k, int x) {
    method findClosestElements (line 40) | vector<int> findClosestElements(vector<int>& arr, int k, int x) {
  class Solution (line 38) | class Solution {
    method findClosestElements (line 4) | vector<int> findClosestElements(vector<int>& arr, int k, int x) {
    method findClosestElements (line 40) | vector<int> findClosestElements(vector<int>& arr, int k, int x) {

FILE: cpp/651-660/Judge Route Circle.cpp
  class Solution (line 1) | class Solution {
    method judgeCircle (line 3) | bool judgeCircle(string moves) {

FILE: cpp/651-660/Maximum Binary Tree.cpp
  class Solution (line 10) | class Solution {
    method TreeNode (line 12) | TreeNode* dfs(std::vector<int>::iterator start, std::vector<int>::iter...
    method TreeNode (line 29) | TreeNode* constructMaximumBinaryTree(vector<int>& nums) {

FILE: cpp/651-660/Print Binary Tree.cpp
  class Solution (line 10) | class Solution {
    method height (line 12) | int height(TreeNode* root, int h) {
    method dfs (line 21) | void dfs(TreeNode* root, vector<vector<string>>& result, int height, i...
    method printTree (line 29) | vector<vector<string>> printTree(TreeNode* root) {

FILE: cpp/651-660/Remove 9.cpp
  class Solution (line 1) | class Solution {
    method newInteger (line 3) | int newInteger(int n) {

FILE: cpp/651-660/Split Array into Consecutive Subsequences.cpp
  class Solution (line 1) | class Solution {
    method isPossible (line 3) | bool isPossible(vector<int>& nums) {

FILE: cpp/651-660/Two Sum IV - Input is a BST.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 13) | void dfs(TreeNode* root, unordered_set<int>& myset, int k) {
    method findTarget (line 27) | bool findTarget(TreeNode* root, int k) {

FILE: cpp/661-670/Beautiful Arrangement II.cpp
  class Solution (line 1) | class Solution {
    method constructArray (line 3) | vector<int> constructArray(int n, int k) {

FILE: cpp/661-670/Equal Tree Partition.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 13) | int dfs(TreeNode* root) {
    method checkEqualTree (line 20) | bool checkEqualTree(TreeNode* root) {

FILE: cpp/661-670/Image Smoother.cpp
  class Solution (line 1) | class Solution {
    method imageSmoother (line 3) | vector<vector<int>> imageSmoother(vector<vector<int>>& M) {

FILE: cpp/661-670/Kth largest Number in Multiplication Table.cpp
  class Solution (line 1) | class Solution {
    method validate (line 2) | bool validate(int p, int m, int n, int k){
    method findKthNumber (line 12) | int findKthNumber(int m, int n, int k) {

FILE: cpp/661-670/Maximum Swap.cpp
  class Solution (line 1) | class Solution {
    method maximumSwap (line 3) | int maximumSwap(int num) {

FILE: cpp/661-670/Maximum Width of Binary Tree.cpp
  class Solution (line 10) | class Solution {
    method widthOfBinaryTree (line 12) | int widthOfBinaryTree(TreeNode* root) {

FILE: cpp/661-670/Non-decreasing Array.cpp
  class Solution (line 1) | class Solution {
    method checkPossibility (line 3) | bool checkPossibility(vector<int>& nums) {

FILE: cpp/661-670/Path Sum IV.cpp
  class Solution (line 1) | class Solution {
    method getLeftChild (line 2) | int getLeftChild(int key) {
    method pathSum (line 8) | int pathSum(vector<int>& nums) {

FILE: cpp/661-670/Strange Printer.cpp
  class Solution (line 1) | class Solution {
    method strangePrinter (line 3) | int strangePrinter(string s) {

FILE: cpp/661-670/Trim a Binary Search Tree.cpp
  class Solution (line 10) | class Solution {
    method TreeNode (line 12) | TreeNode* trimBST(TreeNode* root, int L, int R) {

FILE: cpp/671-680/24 Game.cpp
  class Solution (line 1) | class Solution {
    method op (line 3) | vector<double> op(double d1, double d2) {
    method almost (line 14) | bool almost(double num) {
    method dfs (line 18) | bool dfs(vector<double> nums) {
    method judgePoint24 (line 44) | bool judgePoint24(vector<int>& nums) {

FILE: cpp/671-680/Cut Off Trees for Golf Event.cpp
  class Solution (line 1) | class Solution {
    method cutOffTree (line 3) | int cutOffTree(vector<vector<int>>& forest) {
    method next_step (line 29) | int next_step(vector<vector<int>>& forest, int sr, int sc, int er, int...

FILE: cpp/671-680/Implement Magic Dictionary.cpp
  type TrieNode (line 1) | struct TrieNode {
    method TrieNode (line 5) | TrieNode(): word(false) {
  class Trie (line 10) | class Trie {
    method Trie (line 13) | Trie() {
    method insert (line 18) | void insert(const string& s) {
    method search (line 31) | bool search(TrieNode* tmp, const string& key, int strIndex, int count) {
  class MagicDictionary (line 49) | class MagicDictionary {
    method MagicDictionary (line 53) | MagicDictionary() {
    method buildDict (line 57) | void buildDict(vector<string> dict) {
    method search (line 62) | bool search(string word) {

FILE: cpp/671-680/Longest Continuous Increasing Subsequence.cpp
  class Solution (line 1) | class Solution {
    method findLengthOfLCIS (line 3) | int findLengthOfLCIS(vector<int>& nums) {

FILE: cpp/671-680/Map Sum Pairs.cpp
  type TrieNode (line 1) | struct TrieNode {
    method TrieNode (line 6) | TrieNode(): word(false) {
  class Trie (line 11) | class Trie {
    method dfs (line 13) | int dfs(TrieNode *tmp) {
    method Trie (line 22) | Trie() {
    method insert (line 27) | void insert(const string& s, int val) {
    method startsWith (line 40) | int startsWith(const string& prefix) {
  class MapSum (line 56) | class MapSum {
    method MapSum (line 60) | MapSum() {
    method insert (line 63) | void insert(string key, int val) {
    method sum (line 67) | int sum(string prefix) {

FILE: cpp/671-680/Number of Longest Increasing Subsequence.cpp
  class Solution (line 1) | class Solution {
    method findNumberOfLIS (line 3) | int findNumberOfLIS(vector<int>& nums) {

FILE: cpp/671-680/Second Minimum Node In a Binary Tree.cpp
  class Solution (line 10) | class Solution {
    method findSecondMinimumValue (line 12) | int findSecondMinimumValue(TreeNode* root) {
    method minval (line 17) | int minval(TreeNode* p, int first) {

FILE: cpp/671-680/Valid Palindrome II.cpp
  class Solution (line 1) | class Solution {
    method validPalindrome (line 3) | bool validPalindrome(string s) {

FILE: cpp/671-680/Valid Parenthesis String.cpp
  class Solution (line 1) | class Solution {
    method checkValidString (line 3) | bool checkValidString(string s) {

FILE: cpp/681-690/Baseball Game.cpp
  class Solution (line 1) | class Solution {
    method calPoints (line 3) | int calPoints(vector<string>& ops) {

FILE: cpp/681-690/Employee Importance.cpp
  class Solution (line 14) | class Solution {
    method dfs (line 16) | int dfs(const map<int, Employee*>& mymap, int id) {
    method getImportance (line 25) | int getImportance(vector<Employee*> employees, int id) {

FILE: cpp/681-690/K Empty Slots.cpp
  class Solution (line 1) | class Solution {
    method kEmptySlots (line 3) | int kEmptySlots(vector<int>& flowers, int k) {

FILE: cpp/681-690/Knight Probability in Chessboard.cpp
  class Solution (line 1) | class Solution {
    method knightProbability (line 3) | double knightProbability(int N, int K, int r, int c) {
    method helper (line 8) | double helper(vector<vector<vector<double>>>& dp, int N, int k, int r,...

FILE: cpp/681-690/Longest Univalue Path.cpp
  class Solution (line 10) | class Solution {
    method dfs (line 13) | int dfs(TreeNode* root) {
    method longestUnivaluePath (line 32) | int longestUnivaluePath(TreeNode* root) {

FILE: cpp/681-690/Maximum Sum of 3 Non-Overlapping Subarrays.cpp
  class Solution (line 1) | class Solution {
    method maxSumOfThreeSubarrays (line 3) | vector<int> maxSumOfThreeSubarrays(vector<int>& nums, int k) {

FILE: cpp/681-690/Next Closest Time.cpp
  class Solution (line 1) | class Solution {
    method string (line 3) | string nextClosestTime(string time) {

FILE: cpp/681-690/Redundant Connection II.cpp
  class UF (line 1) | class UF {
    method UF (line 11) | UF(int N) : parent(N), rank(N, 0), N(N), count(N) {
    method find (line 17) | int find(int p) {
    method connected (line 25) | bool connected(int p, int q) {
    method Union (line 29) | void Union(int p, int q) {
  class Solution (line 45) | class Solution {
    method findRedundantDirectedConnection (line 47) | vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {

FILE: cpp/681-690/Redundant Connection.cpp
  class UF (line 1) | class UF {
    method UF (line 11) | UF(int N) : parent(N), rank(N, 0), N(N), count(N) {
    method find (line 17) | int find(int p) {
    method connected (line 25) | bool connected(int p, int q) {
    method Union (line 29) | void Union(int p, int q) {
  class Solution (line 45) | class Solution {
    method findRedundantConnection (line 47) | vector<int> findRedundantConnection(vector<vector<int>>& edges) {

FILE: cpp/681-690/Repeated String Match.cpp
  class Solution (line 1) | class Solution {
    method repeatedStringMatch (line 3) | int repeatedStringMatch(string A, string B) {

FILE: cpp/691-700/Binary Number with Alternating Bits.cpp
  class Solution (line 1) | class Solution {
    method hasAlternatingBits (line 3) | bool hasAlternatingBits(int n) {

FILE: cpp/691-700/Count Binary Substrings.cpp
  class Solution (line 1) | class Solution {
    method countBinarySubstrings (line 3) | int countBinarySubstrings(string s) {

FILE: cpp/691-700/Degree of an Array.cpp
  class Solution (line 1) | class Solution {
    method findShortestSubArray (line 3) | int findShortestSubArray(vector<int>& nums) {

FILE: cpp/691-700/Falling Squares.cpp
  class Solution (line 1) | class Solution {
    method fallingSquares (line 3) | vector<int> fallingSquares(vector<pair<int, int>>& positions) {

FILE: cpp/691-700/Max Area of Island.cpp
  class Solution (line 1) | class Solution {
    method maxAreaOfIsland (line 3) | int maxAreaOfIsland(vector<vector<int>>& grid) {
    method AreaOfIsland (line 11) | int AreaOfIsland(vector<vector<int>>& grid, int i, int j){

FILE: cpp/691-700/Number of Distinct Islands.cpp
  c

[
  {
    "path": ".gitignore",
    "chars": 10,
    "preview": ".DS_Store\n"
  },
  {
    "path": "LICENSE",
    "chars": 1060,
    "preview": "Copyright (C) <2015> <leetcode.com>\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of thi"
  },
  {
    "path": "README.md",
    "chars": 77779,
    "preview": "# leetcode\nLeetCode solutions.\nLeetCode solutions in English.\nLeetCode中文解答。\n\nI uploaded some codes [here](https://zhench"
  },
  {
    "path": "Solve the Equation.cpp",
    "chars": 1028,
    "preview": "// https://discuss.leetcode.com/topic/95378/concise-c-solution-with-regular-expression-12-lines\nclass Solution {\npublic:"
  },
  {
    "path": "TODO",
    "chars": 198,
    "preview": "4 Median of Two Sorted Arrays\n5 Longest Palindromic Substring \n9 Palindrome Number\n10 Regular Expression Matching(花了挺多时间"
  },
  {
    "path": "cpp/001-010/Add Two Numbers.cpp",
    "chars": 629,
    "preview": "class Solution {\npublic:\n    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {\n        ListNode *head = new ListNode"
  },
  {
    "path": "cpp/001-010/Longest Palindromic Substring.cpp",
    "chars": 666,
    "preview": "class Solution {\npublic:\n    string longestPalindrome(string s) {\n        int n = s.length();\n        int longestBegin ="
  },
  {
    "path": "cpp/001-010/Longest Substring Without Repeating Characters.cpp",
    "chars": 510,
    "preview": "class Solution {\npublic:\n    int lengthOfLongestSubstring(string s) {\n        unordered_map<char, int> mymap;\n        in"
  },
  {
    "path": "cpp/001-010/Median of Two Sorted Arrays.cpp",
    "chars": 1171,
    "preview": "class Solution {\npublic:\n    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {\n        int m = num"
  },
  {
    "path": "cpp/001-010/Palindrome Number.cpp",
    "chars": 345,
    "preview": "class Solution {\npublic:\n    bool isPalindrome(int x) {\n        if (x == 0) return true;\n        if (x < 0) return false"
  },
  {
    "path": "cpp/001-010/Regular Expression Matching.cpp",
    "chars": 749,
    "preview": "class Solution {\n    \n    bool isMatch(const string& s, int sidx, const string& p, int pidx) {\n        if (pidx >= p.len"
  },
  {
    "path": "cpp/001-010/Reverse Integer.cpp",
    "chars": 571,
    "preview": "class Solution {\npublic:\n    int reverse(int x) {\n        // INT_MAX: 2147483647\n        // INT_MIN: -2147483648\n       "
  },
  {
    "path": "cpp/001-010/String to Integer (atoi).cpp",
    "chars": 879,
    "preview": "class Solution {\npublic:\n    int myAtoi(string str) {\n        while (str[0] == ' ') {\n            str.erase(0, 1);\n     "
  },
  {
    "path": "cpp/001-010/Two Sum.cpp",
    "chars": 481,
    "preview": "class Solution {\npublic:\n    vector<int> twoSum(vector<int> &numbers, int target) {\n        unordered_map<int, int> m;\n "
  },
  {
    "path": "cpp/001-010/ZigZag Conversion.cpp",
    "chars": 616,
    "preview": "class Solution {\npublic:\n    string convert(string s, int numRows) {\n        if (numRows == 1) {\n            return s;\n "
  },
  {
    "path": "cpp/011-020/3Sum Closest.cpp",
    "chars": 904,
    "preview": "class Solution {\npublic:\n    int threeSumClosest(vector<int>& nums, int target) {\n        int ans = 0;\n        int diff "
  },
  {
    "path": "cpp/011-020/3Sum.cpp",
    "chars": 984,
    "preview": "class Solution {\npublic:\n    vector<vector<int>> threeSum(vector<int>& nums) {\n        vector<vector<int>> result;\n     "
  },
  {
    "path": "cpp/011-020/4Sum.cpp",
    "chars": 1225,
    "preview": "class Solution {\n    \npublic:\n    vector<vector<int> > fourSum(vector<int> &num, int target) {\n        vector<vector<int"
  },
  {
    "path": "cpp/011-020/Container With Most Water.cpp",
    "chars": 297,
    "preview": "class Solution {\npublic:\n    int maxArea(vector<int>& height) {\n        int i(0), j(height.size()-1);\n        int area(0"
  },
  {
    "path": "cpp/011-020/Integer to Roman.cpp",
    "chars": 646,
    "preview": "class Solution {\npublic:\n    string intToRoman(int num) {\n        map<int, string> mymap{\n            {1, \"I\"}, {5, \"V\"}"
  },
  {
    "path": "cpp/011-020/Letter Combinations of a Phone Number.cpp",
    "chars": 736,
    "preview": "class Solution {\n    \npublic:\n    vector<string> letterCombinations(string digits) {\n        string symbols[10] = {\"\", \""
  },
  {
    "path": "cpp/011-020/Longest Common Prefix.cpp",
    "chars": 598,
    "preview": "class Solution {\npublic:\n    string longestCommonPrefix(vector<string>& strs) {\n        if (strs.empty()) {\n            "
  },
  {
    "path": "cpp/011-020/Remove Nth Node From End of List.cpp",
    "chars": 691,
    "preview": "class Solution {\npublic:\n    ListNode* removeNthFromEnd(ListNode* head, int n) {\n        int len = 0;\n        ListNode* "
  },
  {
    "path": "cpp/011-020/Roman to Integer.cpp",
    "chars": 521,
    "preview": "class Solution {\npublic:\n    \n    int romanToInt(string s) {\n        map<char, int> table { \n            {'I', 1}, {'V',"
  },
  {
    "path": "cpp/011-020/Valid Parentheses.cpp",
    "chars": 737,
    "preview": "class Solution {\npublic:\n    bool isValid(string s) {\n        stack<char> container;\n        for (int i = 0;i < s.length"
  },
  {
    "path": "cpp/021-030/Divide Two Integers.cpp",
    "chars": 2196,
    "preview": "/*\n * Solution 1:\n * Use long type\n */\nclass Solution {\npublic:\n    int divide(int dividend, int divisor) {\n        if ("
  },
  {
    "path": "cpp/021-030/Generate Parentheses.cpp",
    "chars": 602,
    "preview": "class Solution {\n    \n    void dfs(string s, int open, int close, vector<string>& parentheses) {\n        if (close < ope"
  },
  {
    "path": "cpp/021-030/Implement strStr().cpp",
    "chars": 447,
    "preview": "class Solution {\npublic:\n    int strStr(string haystack, string needle) {\n        int m = haystack.length(), n = needle."
  },
  {
    "path": "cpp/021-030/Merge Two Sorted Lists.cpp",
    "chars": 737,
    "preview": "class Solution {\npublic:\n    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {\n        ListNode *head = new ListNode"
  },
  {
    "path": "cpp/021-030/Merge k Sorted Lists.cpp",
    "chars": 846,
    "preview": "class Solution {\npublic:\n    ListNode *mergeKLists(vector<ListNode *> &lists) {\n        auto cmp = [] (ListNode *n1, Lis"
  },
  {
    "path": "cpp/021-030/Remove Duplicates from Sorted Array.cpp",
    "chars": 275,
    "preview": "class Solution {\npublic:\n    int removeDuplicates(vector<int>& nums) {\n        int pos = 0;\n        for (int n : nums) {"
  },
  {
    "path": "cpp/021-030/Remove Element.cpp",
    "chars": 262,
    "preview": "class Solution {\npublic:\n    int removeElement(vector<int>& nums, int val) {\n        int pos = 0;\n        for (int n : n"
  },
  {
    "path": "cpp/021-030/Reverse Nodes in k-Group.cpp",
    "chars": 759,
    "preview": "class Solution {\n    \n    int length(ListNode* head) {\n        int len = 0;\n        while (head != nullptr) {\n          "
  },
  {
    "path": "cpp/021-030/Substring with Concatenation of All Words.cpp",
    "chars": 1120,
    "preview": "class Solution {\npublic:\n    vector<int> findSubstring(string s, vector<string>& words) {\n        vector<int> res;\n     "
  },
  {
    "path": "cpp/021-030/Swap Nodes in Pairs.cpp",
    "chars": 339,
    "preview": "class Solution {\npublic:\n    ListNode* swapPairs(ListNode* head) {\n        if (head == nullptr || head->next == nullptr)"
  },
  {
    "path": "cpp/031-040/Combination Sum II.cpp",
    "chars": 1177,
    "preview": "#include <iostream>\n#include <unordered_map>\n#include <vector>\n#include <stack>\n#include <queue>\n\nusing namespace std;\n\n"
  },
  {
    "path": "cpp/031-040/Combination Sum.cpp",
    "chars": 846,
    "preview": "class Solution {\n    \n    void help(vector<int>& now, vector<int>&candidates, int index, int target, vector<vector<int>>"
  },
  {
    "path": "cpp/031-040/Count and Say.cpp",
    "chars": 767,
    "preview": "#include <iostream>\n#include <unordered_map>\n#include <vector>\n#include <stack>\n#include <queue>\n\nusing namespace std;\n\n"
  },
  {
    "path": "cpp/031-040/Longest Valid Parentheses.cpp",
    "chars": 1231,
    "preview": "// Solution 1: DP\nclass Solution {\npublic:\n    int longestValidParentheses(string s) {\n        int n = s.size();\n       "
  },
  {
    "path": "cpp/031-040/Next Permutation.cpp",
    "chars": 661,
    "preview": "class Solution {\npublic:\n    void nextPermutation(vector<int> &num) {\n        if (num.empty()) {\n            return;\n   "
  },
  {
    "path": "cpp/031-040/Search Insert Position.cpp",
    "chars": 373,
    "preview": "class Solution {\npublic:\n    int searchInsert(vector<int>& nums, int target) {\n        int lo = 0;\n        int hi = nums"
  },
  {
    "path": "cpp/031-040/Search for a Range.cpp",
    "chars": 1733,
    "preview": "class Solution {\npublic:\n    vector<int> searchRange(vector<int>& nums, int target) {\n        std::vector<int>::iterator"
  },
  {
    "path": "cpp/031-040/Search in Rotated Sorted Array.cpp",
    "chars": 572,
    "preview": "class Solution {\npublic:\n    int search(vector<int>& nums, int target) {\n        int i = 0;\n        int j = nums.size() "
  },
  {
    "path": "cpp/031-040/Sudoku Solver.cpp",
    "chars": 1616,
    "preview": "class Solution {\n\n    bool rows[9][9];\n    bool cols[9][9];\n    bool rec[3][3][9];\n\n    bool help(vector<vector<char> > "
  },
  {
    "path": "cpp/031-040/Valid Sudoku.cpp",
    "chars": 823,
    "preview": "class Solution {\npublic:\n    bool isValidSudoku(vector<vector<char> > &board) {\n        bool r[9][9], c[9][9], s[3][3][9"
  },
  {
    "path": "cpp/041-050/First Missing Positive.cpp",
    "chars": 542,
    "preview": "class Solution {\npublic:\n    int firstMissingPositive(vector<int>& nums) {\n        if (nums.empty()) return 1;\n        i"
  },
  {
    "path": "cpp/041-050/Group Anagrams.cpp",
    "chars": 437,
    "preview": "class Solution {\npublic:\n    vector<vector<string>> groupAnagrams(vector<string>& strs) {\n        map<string, vector<str"
  },
  {
    "path": "cpp/041-050/Jump Game II.cpp",
    "chars": 483,
    "preview": "class Solution {\npublic:\n    int jump(vector<int>& nums) {\n        \n        if (nums.size() < 2) return 0;\n        \n    "
  },
  {
    "path": "cpp/041-050/Multiply Strings.cpp",
    "chars": 918,
    "preview": "class Solution {\n    \npublic:\n    string multiply(string num1, string num2) {\n        \n        string result(num1.length"
  },
  {
    "path": "cpp/041-050/Permutations II.cpp",
    "chars": 614,
    "preview": "class Solution {\n    \n    void help(vector<vector<int>>& result, int begin, vector<int> num) {\n        if (begin == num."
  },
  {
    "path": "cpp/041-050/Permutations.cpp",
    "chars": 579,
    "preview": "class Solution {\n    \n    void help(vector<vector<int>>& result, int begin, vector<int> &num)\n    {\n        if (begin =="
  },
  {
    "path": "cpp/041-050/Pow.cpp",
    "chars": 372,
    "preview": "class Solution {\npublic:\n    double myPow(double x, int n) {\n        double res = 1.0;\n        double tmp = x;\n        b"
  },
  {
    "path": "cpp/041-050/Rotate Image.cpp",
    "chars": 460,
    "preview": "class Solution {\npublic:\n    void rotate(vector<vector<int> > &matrix) {\n        int n = matrix[0].size() -1;\n        fo"
  },
  {
    "path": "cpp/041-050/Trapping Rain Water.cpp",
    "chars": 584,
    "preview": "class Solution {\npublic:\n    int trap(vector<int>& height) {\n        int i = 0;\n        int j = height.size() - 1;\n     "
  },
  {
    "path": "cpp/041-050/Wildcard Matching.cpp",
    "chars": 515,
    "preview": "class Solution {\npublic:\n    bool isMatch(string s, string p) {\n        \n        int i(0),j(0),ss(0),pp(-1);\n        \n  "
  },
  {
    "path": "cpp/051-060/Insert Interval.cpp",
    "chars": 896,
    "preview": "class Solution {\n    \n    vector<Interval> merge(vector<Interval> &intervals) {\n        if(intervals.size() < 2)\n       "
  },
  {
    "path": "cpp/051-060/Jump Game.cpp",
    "chars": 404,
    "preview": "class Solution {\npublic:\n    bool canJump(vector<int>& nums) {\n        \n        int maxpos(0);\n\n        for (int i = 0; "
  },
  {
    "path": "cpp/051-060/Length of Last Word.cpp",
    "chars": 282,
    "preview": "class Solution {\npublic:\n    int lengthOfLastWord(string s) {\n        int len = 0, tail = s.length() - 1;\n        while "
  },
  {
    "path": "cpp/051-060/Maximum_Subarray.cpp",
    "chars": 970,
    "preview": "/*************************************************************************\n\t> File Name: Maximum_Subarray.cpp\n\t> Author:"
  },
  {
    "path": "cpp/051-060/Merge Intervals.cpp",
    "chars": 704,
    "preview": "class Solution {\npublic:\n    vector<vector<int>> merge(vector<vector<int>> &intervals) {\n        auto comp = [](const ve"
  },
  {
    "path": "cpp/051-060/N-Queens II.cpp",
    "chars": 883,
    "preview": "class Solution {\n    \n    bool *cols;\n    bool *add;\n    bool *diff;\n    int n;\n    \n    bool valid(int i, int j) {\n    "
  },
  {
    "path": "cpp/051-060/N-Queens.cpp",
    "chars": 1272,
    "preview": "class Solution {\n    \n    bool *cols;\n    bool *add;\n    bool *diff;\n    int n;\n    \n    bool valid(int i, int j)\n    {\n"
  },
  {
    "path": "cpp/051-060/Permutation Sequence.cpp",
    "chars": 570,
    "preview": "class Solution {\npublic:\n    string getPermutation(int n, int k) {\n        int pTable[10] = {1};\n        for (int i = 1;"
  },
  {
    "path": "cpp/051-060/Spiral Matrix II.cpp",
    "chars": 1066,
    "preview": "#include <iostream>\n#include <unordered_map>\n#include <vector>\n#include <stack>\n#include <queue>\n\nusing namespace std;\n\n"
  },
  {
    "path": "cpp/051-060/Spiral Matrix.cpp",
    "chars": 1055,
    "preview": "#include <iostream>\n#include <unordered_map>\n#include <vector>\n#include <stack>\n#include <queue>\n\nusing namespace std;\n\n"
  },
  {
    "path": "cpp/061-070/Add Binary.cpp",
    "chars": 580,
    "preview": "class Solution {\npublic:\n    string addBinary(string a, string b) {\n        string result;\n        int carry = 0;\n      "
  },
  {
    "path": "cpp/061-070/Climbing Stairs.cpp",
    "chars": 263,
    "preview": "class Solution {\npublic:\n    int climbStairs(int n) {\n        vector<int> dp(n, 0);\n        dp[0] = 1;\n        dp[1] = 2"
  },
  {
    "path": "cpp/061-070/Minimum Path Sum .cpp",
    "chars": 464,
    "preview": "public:\nint minPathSum(vector<vector<int> > &grid) {\n    \n    int n = grid.size();\n    int m = grid[0].size();\n    int p"
  },
  {
    "path": "cpp/061-070/Plus One.cpp",
    "chars": 374,
    "preview": "class Solution {\npublic:\n    vector<int> plusOne(vector<int>& digits) {\n        int carry(1);\n        for (int i = digit"
  },
  {
    "path": "cpp/061-070/Rotate List.cpp",
    "chars": 768,
    "preview": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n *     int val;\n *     ListNode *next;\n *     ListNode(in"
  },
  {
    "path": "cpp/061-070/Sqrt.cpp",
    "chars": 969,
    "preview": "class Solution {\npublic:\n    int mySqrt(int x) {\n        if (x == 0) return 0;\n        int left(1), right(x);\n        wh"
  },
  {
    "path": "cpp/061-070/Text Justification.cpp",
    "chars": 1828,
    "preview": "class Solution {\n    \n    vector<int> help(vector<string> &words, int start, int end, int L)\n    {\n        int wordCount"
  },
  {
    "path": "cpp/061-070/Unique Paths II .cpp",
    "chars": 700,
    "preview": "class Solution {\npublic:\n    int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) {\n        int m(obstacleGr"
  },
  {
    "path": "cpp/061-070/Unique Paths.cpp",
    "chars": 301,
    "preview": "class Solution {\npublic:\n    int uniquePaths(int m, int n) {\n        vector<vector<int> > path(m, vector<int> (n, 1));\n "
  },
  {
    "path": "cpp/061-070/Valid Number.cpp",
    "chars": 1049,
    "preview": "class Solution {\npublic:\n    bool isNumber(string str) {\n        int state=0, flag=0; // flag to judge the special case "
  },
  {
    "path": "cpp/071-080/Combinations.cpp",
    "chars": 563,
    "preview": "class Solution {\n    \n    void help(int n, int k, int index, vector<int>&tmp, vector<vector<int>>&v)\n    {\n        if(k "
  },
  {
    "path": "cpp/071-080/Edit Distance.cpp",
    "chars": 725,
    "preview": "class Solution {\npublic:\n    int minDistance(string word1, string word2) {\n        int m = word1.length();\n        int n"
  },
  {
    "path": "cpp/071-080/Minimum Window Substring.cpp",
    "chars": 781,
    "preview": "class Solution {\npublic:\n    string minWindow(string s, string t) {\n        unordered_map<char, int> dict;\n        int c"
  },
  {
    "path": "cpp/071-080/Remove Duplicates from Sorted Array II.cpp",
    "chars": 316,
    "preview": "class Solution {\npublic:\n    int removeDuplicates(vector<int>& nums) {\n        int rear(1), n(nums.size());\n        if ("
  },
  {
    "path": "cpp/071-080/Search a 2D Matrix.cpp",
    "chars": 459,
    "preview": "class Solution {\npublic:\n    bool searchMatrix(vector<vector<int> > &matrix, int target) {\n        int row(matrix.size()"
  },
  {
    "path": "cpp/071-080/Set Matrix Zeroes.cpp",
    "chars": 823,
    "preview": "class Solution {\npublic:\n    void setZeroes(vector<vector<int> > &matrix) {\n        \n        bool col0 = false;\n        "
  },
  {
    "path": "cpp/071-080/Simplify Path.cpp",
    "chars": 455,
    "preview": "class Solution {\npublic:\n    string simplifyPath(string path) {\n        string res, tmp;\n        vector<string> stk;\n   "
  },
  {
    "path": "cpp/071-080/Sort Colors.cpp",
    "chars": 427,
    "preview": "class Solution {\npublic:\n    void sortColors(vector<int>& nums) {\n        int i = 0, j = 0;\n        for (int r = 0; r < "
  },
  {
    "path": "cpp/071-080/Subsets.cpp",
    "chars": 527,
    "preview": "class Solution {\npublic:\n    vector<vector<int> > subsets(vector<int> &S) {\n        \n        sort(S.begin(),S.end());\n  "
  },
  {
    "path": "cpp/071-080/Word Search.cpp",
    "chars": 1024,
    "preview": "class Solution {\npublic:\n    bool dfs(vector<vector<char>>& board, const string &word, int i, int j, int ind) {\n        "
  },
  {
    "path": "cpp/081-090/Gray Code.cpp",
    "chars": 284,
    "preview": "class Solution {\npublic:\n    vector<int> grayCode(int n) {\n        vector<int> v{0};\n        for (int i = 0; i < n; i++)"
  },
  {
    "path": "cpp/081-090/Largest Rectangle in Histogram.cpp",
    "chars": 530,
    "preview": "class Solution {\npublic:\n    int largestRectangleArea(vector<int> &hist) {\n        int res(0);\n        stack<int> s;\n   "
  },
  {
    "path": "cpp/081-090/Maximal Rectangle.cpp",
    "chars": 902,
    "preview": "class Solution {\npublic:\n    int maximalRectangle(vector<vector<char>>& matrix) {\n        if (matrix.size() <= 0) return"
  },
  {
    "path": "cpp/081-090/Merge Sorted Array.cpp",
    "chars": 675,
    "preview": "class Solution {\npublic:\n    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {\n        int i = m - 1;\n "
  },
  {
    "path": "cpp/081-090/Partition List.cpp",
    "chars": 652,
    "preview": "class Solution {\npublic:\n    ListNode *partition(ListNode *head, int x) {\n        \n        ListNode *head1 = new ListNod"
  },
  {
    "path": "cpp/081-090/Remove Duplicates from Sorted List II.cpp",
    "chars": 1136,
    "preview": "#include <iostream>\n#include <string>\n#include <vector>\n#include <cmath>\n#include <stack>\n#include <string>\n\nusing names"
  },
  {
    "path": "cpp/081-090/Remove Duplicates from Sorted List.cpp",
    "chars": 909,
    "preview": "#include <iostream>\n#include <string>\n#include <vector>\n#include <cmath>\n#include <stack>\n#include <string>\n\nusing names"
  },
  {
    "path": "cpp/081-090/Scramble String.cpp",
    "chars": 772,
    "preview": "class Solution {\n    \npublic:\n    bool isScramble(string s1, string s2) {\n        // Note: The Solution object is instan"
  },
  {
    "path": "cpp/081-090/Search in Rotated Sorted Array II.cpp",
    "chars": 665,
    "preview": "class Solution {\npublic:\n    bool search(vector<int>& nums, int target) {\n        int i = 0;\n        int j = nums.size()"
  },
  {
    "path": "cpp/081-090/Subsets II.cpp",
    "chars": 1036,
    "preview": "class Solution {\npublic:\n    vector<vector<int>> subsetsWithDup(vector<int>& nums) {\n        \n        sort(nums.begin(),"
  },
  {
    "path": "cpp/091-100/Binary Tree Inorder Traversal.cpp",
    "chars": 663,
    "preview": "class Solution {\npublic:\n    vector<int> inorderTraversal(TreeNode* root) {\n        vector<int> result;\n        stack<Tr"
  },
  {
    "path": "cpp/091-100/Decode Ways.cpp",
    "chars": 988,
    "preview": "class Solution {\n    \n    bool valid(char ch1, char ch2)\n    {\n        if(ch1 == '1')\n            return true;\n        e"
  },
  {
    "path": "cpp/091-100/Interleaving String.cpp",
    "chars": 1081,
    "preview": "class Solution {\n    \npublic:\n    bool isInterleave(string s1, string s2, string s3) {\n        if(s1.length() + s2.lengt"
  },
  {
    "path": "cpp/091-100/Recover Binary Search Tree.cpp",
    "chars": 793,
    "preview": "class Solution {\npublic:\n    void recoverTree(TreeNode* root) {\n        stack<TreeNode*>s;\n        TreeNode *p = root;\n "
  },
  {
    "path": "cpp/091-100/Restore IP Addresses.cpp",
    "chars": 821,
    "preview": "class Solution {\npublic:\n    vector<string> restoreIpAddresses(string s) {\n        vector<string> ret;\n        string an"
  },
  {
    "path": "cpp/091-100/Reverse Linked List II.cpp",
    "chars": 717,
    "preview": "class Solution {\npublic:\n    ListNode *reverseBetween(ListNode *head, int m, int n) {\n        int d = n - m;\n        if("
  },
  {
    "path": "cpp/091-100/Same Tree.cpp",
    "chars": 312,
    "preview": "class Solution {\npublic:\n    bool isSameTree(TreeNode* p, TreeNode* q) {\n        if (p == nullptr && q == nullptr) retur"
  },
  {
    "path": "cpp/091-100/Unique Binary Search Trees II.cpp",
    "chars": 1111,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/091-100/Unique Binary Search Trees.cpp",
    "chars": 274,
    "preview": "class Solution {\npublic:\n    int numTrees(int n) {\n        vector<int> dp(n+1, 0);\n        dp[0] = dp[1] = 1;\n        \n "
  },
  {
    "path": "cpp/091-100/Validate Binary Search Tree.cpp",
    "chars": 640,
    "preview": "class Solution {\npublic:\n    bool isValidBST(TreeNode* root) {\n        stack<TreeNode*>s;\n        TreeNode *p = root;\n  "
  },
  {
    "path": "cpp/1001-10000/1001-1010/Construct Binary Search Tree from Preorder Traversal.cpp",
    "chars": 816,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/1001-10000/1011-1020/Best Sightseeing Pair.cpp",
    "chars": 373,
    "preview": "class Solution {\npublic:\n    int maxScoreSightseeingPair(vector<int>& A) {\n        int best_i = 0;\n        int ans = 0;\n"
  },
  {
    "path": "cpp/1001-10000/1011-1020/Binary Prefix Divisible By 5.cpp",
    "chars": 332,
    "preview": "class Solution {\npublic:\n    vector<bool> prefixesDivBy5(vector<int>& A) {\n        vector<bool> answer(A.size());\n      "
  },
  {
    "path": "cpp/1001-10000/1011-1020/Binary String With Substrings Representing 1 To N.cpp",
    "chars": 519,
    "preview": "class Solution {\npublic:\n    bool queryString(string S, int N) {\n        for (int i = N; i >= 1; i--) {\n            int "
  },
  {
    "path": "cpp/1001-10000/1011-1020/Convert to Base -2.cpp",
    "chars": 376,
    "preview": "class Solution {\npublic:\n    string baseNeg2(int N) {\n        if (N == 0) return \"0\";\n        string ans;\n        \n     "
  },
  {
    "path": "cpp/1001-10000/1011-1020/Next Greater Node In Linked List.cpp",
    "chars": 780,
    "preview": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n *     int val;\n *     ListNode *next;\n *     ListNode(in"
  },
  {
    "path": "cpp/1001-10000/1011-1020/Number of Enclaves.cpp",
    "chars": 1056,
    "preview": "class Solution {\n    \n    pair<int, int> tmp[4] = {{1,0}, {-1,0}, {0,1}, {0,-1}};\n    \n    int m;\n    int n;\n    \n    vo"
  },
  {
    "path": "cpp/1001-10000/1011-1020/Partition Array Into Three Parts With Equal Sum.cpp",
    "chars": 392,
    "preview": "class Solution {\npublic:\n    bool canThreePartsEqualSum(vector<int>& A) {\n        int target = std::accumulate(A.begin()"
  },
  {
    "path": "cpp/1001-10000/1021-1030/Camelcase Matching.cpp",
    "chars": 936,
    "preview": "class Solution {\npublic:\n    vector<bool> camelMatch(vector<string>& queries, string pattern) {\n        vector<bool> ans"
  },
  {
    "path": "cpp/1001-10000/1021-1030/Divisor Game.cpp",
    "chars": 428,
    "preview": "class Solution {\n    map<int, bool> dp;\npublic:\n    bool divisorGame(int N) {\n        if (N == 0) return false;\n        "
  },
  {
    "path": "cpp/1001-10000/1021-1030/Longest Arithmetic Sequence.cpp",
    "chars": 511,
    "preview": "class Solution {\npublic:\n    int longestArithSeqLength(vector<int>& A) {\n        unordered_map<int, int> dp;\n        int"
  },
  {
    "path": "cpp/1001-10000/1021-1030/Matrix Cells in Distance Order.cpp",
    "chars": 1273,
    "preview": "class Solution {\npublic:\n    vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0) {\n        vector<vector"
  },
  {
    "path": "cpp/1001-10000/1021-1030/Maximum Difference Between Node and Ancestor.cpp",
    "chars": 682,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/1001-10000/1021-1030/Recover a Tree From Preorder Traversal.cpp",
    "chars": 935,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/1001-10000/1021-1030/Remove Outermost Parentheses.cpp",
    "chars": 620,
    "preview": "class Solution {\npublic:\n    string removeOuterParentheses(string S) {\n        string return_ans;\n        stack<char> my"
  },
  {
    "path": "cpp/1001-10000/1021-1030/Sum of Root To Leaf Binary Numbers.cpp",
    "chars": 591,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/1001-10000/1021-1030/Two City Scheduling.cpp",
    "chars": 811,
    "preview": "class Solution {\npublic:\n    int twoCitySchedCost(vector<vector<int>>& costs) {\n        sort(begin(costs), end(costs), ["
  },
  {
    "path": "cpp/1001-10000/1021-1030/Video Stitching.cpp",
    "chars": 714,
    "preview": "class Solution {\npublic:\n    int videoStitching(vector<vector<int>>& clips, int T) {\n        auto cmp = [](const vector<"
  },
  {
    "path": "cpp/1001-10000/1031-1040/Binary Search Tree to Greater Sum Tree.cpp",
    "chars": 519,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/1001-10000/1031-1040/Coloring A Border.cpp",
    "chars": 1306,
    "preview": "class Solution {\n    \n    int old_color;\n    int new_color;\n    int row;\n    int col;\n    pair<int, int> tmp[4] = {{-1, "
  },
  {
    "path": "cpp/1001-10000/1031-1040/Escape a Large Maze.cpp",
    "chars": 1613,
    "preview": "class Solution {\n    \n    bool find = false;\n    \n    pair<int, int> tmp[4] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};\n    \n "
  },
  {
    "path": "cpp/1001-10000/1031-1040/Maximum Sum of Two Non-Overlapping Subarrays.cpp",
    "chars": 615,
    "preview": "class Solution {\npublic:\n    int maxSumTwoNoOverlap(vector<int>& A, int L, int M) {\n        vector<int> sum = {0};\n     "
  },
  {
    "path": "cpp/1001-10000/1031-1040/Minimum Score Triangulation of Polygon.cpp",
    "chars": 985,
    "preview": "class Solution {\n    \n    int dfs(vector<int>& A, map<pair<int, int>, int>& cache, int start_index, int end_index) {\n   "
  },
  {
    "path": "cpp/1001-10000/1031-1040/Moving Stones Until Consecutive.cpp",
    "chars": 494,
    "preview": "class Solution {\npublic:\n    vector<int> numMovesStones(int a, int b, int c) {\n        vector<int> v{a,b,c};\n        sor"
  },
  {
    "path": "cpp/1001-10000/1031-1040/Stream of Characters.cpp",
    "chars": 1698,
    "preview": "struct TrieNode {\n    TrieNode *nodes[26];\n    bool word;\n    // Initialize your data structure here.\n    TrieNode(): wo"
  },
  {
    "path": "cpp/1001-10000/1031-1040/Uncrossed Lines.cpp",
    "chars": 554,
    "preview": "class Solution {\npublic:\n    int maxUncrossedLines(vector<int>& A, vector<int>& B) {\n        int m = A.size();\n        i"
  },
  {
    "path": "cpp/1001-10000/1031-1040/Valid Boomerang.cpp",
    "chars": 552,
    "preview": "class Solution {\npublic:\n    bool isBoomerang(vector<vector<int>>& points) {\n        sort(points.begin(), points.end());"
  },
  {
    "path": "cpp/1001-10000/1041-1050/Flower Planting With No Adjacent.cpp",
    "chars": 1219,
    "preview": "class Solution {\n    vector<int> colors;\n    \n    void dfs(int u, map<int, vector<int>>& edges) {\n        vector<int> ne"
  },
  {
    "path": "cpp/1001-10000/1041-1050/Last Stone Weight II.cpp",
    "chars": 589,
    "preview": "class Solution {\n\npublic:\n    int lastStoneWeightII(vector<int>& stones) {\n        int sum = 0;\n        bool dp[1501] = "
  },
  {
    "path": "cpp/1001-10000/1041-1050/Last Stone Weight.cpp",
    "chars": 525,
    "preview": "class Solution {\npublic:\n    int lastStoneWeight(vector<int>& stones) {\n        std::priority_queue<int, std::vector<int"
  },
  {
    "path": "cpp/1001-10000/1041-1050/Longest String Chain.cpp",
    "chars": 949,
    "preview": "class Solution {\n    \n    int dfs(const string& word, const unordered_set<string>& dictionary, unordered_map<string, int"
  },
  {
    "path": "cpp/1001-10000/1041-1050/Partition Array for Maximum Sum.cpp",
    "chars": 635,
    "preview": "class Solution {\npublic:\n    int maxSumAfterPartitioning(vector<int>& A, int K) {\n        vector<int> dp(A.size()+1, 0);"
  },
  {
    "path": "cpp/1001-10000/1041-1050/Remove All Adjacent Duplicates In String.cpp",
    "chars": 326,
    "preview": "class Solution {\npublic:\n    string removeDuplicates(string S) {\n        int i = 0;\n        \n        for (char ch : S) {"
  },
  {
    "path": "cpp/1001-10000/1041-1050/Robot Bounded In Circle.cpp",
    "chars": 1593,
    "preview": "class Solution {\n    \n    pair<int, int> getNextDirection(pair<int, int> d, char ch) {\n        if (ch == 'L') {\n        "
  },
  {
    "path": "cpp/1001-10000/1051-1060/Distant Barcodes.cpp",
    "chars": 1106,
    "preview": "class Solution {\npublic:\n    vector<int> rearrangeBarcodes(vector<int>& barcodes) {\n        auto cmp = [](const pair<int"
  },
  {
    "path": "cpp/1001-10000/1051-1060/Grumpy Bookstore Owner.cpp",
    "chars": 574,
    "preview": "class Solution {\npublic:\n    int maxSatisfied(vector<int>& customers, vector<int>& grumpy, int X) {\n        int gained ="
  },
  {
    "path": "cpp/1001-10000/1051-1060/Height Checker.cpp",
    "chars": 333,
    "preview": "class Solution {\npublic:\n    int heightChecker(vector<int>& heights) {\n        int returned_ans = 0;\n        vector<int>"
  },
  {
    "path": "cpp/1001-10000/1051-1060/Previous Permutation With One Swap.cpp",
    "chars": 811,
    "preview": "class Solution {\npublic:\n    vector<int> prevPermOpt1(vector<int>& A) {\n        if (A.empty()) return A;\n        \n      "
  },
  {
    "path": "cpp/1001-10000/1071-1080/Adding Two Negabinary Numbers.cpp",
    "chars": 974,
    "preview": "class Solution {\npublic:\n    vector<int> addNegabinary(vector<int>& arr1, vector<int>& arr2) {\n        vector<int> ans;\n"
  },
  {
    "path": "cpp/1001-10000/1071-1080/Flip Columns For Maximum Number of Equal Rows.cpp",
    "chars": 618,
    "preview": "class Solution {\n    \n    void process(map<string, int>& mymap, const vector<int>& vec) {\n        string str1, str2;\n   "
  },
  {
    "path": "cpp/1001-10000/1071-1080/Greatest Common Divisor of Strings.cpp",
    "chars": 669,
    "preview": "class Solution {\n    \n    bool IsValid(const string& str, const string& candidate) {\n        for (int i = 0; i < str.len"
  },
  {
    "path": "cpp/1001-10000/1071-1080/Insufficient Nodes in Root to Leaf Paths.cpp",
    "chars": 655,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/1001-10000/1071-1080/Letter Tile Possibilities.cpp",
    "chars": 691,
    "preview": "class Solution {\n    int fact[8] = { 1, 1, 2, 6, 24, 120, 720, 5040 };\n    set<string> st;\n    \n    int uniquePerms(cons"
  },
  {
    "path": "cpp/1001-10000/1071-1080/Number of Submatrices That Sum to Target.cpp",
    "chars": 765,
    "preview": "class Solution {\npublic:\n    int numSubmatrixSumTarget(vector<vector<int>>& matrix, int target) {\n        int m = matrix"
  },
  {
    "path": "cpp/1001-10000/1071-1080/Occurrences After Bigram.cpp",
    "chars": 691,
    "preview": "class Solution {\npublic:\n    vector<string> findOcurrences(string text, string first, string second) {\n        string ma"
  },
  {
    "path": "cpp/1001-10000/1081-1090/Duplicate Zeros.cpp",
    "chars": 569,
    "preview": "class Solution {\npublic:\n    void duplicateZeros(vector<int>& arr) {\n        int zeros_now = 0;\n        for (int e : arr"
  },
  {
    "path": "cpp/1001-10000/1081-1090/Largest Values From Labels.cpp",
    "chars": 763,
    "preview": "class Solution {\npublic:\n    int largestValsFromLabels(vector<int>& values, vector<int>& labels, int num_wanted, int use"
  },
  {
    "path": "cpp/1001-10000/1081-1090/Smallest Subsequence of Distinct Characters.cpp",
    "chars": 1043,
    "preview": "class Solution {\npublic:\n    string smallestSubsequence(string text) {\n        \n        bool visited[26] = {false};\n    "
  },
  {
    "path": "cpp/1001-10000/1091-1100/Brace Expansion II.cpp",
    "chars": 2215,
    "preview": "class Solution {\n    \n    set<string> merge(const set<string>& set1, const set<string>& set2) {\n        set<string> ans;"
  },
  {
    "path": "cpp/1001-10000/1091-1100/Car Pooling.cpp",
    "chars": 548,
    "preview": "class Solution {\npublic:\n    bool carPooling(vector<vector<int>>& trips, int capacity) {\n        vector<pair<int, int>> "
  },
  {
    "path": "cpp/1001-10000/1091-1100/Find in Mountain Array.cpp",
    "chars": 2569,
    "preview": "/**\n * // This is the MountainArray's API interface.\n * // You should not implement it, or speculate about its implement"
  },
  {
    "path": "cpp/1001-10000/1091-1100/Shortest Common Supersequence.cpp",
    "chars": 1520,
    "preview": "class Solution {\n    \npublic:\n    string shortestCommonSupersequence(string str1, string str2) {\n        int m = str1.si"
  },
  {
    "path": "cpp/1001-10000/1091-1100/Shortest Path in Binary Matrix.cpp",
    "chars": 1304,
    "preview": "class Solution {\npublic:\n    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {\n        int m = grid.size();\n    "
  },
  {
    "path": "cpp/1001-10000/1091-1100/Statistics from a Large Sample.cpp",
    "chars": 1179,
    "preview": "class Solution {\npublic:\n    vector<double> sampleStats(vector<int>& count) {\n        vector<double> res{256, -1, 0, 0, "
  },
  {
    "path": "cpp/1001-10000/1091-1100/Two Sum Less Than K.cpp",
    "chars": 422,
    "preview": "class Solution {\npublic:\n    int twoSumLessThanK(vector<int>& A, int K) {\n        sort(begin(A), end(A));\n        int i "
  },
  {
    "path": "cpp/1001-10000/1101-1110/Corporate Flight Bookings.cpp",
    "chars": 523,
    "preview": "class Solution {\npublic:\n    vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {\n        unordered_ma"
  },
  {
    "path": "cpp/1001-10000/1101-1110/Defanging an IP Address.cpp",
    "chars": 319,
    "preview": "class Solution {\npublic:\n    string defangIPaddr(string address) {\n        string ans;\n        \n        for (char ch : a"
  },
  {
    "path": "cpp/1001-10000/1101-1110/Delete Nodes And Return Forest.cpp",
    "chars": 1019,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/1001-10000/1101-1110/Distribute Candies to People.cpp",
    "chars": 412,
    "preview": "class Solution {\npublic:\n    vector<int> distributeCandies(int candies, int num_people) {\n        vector<int> ans(num_pe"
  },
  {
    "path": "cpp/1001-10000/1101-1110/Filling Bookcase Shelves.cpp",
    "chars": 2182,
    "preview": "class Solution {\npublic:\n    int minHeightShelves(vector<vector<int>>& books, int shelf_width) {\n        vector<int> dp("
  },
  {
    "path": "cpp/1001-10000/1101-1110/Parsing A Boolean Expression.cpp",
    "chars": 1367,
    "preview": "class Solution {\npublic:\n    bool parseBoolExpr(string expression) {\n        stack<char> ops;\n        stack<bool> nums;\n"
  },
  {
    "path": "cpp/1001-10000/1101-1110/Path In Zigzag Labelled Binary Tree.cpp",
    "chars": 790,
    "preview": "class Solution {\npublic:\n    vector<int> pathInZigZagTree(int label) {\n        int row = 0;\n        int tmp = label;\n   "
  },
  {
    "path": "cpp/1001-10000/1111-1120/Maximum Nesting Depth of Two Valid Parentheses Strings.cpp",
    "chars": 474,
    "preview": "class Solution {\npublic:\n    vector<int> maxDepthAfterSplit(string seq) {\n        int n = seq.size();\n        vector<int"
  },
  {
    "path": "cpp/1001-10000/1111-1120/Print FooBar Alternately.cpp",
    "chars": 672,
    "preview": "class FooBar {\n    mutex m1,m2;\nprivate:\n    int n;\n\npublic:\n    FooBar(int n) {\n        this->n = n;\n\t\tm1.lock();\n    }"
  },
  {
    "path": "cpp/1001-10000/1111-1120/Print in Order.cpp",
    "chars": 684,
    "preview": "class Foo {\n    \n    std::promise<void> p1;\n    std::promise<void> p2;\n    \npublic:\n    Foo() {\n        \n    }\n\n    void"
  },
  {
    "path": "cpp/1001-10000/1121-1130/Lowest Common Ancestor of Deepest Leaves.cpp",
    "chars": 825,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/1001-10000/1121-1130/Minimum Cost Tree From Leaf Values.cpp",
    "chars": 1087,
    "preview": "class Solution {\npublic:\n    int mctFromLeafValues(vector<int>& arr) {\n        int n = arr.size();\n        vector<vector"
  },
  {
    "path": "cpp/1001-10000/1121-1130/Number of Equivalent Domino Pairs.cpp",
    "chars": 458,
    "preview": "class Solution {\npublic:\n    int numEquivDominoPairs(vector<vector<int>>& dominoes) {\n        map<pair<int, int>, int> m"
  },
  {
    "path": "cpp/1001-10000/1121-1130/Relative Sort Array.cpp",
    "chars": 715,
    "preview": "class Solution {\npublic:\n    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {\n        map<int, int>"
  },
  {
    "path": "cpp/1001-10000/1121-1130/Smallest Sufficient Team.cpp",
    "chars": 2602,
    "preview": "class Solution {\n    \n    vector<int> ans;\n    \n    map<string, vector<int>> skill_to_ppl;\n    \n    bool dfs(int need_sk"
  },
  {
    "path": "cpp/1001-10000/1131-1140/N-th Tribonacci Number.cpp",
    "chars": 298,
    "preview": "class Solution {\npublic:\n    int tribonacci(int n) {\n        int dp[50] = {0};\n        dp[1] = 1;\n        dp[2] = 1;\n   "
  },
  {
    "path": "cpp/1001-10000/1141-1150/Binary Tree Coloring Game.cpp",
    "chars": 797,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/1001-10000/1141-1150/Decrease Elements To Make Array Zigzag.cpp",
    "chars": 680,
    "preview": "class Solution {\npublic:\n    int movesToMakeZigzag(vector<int>& nums) {\n        int temp1 = 0;\n        for (int i = 1; i"
  },
  {
    "path": "cpp/1001-10000/1141-1150/Longest Chunked Palindrome Decomposition.cpp",
    "chars": 765,
    "preview": "class Solution {\npublic:\n    int longestDecomposition(string text) {\n        if (text.length() <= 1) return text.length("
  },
  {
    "path": "cpp/1001-10000/1141-1150/Longest Common Subsequence.cpp",
    "chars": 575,
    "preview": "class Solution {\npublic:\n    int longestCommonSubsequence(string text1, string text2) {\n        int m = text1.length();\n"
  },
  {
    "path": "cpp/1001-10000/1141-1150/Snapshot Array.cpp",
    "chars": 967,
    "preview": "class SnapshotArray {\n    map<pair<int, int>, int> mymap_;\n    int snapshot_id_;\n    map<int, vector<int>> index_to_snap"
  },
  {
    "path": "cpp/1001-10000/1151-1160/Day of the Year.cpp",
    "chars": 410,
    "preview": "class Solution {\npublic:\n    int dayOfYear(string date) {\n        vector<int> daysOfMonth{31, 28, 31, 30, 31, 30, 31, 31"
  },
  {
    "path": "cpp/1001-10000/1151-1160/Find Words That Can Be Formed by Characters.cpp",
    "chars": 666,
    "preview": "class Solution {\npublic:\n    int countCharacters(vector<string>& words, string chars) {\n        map<char, int> mymap;\n  "
  },
  {
    "path": "cpp/1001-10000/1151-1160/Number of Dice Rolls With Target Sum.cpp",
    "chars": 557,
    "preview": "class Solution {\n    unordered_map<int, long> cache;\npublic:\n    int numRollsToTarget(int d, int f, int target) {\n      "
  },
  {
    "path": "cpp/1001-10000/1161-1170/As Far from Land as Possible.cpp",
    "chars": 1492,
    "preview": "class Solution {\npublic:\n    int maxDistance(vector<vector<int>>& grid) {\n        queue<pair<int, int>> myqueue;\n       "
  },
  {
    "path": "cpp/1001-10000/1161-1170/Compare Strings by Frequency of the Smallest Character.cpp",
    "chars": 764,
    "preview": "class Solution {\n    \n    int getF(const string& word) {\n        char ch = word[0];\n        for (int i = 1; i < word.siz"
  },
  {
    "path": "cpp/1001-10000/1161-1170/Design File System.cpp",
    "chars": 736,
    "preview": "class FileSystem {\n    map<string, int> mymap;\npublic:\n    FileSystem() {\n        mymap[\"\"] = 0;\n    }\n    \n    bool cre"
  },
  {
    "path": "cpp/1001-10000/1161-1170/Invalid Transactions.cpp",
    "chars": 1278,
    "preview": "class Solution {\n    \n    vector<string> split(const string &s, char delim) {\n        vector<string> elems;\n        stri"
  },
  {
    "path": "cpp/1001-10000/1161-1170/Maximum Level Sum of a Binary Tree.cpp",
    "chars": 780,
    "preview": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *r"
  },
  {
    "path": "cpp/1001-10000/1161-1170/Minimum Cost to Connect Sticks.cpp",
    "chars": 476,
    "preview": "class Solution {\npublic:\n    int connectSticks(vector<int>& sticks) {\n        priority_queue<int, vector<int>, std::grea"
  },
  {
    "path": "cpp/1001-10000/1161-1170/Optimize Water Distribution in a Village.cpp",
    "chars": 1571,
    "preview": "class UF {\n    \nprivate:\n    vector<int> parent;\n    vector<int> rank;\n    int count;\n    int N;\n    \npublic:\n    \n    U"
  },
  {
    "path": "cpp/1001-10000/1161-1170/Single-Row Keyboard.cpp",
    "chars": 396,
    "preview": "class Solution {\npublic:\n    int calculateTime(string keyboard, string word) {\n        map<char, int> kmap;\n        for "
  },
  {
    "path": "cpp/1001-10000/1171-1180/Can Make Palindrome from Substring.cpp",
    "chars": 872,
    "preview": "class Solution {\npublic:\n    vector<bool> canMakePaliQueries(string s, vector<vector<int>>& queries) {\n        vector<ve"
  },
  {
    "path": "cpp/1001-10000/1171-1180/Count Substrings with Only One Distinct Letter.cpp",
    "chars": 347,
    "preview": "class Solution {\npublic:\n    int countLetters(string S) {\n        int i = 0;\n        int j = 0;\n        int ans = 0;\n   "
  },
  {
    "path": "cpp/1001-10000/1171-1180/Diet Plan Performance.cpp",
    "chars": 532,
    "preview": "class Solution {\npublic:\n    int dietPlanPerformance(vector<int>& calories, int k, int lower, int upper) {\n        int a"
  },
  {
    "path": "cpp/1001-10000/1171-1180/Dinner Plate Stacks.cpp",
    "chars": 1462,
    "preview": "class DinnerPlates {\n    \n    vector<stack<int>> v;\n    int capacity;\n    int bestindex;\n    \npublic:\n    DinnerPlates(i"
  },
  {
    "path": "cpp/1001-10000/1171-1180/Prime Arrangements.cpp",
    "chars": 748,
    "preview": "class Solution {\n    \n    bool isPrime(int k) {\n        if (k == 1) return false;\n        if (k <= 3) return true;\n     "
  },
  {
    "path": "cpp/1001-10000/1171-1180/Remove Zero Sum Consecutive Nodes from Linked List.cpp",
    "chars": 1020,
    "preview": "/**\n * Definition for singly-linked list.\n * struct ListNode {\n *     int val;\n *     ListNode *next;\n *     ListNode(in"
  },
  {
    "path": "cpp/1001-10000/1181-1190/Before and After Puzzle.cpp",
    "chars": 1679,
    "preview": "class Solution {\n    \n    string getfirst(string& s) {\n        size_t pos = s.find(' ');\n        if (pos == string::npos"
  },
  {
    "path": "cpp/1001-10000/1181-1190/Day of the Week.cpp",
    "chars": 527,
    "preview": "class Solution {\npublic:\n    string dayOfTheWeek(int day, int month, int year) {\n        vector<int> t {0, 3, 2, 5, 0, 3"
  }
]

// ... and 943 more files (download for full content)