├── .gitattributes ├── .gitignore ├── README.md ├── build.gradle ├── gradle └── wrapper │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── settings.gradle └── src ├── main └── java │ └── com │ └── idiotleon │ ├── App.java │ ├── bycompany │ ├── amazon │ │ └── ood │ │ │ └── first_unique_number_in_data_stream │ │ │ ├── SolutionApproach0DoublyLinkedList.java │ │ │ ├── followup │ │ │ └── SolutionApproach0DoublyLinkedList.java │ │ │ └── util │ │ │ └── Constants.java │ ├── facebook │ │ ├── array │ │ │ ├── leftmost │ │ │ │ └── util │ │ │ │ │ └── BinaryMatrix.java │ │ │ └── longest_arithmetic_progression │ │ │ │ └── SolutionApproach0DP2Dimen.java │ │ └── string │ │ │ └── first_index_of_anagram │ │ │ └── SolutionApproachSlidingWindow.java │ ├── google │ │ ├── array │ │ │ ├── is_error_threshold_met │ │ │ │ └── SolutionApproach0MonoDeque.java │ │ │ └── merge_interval_with_labels │ │ │ │ └── Solution.java │ │ ├── graph │ │ │ ├── how_many_blocks_turned_upside_down │ │ │ │ └── SolutionApproachDijkstrasAlgorithm.java │ │ │ ├── how_many_paths_from_top_to_bottom │ │ │ │ ├── SolutionApproach0BFS.java │ │ │ │ └── SolutionApproach0DFS.java │ │ │ └── itinerary_modification_cost │ │ │ │ ├── FalseApproachBFS.java │ │ │ │ └── FalseApproachDFS.java │ │ ├── string │ │ │ ├── parse_json │ │ │ │ └── SolutionApproach0Trie.java │ │ │ └── two_ptr │ │ │ │ └── SolutionSongAndLyric.java │ │ └── unsolved │ │ │ └── logger.txt │ └── others │ │ ├── array │ │ ├── black_jack │ │ │ ├── FakeCardApi.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ └── SolutionApproach0DP2Dimen2.java │ │ ├── coin_the_array │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0DFSWithTrie.java │ │ └── insert_tags_into_the_string │ │ │ └── SolutionApproach0SweepLine.java │ │ ├── matrix │ │ ├── hungry_rabbit │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── problem_description.txt │ │ └── most_connected_pixels │ │ │ ├── Pixel.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0DFS1.java │ │ └── tree │ │ └── traverse_binary_tree_with_parent_pointer │ │ └── Solution.java │ ├── leetcode │ ├── bash │ │ └── problem_list.txt │ ├── explore │ │ └── challenge30days │ │ │ ├── first_unique_number │ │ │ └── SolutionApproachDLinkedList.java │ │ │ └── valid_sequence_from_root_to_leaves │ │ │ └── SolutionApproachDFS.java │ ├── interativeprogram │ │ └── lvl2 │ │ │ ├── FakeBinaryMatrix.java │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── SolutionApproach1BinarySearch.java │ ├── lvl1 │ │ ├── lc0020 │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0027 │ │ │ └── Solution.java │ │ ├── lc0058 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── SolutionApproach1LastIndexOf.java │ │ ├── lc0062 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── SolutionApproach0DP2Dimen.java │ │ ├── lc0066 │ │ │ └── Solution.java │ │ ├── lc0067 │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ └── SolutionApproach0TwoPointers1.java │ │ ├── lc0070 │ │ │ └── SolutionApproach0DP1Dimen.java │ │ ├── lc0088 │ │ │ ├── SolutionApproach0ThreePointers.java │ │ │ └── SolutionApproach0ThreePointers1.java │ │ ├── lc0125 │ │ │ └── SolutionApproach0HighLowPointers.java │ │ ├── lc0172 │ │ │ └── Solution.java │ │ ├── lc0189 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── similar_problems.txt │ │ ├── lc0191 │ │ │ └── SolutionApproachBitManipulation.java │ │ ├── lc0204 │ │ │ ├── SolutionApproach0DP.java │ │ │ └── SolutionApproach0DP1.java │ │ ├── lc0258 │ │ │ ├── SolutionApproach0Math.java │ │ │ ├── SolutionApproach1DFSRecursivel.java │ │ │ └── SolutionApproach1Iteration.java │ │ ├── lc0326 │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc0345 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0346 │ │ │ └── SolutionApproach0Queue.java │ │ ├── lc0349 │ │ │ ├── SolutionApproach0Set.java │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ └── SolutionApproach1BinarySearch.java │ │ ├── lc0383 │ │ │ └── Solution.java │ │ ├── lc0389 │ │ │ ├── SolutionApproach0BitXOR.java │ │ │ ├── SolutionApproach0BitXOR1.java │ │ │ └── SolutionApproach0FreqsArray.java │ │ ├── lc0415 │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ └── followup │ │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0455 │ │ │ ├── SolutionApproach0TwoPointers0.java │ │ │ └── SolutionApproach0TwoPointers1.java │ │ ├── lc0509 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP0D.java │ │ │ ├── SolutionApproach0DP1D.java │ │ │ └── SolutionApproach1DFSNaive.java │ │ ├── lc0520 │ │ │ └── SolutionApproach0ParsingString.java │ │ ├── lc0559 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0643 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── SolutionApproach0SlidingWindow1.java │ │ ├── lc0671 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0700 │ │ │ ├── SolutionApproach0Iteration.java │ │ │ ├── SolutionApproach0Recursion.java │ │ │ └── similar_problems.txt │ │ ├── lc0766 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── followup │ │ │ │ ├── followup1 │ │ │ │ │ └── Solution.java │ │ │ │ └── followup2 │ │ │ │ │ └── Solution.java │ │ │ └── similar_problems.txt │ │ ├── lc0771 │ │ │ ├── SolutionApproachDictArr.java │ │ │ ├── SolutionApproachDictSet.java │ │ │ └── SolutionApproachTwoPtrs.java │ │ ├── lc0819 │ │ │ └── SolutionApproach0HashMap.java │ │ ├── lc0830 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0872 │ │ │ ├── SolutionApproach0PostorderIterative.java │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc0884 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ └── SolutionApproach0HashSet.java │ │ ├── lc0905 │ │ │ ├── SolutionApproachHighLowPointers.java │ │ │ ├── SolutionApproachHighLowPointers1.java │ │ │ ├── SolutionApproachHighLowPointers2.java │ │ │ └── similar_problems.txt │ │ ├── lc0965 │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc0977 │ │ │ ├── SolutionApproach0HighLowPointers.java │ │ │ └── SolutionApproach0HighLowPointers1.java │ │ ├── lc0997 │ │ │ └── Solution.java │ │ ├── lc1009 │ │ │ ├── SolutionApproach0BitManipulation.java │ │ │ ├── SolutionApproach0BitManipulation1.java │ │ │ └── SolutionApproach0BitManipulation2.java │ │ ├── lc1046 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc1119 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc1161 │ │ │ ├── SolutionApprioach0DFS.java │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc1165 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc1290 │ │ │ ├── SolutionApproach0OnePass.java │ │ │ └── SolutionApproach0OnePass1.java │ │ ├── lc1470 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc1598 │ │ │ └── SolutionApproach0Stack.java │ │ └── lc1614 │ │ │ └── SolutionApproach0Stack.java │ ├── lvl2 │ │ ├── lc0001 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ ├── SolutionApproach1TwoPointers.java │ │ │ └── similar_problems.txt │ │ ├── lc0002 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0003 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ ├── SolutionApproach0SlidingWindow1.java │ │ │ └── followup │ │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ │ └── SolutionApproach0SlidingWindow1.java │ │ ├── lc0017 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ └── SolutionApproach0Backtrack2.java │ │ ├── lc0022 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ ├── SolutionApproach1DFSMemo.java │ │ │ └── SolutionApproach1DP1Dimen.java │ │ ├── lc0026 │ │ │ ├── SolutionApproach0HighLowPointers.java │ │ │ └── SolutionApproach0HighLowPointers1.java │ │ ├── lc0028 │ │ │ ├── SolutionApproach0KMPAlgorithm.java │ │ │ ├── SolutionApproach1TwoPointers.java │ │ │ ├── SolutionApproach1TwoPointers1.java │ │ │ ├── SolutionApproach2ThreePointers.java │ │ │ └── similar_problems.txt │ │ ├── lc0035 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach0BinarySearch1.java │ │ ├── lc0038 │ │ │ └── SolutionApproach0ParsingString.java │ │ ├── lc0053 │ │ │ ├── SolutionApproach0KadanesAlgorithm.java │ │ │ ├── SolutionApproach0KadanesAlgorithm1.java │ │ │ ├── SolutionApproach0KadanesAlgorithm2.java │ │ │ ├── SolutionApproach0KadanesAlgorithm3.java │ │ │ ├── SolutionApproach0KadanesAlgorithm4.java │ │ │ ├── SolutionApproach1DivideAndConquer.java │ │ │ ├── followups │ │ │ │ ├── followup0 │ │ │ │ │ ├── SolutionApproach0KadanesAlgorithm.java │ │ │ │ │ └── SolutionApproach0KadanesAlgorithm1.java │ │ │ │ ├── followup1 │ │ │ │ │ └── SolutionApproach0KadanesAlgorithm.java │ │ │ │ └── followup2 │ │ │ │ │ └── SolutionApproach0DivideAndConquer.java │ │ │ └── similar_problems.txt │ │ ├── lc0063 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── SolutionApproach0DP2Dimen.java │ │ ├── lc0064 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── SolutionApproach0DP2Dimen.java │ │ ├── lc0074 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach1BinarySearch.java │ │ ├── lc0077 │ │ │ └── SolutionApproach0Backtrack.java │ │ ├── lc0078 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ ├── bit_masking │ │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ │ └── SolutionApproach0Backtrack1.java │ │ │ └── similar_problems.txt │ │ ├── lc0082 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0083 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0090 │ │ │ ├── SolutionApproach0BacktrackRecursive.java │ │ │ ├── SolutionApproach0BacktrackRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0094 │ │ │ ├── SolutionApproach0InorderIterative.java │ │ │ ├── SolutionApproach0InorderIterative1.java │ │ │ ├── SolutionApproach0MorrisInorderTraversal.java │ │ │ └── SolutionApproach1DFSRecursively.java │ │ ├── lc0100 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ └── SolutionApproach0PreorderRecursive1.java │ │ ├── lc0102 │ │ │ ├── SolutionApproach0BFS0.java │ │ │ └── SolutionApproach0BFS1.java │ │ ├── lc0104 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ └── SolutionApproach0PreorderRecursive.java │ │ ├── lc0107 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc0110 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ └── SolutionApproach0PostorderRecursive1.java │ │ ├── lc0111 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach0PostorderRecursive1.java │ │ │ ├── SolutionApproach0PostorderRecursive2.java │ │ │ ├── SolutionApproach0PostorderRecursive3.java │ │ │ ├── SolutionApproach0PostorderRecursive4.java │ │ │ ├── SolutionApproach0PostorderRecursive5.java │ │ │ ├── SolutionApproach0PostorderRecursive6.java │ │ │ ├── SolutionApproach0PostorderRecursive7.java │ │ │ └── SolutionApproach0PreorderRecursive.java │ │ ├── lc0112 │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ ├── SolutionApproach0PreorderRecursive1.java │ │ │ ├── SolutionApproach1BFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0114 │ │ │ ├── SolutionApproach0DFSIterative.java │ │ │ ├── SolutionApproach0MorrisPreorderTraversal.java │ │ │ └── SolutionApproach1DFSRecursive.java │ │ ├── lc0118 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0122 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0136 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── similar_problems.txt │ │ ├── lc0157 │ │ │ ├── FakeReader4.java │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0LinearScan1.java │ │ │ └── similar_problems.txt │ │ ├── lc0160 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0165 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0168 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0Iteration.java │ │ │ └── similar_problems.txt │ │ ├── lc0171 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── similar_problems.txt │ │ ├── lc0198 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP0Dimen1.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach1DFSNaive.java │ │ │ └── similar_problems.txt │ │ ├── lc0199 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc0202 │ │ │ └── Solution.java │ │ ├── lc0203 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0205 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0LinearScan1.java │ │ │ ├── SolutionApproach0LinearScan2.java │ │ │ └── SolutionApproach0LinearScan3.java │ │ ├── lc0206 │ │ │ ├── SolutionApproach0DFSIterative.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── similar_problems.txt │ │ ├── lc0207 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0TopologicalSort.java │ │ │ ├── SolutionApproach0TopologicalSort1.java │ │ │ ├── SolutionApproach0TopologicalSort2.java │ │ │ └── similar_problems.txt │ │ ├── lc0209 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ ├── SolutionApproach0SlidingWindow1.java │ │ │ └── followups │ │ │ │ └── SolutionApproach0BinarySearchWithPrefixSums.java │ │ ├── lc0215 │ │ │ ├── SolutionApproach0QuickSelect.java │ │ │ ├── SolutionApproach1MinHeap.java │ │ │ ├── SolutionApproach2SortingArray.java │ │ │ └── similar_problems.txt │ │ ├── lc0226 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0231 │ │ │ ├── SolutionApproach0BitManipulation.java │ │ │ └── SolutionApproach1BinarySearch.java │ │ ├── lc0242 │ │ │ └── SolutionApproach0HashMap.java │ │ ├── lc0246 │ │ │ ├── SolutionApproach0HighLowPointers.java │ │ │ ├── SolutionApproach0HighLowPointers1.java │ │ │ ├── SolutionApproach0HighLowPointers2.java │ │ │ └── similar_problems.txt │ │ ├── lc0252 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ └── similar_problems.txt │ │ ├── lc0257 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── SolutionApproach0Backtrack1.java │ │ ├── lc0263 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0Iteration.java │ │ │ ├── SolutionApproach0Iteration1.java │ │ │ ├── SolutionApproach1DFSNaive.java │ │ │ └── similar_problems.txt │ │ ├── lc0274 │ │ │ ├── SolutionApproach0Sorting.java │ │ │ └── similar_problemx.txt │ │ ├── lc0278 │ │ │ ├── FakeVersionControl.java │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0280 │ │ │ ├── SolutionApproach0Sorting.java │ │ │ ├── SolutionApproach0Sorting1.java │ │ │ └── similar_problems.txt │ │ ├── lc0283 │ │ │ ├── SolutionApproach0HighLowPointers.java │ │ │ ├── SolutionApproach0HighLowPointers1.java │ │ │ ├── SolutionApproach0HighLowPointers2.java │ │ │ └── similar_problems.txt │ │ ├── lc0290 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ ├── SolutionApproach0HashMap1.java │ │ │ └── SolutionApproach0HashMap2.java │ │ ├── lc0299 │ │ │ └── SolutionApproach0LiearScan.java │ │ ├── lc0303 │ │ │ └── SolutionApproach0PrefixSums.java │ │ ├── lc0310 │ │ │ ├── SolutionApproach0TopologicalSort0.java │ │ │ ├── SolutionApproach0TopologicalSort1.java │ │ │ ├── SolutionApproach0TopologicalSort2.java │ │ │ └── similar_problems.txt │ │ ├── lc0328 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── SolutionApproach0LinearScan1.java │ │ ├── lc0347 │ │ │ └── SolutionApproach0MinHeap.java │ │ ├── lc0361 │ │ │ ├── SolutionApproach0DP.java │ │ │ └── SolutionApproach0Scan.java │ │ ├── lc0366 │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc0369 │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0371 │ │ │ ├── SolutionApproach0BitManipulation.java │ │ │ └── SolutionApproach0BitManipulation1.java │ │ ├── lc0374 │ │ │ ├── FakeGuessGame.java │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0392 │ │ │ ├── SolutionApproach0TwoPtrs.java │ │ │ ├── SolutionApproach1TwoPtrs.java │ │ │ └── followup │ │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0404 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFSIterative.java │ │ │ ├── SolutionApproach0DFSRecurisve.java │ │ │ ├── SolutionApproach0DFSRecurisve1.java │ │ │ ├── SolutionApproach0DFSRecursive3.java │ │ │ └── similar_problems.txt │ │ ├── lc0405 │ │ │ └── SolutionApproach0Math.java │ │ ├── lc0408 │ │ │ └── Solution0TwoPointers.java │ │ ├── lc0409 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0LinearScan1.java │ │ │ ├── SolutionApproach0LinearScan2.java │ │ │ ├── SolutionApproach0LinearScan3.java │ │ │ └── SolutionApproach0LinearScan4.java │ │ ├── lc0413 │ │ │ └── SolutionApproachDP.java │ │ ├── lc0429 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc0433 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0438 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── SolutionApproach0SlidingWindow1.java │ │ ├── lc0441 │ │ │ └── SolutionApproach0Math.java │ │ ├── lc0443 │ │ │ └── SolutionApproach0HighLowPointers.java │ │ ├── lc0451 │ │ │ ├── SolutionAppraoch0PriorityQueue.java │ │ │ ├── SolutionApproach0BucketSort.java │ │ │ └── SolutionApproach0Sorting.java │ │ ├── lc0461 │ │ │ └── SolutionApproach0BitManipulation.java │ │ ├── lc0463 │ │ │ ├── SolutionApproach0Geometry.java │ │ │ ├── SolutionApproach1DFSNaive.java │ │ │ └── similar_problems.txt │ │ ├── lc0475 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach0TwoPtrs.java │ │ │ └── SolutionApproach1TreeSet.java │ │ ├── lc0485 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0495 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0496 │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach0MonoStack1.java │ │ │ └── similar_problems.txt │ │ ├── lc0501 │ │ │ ├── SolutionApproach0InorderRecursive.java │ │ │ └── SolutionApproach0InorderRecursive1.java │ │ ├── lc0561 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ ├── SolutionApproach0HashMap1.java │ │ │ └── SolutionApproach1Sort.java │ │ ├── lc0563 │ │ │ └── SolutionApproach0PostorderRecursive.java │ │ ├── lc0567 │ │ │ ├── SolutionApproach0RollingHash.java │ │ │ ├── SolutionApproach1TwoPointers.java │ │ │ └── similar_problems.txt │ │ ├── lc0589 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0PreorderIterative.java │ │ │ └── SolutionApproach0PreorderRecursive.java │ │ ├── lc0590 │ │ │ ├── SolutionApproach0PostorderIterative.java │ │ │ └── SolutionApproach0PostorderRecursive.java │ │ ├── lc0605 │ │ │ └── SolutionApproach0Math.java │ │ ├── lc0606 │ │ │ ├── SolutionApproach0InorderRecursive.java │ │ │ ├── SolutionApproach0InorderRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0617 │ │ │ ├── SolutionAppraoch0Recursion.java │ │ │ ├── SolutionApproach0Recursion1.java │ │ │ └── similar_problems.txt │ │ ├── lc0637 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach1DFS.java │ │ ├── lc0653 │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach1Inorder.java │ │ ├── lc0655 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0658 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0669 │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0Postorder.java │ │ ├── lc0674 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach1DP0Dimen.java │ │ │ ├── SolutionApproach1DP1Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0676 │ │ │ ├── SolutionApproach0TrieWithDFS.java │ │ │ └── SolutionApproach1Trie.java │ │ ├── lc0677 │ │ │ ├── SolutionApproach0Trie.java │ │ │ └── SolutionApproach1Trie.java │ │ ├── lc0690 │ │ │ ├── FakeEmployee.java │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc0692 │ │ │ └── SolutionApproach0MinHeap.java │ │ ├── lc0695 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFSRecursive0.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ ├── followups │ │ │ │ └── SolutionApproach0DFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0701 │ │ │ ├── SolutionApproach0Iteration.java │ │ │ ├── SolutionApproach0Recursion.java │ │ │ └── similar_problems.txt │ │ ├── lc0704 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0720 │ │ │ ├── SolutionApproach0DFSWithTrie.java │ │ │ └── SolutionApproach1Sorting.java │ │ ├── lc0724 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0744 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0767 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0Greedy1.java │ │ │ ├── SolutionApproach0Greedy2.java │ │ │ └── similar_problems.txt │ │ ├── lc0784 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc0791 │ │ │ ├── SolutionApproach0BucketSort.java │ │ │ └── followups │ │ │ │ ├── followup1 │ │ │ │ └── Solution.java │ │ │ │ ├── followup2 │ │ │ │ └── Solution.java │ │ │ │ └── followup3 │ │ │ │ └── Solution.java │ │ ├── lc0814 │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach0PostorderRecursive1.java │ │ │ └── SolutionApproach0PostorderRecursive2.java │ │ ├── lc0817 │ │ │ ├── SolutionApproach0Set.java │ │ │ └── SolutionApproach0Set1.java │ │ ├── lc0821 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0824 │ │ │ └── SolutionApproach0ParsingString.java │ │ ├── lc0826 │ │ │ ├── SolutionApproachBucketAndGreedy.java │ │ │ └── SolutionApproachSortingAndTwoPointers.java │ │ ├── lc0832 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── similar_problems.txt │ │ ├── lc0833 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ └── SolutionApproach1.java │ │ ├── lc0844 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0852 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0859 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0881 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0885 │ │ │ ├── SolutionApproach0Math.java │ │ │ └── SolutionApproach0Math1.java │ │ ├── lc0896 │ │ │ ├── SolutionApproach0OnePass.java │ │ │ └── SolutionApproach0OnePass1.java │ │ ├── lc0897 │ │ │ ├── SolutionApproach0InorderIterative.java │ │ │ ├── SolutionApproach0InorderRecursive.java │ │ │ └── SolutionApproach0MorrisInorder.java │ │ ├── lc0921 │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0925 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0951 │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0953 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── SolutionApproach0LinearScan1.java │ │ ├── lc0958 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0971 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ └── SolutionApproach0SimulateDFS.java │ │ ├── lc0973 │ │ │ ├── Solution0MaxHeap.java │ │ │ ├── Solution0QuickSelect.java │ │ │ ├── Solution1SortingArray.java │ │ │ └── similar_problems.txt │ │ ├── lc0976 │ │ │ ├── SolutionApproach0Geometry.java │ │ │ └── similar_problems.txt │ │ ├── lc0984 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0Greedy1.java │ │ │ └── SolutionApproach0Greedy2.java │ │ ├── lc0985 │ │ │ └── Solution.java │ │ ├── lc0988 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0989 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── SolutionApproach0LinearScan1.java │ │ ├── lc0993 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc0998 │ │ │ ├── SolutionApproach0Iteration.java │ │ │ ├── SolutionApproach0Recursion.java │ │ │ └── SolutionApproach0Recursion1.java │ │ ├── lc1021 │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc1022 │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc1026 │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach0PostorderRecursive1.java │ │ │ ├── SolutionApproach0PostorderRecusrive2.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ └── SolutionApproach1DFS.java │ │ ├── lc1029 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── SolutionApproach0Sorting.java │ │ ├── lc1041 │ │ │ └── SolutionApproach0Math.java │ │ ├── lc1047 │ │ │ ├── SolutionApproach0Stack.java │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ ├── SolutionApproach0TwoPointers1.java │ │ │ ├── SolutionApproach1Recursion.java │ │ │ └── followup │ │ │ │ └── SolutionApproach0Stacks.java │ │ ├── lc1052 │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc1071 │ │ │ ├── SolutionApproach0KMPAlgorithm.java │ │ │ ├── SolutionApproach1Iteration.java │ │ │ ├── SolutionApproach2Recursion.java │ │ │ └── similar_problems.txt │ │ ├── lc1094 │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ ├── SolutionApproach0SweepLine1.java │ │ │ ├── SolutionApproach0SweepLine2.java │ │ │ ├── SolutionApproach0SweepLine3.java │ │ │ ├── SolutionApproach0SweepLine4.java │ │ │ └── similar_problems.txt │ │ ├── lc1100 │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc1103 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0LinearScan1.java │ │ │ └── SolutionApproach0LinearScan2.java │ │ ├── lc1110 │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc1120 │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ └── SolutionApproach0PostorderRecursive1.java │ │ ├── lc1145 │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc1151 │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc1167 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc1176 │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc1180 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc1182 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc1190 │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc1214 │ │ │ ├── SolutionApproach0Stacks.java │ │ │ ├── SolutionApproach1Set.java │ │ │ └── SolutionApproach2DFSNaively.java │ │ ├── lc1232 │ │ │ └── SolutionApproach0Math.java │ │ ├── lc1287 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach1SlidingWindow.java │ │ ├── lc1302 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc1305 │ │ │ ├── SolutionApproach0ControlledInorderIterative.java │ │ │ ├── SolutionApproach1MergeSort.java │ │ │ ├── SolutionApproach2Sorting.java │ │ │ ├── followup │ │ │ │ └── Solution.java │ │ │ └── similar_problems.txt │ │ ├── lc1315 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ ├── SolutionApproach0DFS2.java │ │ │ └── SolutionApproachDFS.java │ │ ├── lc1325 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc1344 │ │ │ └── SolutionAppraoch0Math.java │ │ ├── lc1365 │ │ │ └── SolutionApproach0BucketSort.java │ │ ├── lc1375 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ └── similar_problems.txt │ │ ├── lc1376 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc1379 │ │ │ ├── SolutionApproach0DFSIterative.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ ├── SolutionApproach1BFS.java │ │ │ └── followup │ │ │ │ └── Solution.java │ │ ├── lc1430 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0PreorderIterative.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc1456 │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc1460 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc1464 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc1465 │ │ │ └── SolutionApproach0OnePass.java │ │ ├── lc1469 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0PreorderIterative.java │ │ │ ├── SolutionApproach0PreorderIterative1.java │ │ │ └── SolutionApproach0PreorderRecursive.java │ │ ├── lc1471 │ │ │ ├── SolutionApporach0SortingWithTwoPointers.java │ │ │ └── SolutionApproach1SortingOnly.java │ │ ├── lc1474 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc1490 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFSIterative.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── SolutionApproach0DFSRecursive1.java │ │ ├── lc1513 │ │ │ └── SolutionApproach0Math.java │ │ ├── lc1578 │ │ │ └── SolutionApproach0LiearScan.java │ │ ├── lc1602 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0MorrisPreorder.java │ │ │ └── SolutionApproach0PreorderRecursive.java │ │ ├── lc1609 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc1618 │ │ │ ├── FakeFontInfo.java │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach0BinarySearch1.java │ │ ├── lc1644 │ │ │ └── SolutionApproach0PostorderRecursive.java │ │ └── lc1666 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0DFSRecurisve.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ └── SolutionApproach0Iterative.java │ ├── lvl3 │ │ ├── all_problems.txt │ │ ├── lc0005 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0ExpandPalindrome.java │ │ │ ├── SolutionApproach0ExpandPalindrome1.java │ │ │ └── SolutionApproach0ExpandPalindrome2.java │ │ ├── lc0011 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0015 │ │ │ ├── SolutionApproach0ThreePointers.java │ │ │ ├── followup │ │ │ │ └── Solution.java │ │ │ └── similar_problems.txt │ │ ├── lc0016 │ │ │ ├── SolutionApproach0ThreePointers.java │ │ │ └── similar_problems.txt │ │ ├── lc0029 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach1BitManipulation.java │ │ │ └── SolutionApproach1DFS.java │ │ ├── lc0033 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach1BinarySearch.java │ │ ├── lc0034 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach0BinarySearch1.java │ │ │ └── SolutionApproach1BinarySearch.java │ │ ├── lc0036 │ │ │ ├── SolutionApproach0Set.java │ │ │ ├── SolutionApproach0Set1.java │ │ │ └── SolutionApproach0Set2.java │ │ ├── lc0039 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── similar_problems.txt │ │ ├── lc0040 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── similar_problems.txt │ │ ├── lc0046 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ ├── SolutionApproach0Backtrack2.java │ │ │ └── similar_problems.txt │ │ ├── lc0047 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── similar_problems.txt │ │ ├── lc0048 │ │ │ ├── SolutionApproach0MatrixManipulation.java │ │ │ ├── SolutionApproach0MatrixManipulation1.java │ │ │ ├── followups │ │ │ │ └── SolutionApproach0MatrixManipulation.java │ │ │ └── similar_problems.txt │ │ ├── lc0049 │ │ │ └── SolutionApproach0HashMap.java │ │ ├── lc0050 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach1DFS.java │ │ │ └── SolutionApproach2DFS.java │ │ ├── lc0054 │ │ │ ├── SolutionApproach0MatrixManipulation0.java │ │ │ └── SolutionApproach0MatrixManipulation1.java │ │ ├── lc0055 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ └── similar_problems.txt │ │ ├── lc0056 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── followup │ │ │ │ └── Solution.java │ │ │ └── similar_problems.txt │ │ ├── lc0060 │ │ │ ├── SolutionApproach0Math.java │ │ │ └── similar_problems.txt │ │ ├── lc0061 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── SolutionApproach1TwoPointers.java │ │ ├── lc0064 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0069 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0071 │ │ │ ├── SolutionApproach0Deque.java │ │ │ └── SolutionApproach0Stack1.java │ │ ├── lc0073 │ │ │ └── SolutionApproach0MatrixManipulation.java │ │ ├── lc0075 │ │ │ ├── SolutionApproach0ThreePointers.java │ │ │ └── SolutionApproach0ThreePointers1.java │ │ ├── lc0080 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0086 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0091 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0092 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0LinearScan1.java │ │ │ ├── SolutionApproach0LinearScan2.java │ │ │ └── similar_problems.txt │ │ ├── lc0093 │ │ │ └── SolutionApproach0ParsingString.java │ │ ├── lc0095 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── SolutionApproach0Recursion.java │ │ ├── lc0096 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ └── SolutionApproach0DP1Dimen.java │ │ ├── lc0098 │ │ │ ├── SolutionApproach0InorderIterative.java │ │ │ ├── SolutionApproach0InorderIterative1.java │ │ │ ├── SolutionApproach0InorderRecursive.java │ │ │ ├── SolutionApproach0InorderRecursive1.java │ │ │ ├── SolutionApproach0MorrisInorder.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ └── SolutionApproach0PreorderRecursive1.java │ │ ├── lc0101 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0103 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0105 │ │ │ ├── SolutionApproach0DFSIterative.java │ │ │ ├── SolutionApproach0DFSIterative1.java │ │ │ ├── SolutionApproach0DFSIterative2.java │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc0106 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ ├── SolutionApproach0DFS2.java │ │ │ ├── SolutionApproach0DFSIterative.java │ │ │ └── SolutionApproach0DFSIterative1.java │ │ ├── lc0108 │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0109 │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0113 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ └── similar_problems.txt │ │ ├── lc0114 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ ├── SolutionApproach0MorrisInorderTraversal.java │ │ │ ├── SolutionApproach1DFSRecursive.java │ │ │ ├── SolutionApproach1Preorder.java │ │ │ └── similar_problems.txt │ │ ├── lc0116 │ │ │ ├── Node.java │ │ │ ├── Solution.java │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0Preorder.java │ │ │ ├── SolutionApproach0Preorder1.java │ │ │ └── similar_problems.txt │ │ ├── lc0117 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0119 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc0121 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP0Dimen1.java │ │ │ ├── followup │ │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ │ └── SolutionApproach0DP0Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc0129 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ └── SolutionApproach1DFSConstructingString.java │ │ ├── lc0130 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ └── similar_problems.txt │ │ ├── lc0131 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0133 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFSIterative.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0134 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0137 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ ├── SolutionApproach0HashSet.java │ │ │ ├── similar_problems.txt │ │ │ └── with_bit │ │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ │ └── SolutionApproach0LinearScan1.java │ │ ├── lc0141 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0144 │ │ │ ├── SolutionApproach0PreorderIteratively.java │ │ │ ├── SolutionApproach1PreorderRecursively.java │ │ │ └── followups │ │ │ │ ├── followup0 │ │ │ │ └── Solution.java │ │ │ │ └── followup1 │ │ │ │ └── Solution.java │ │ ├── lc0147 │ │ │ └── SolutionApproach0InsertionSort.java │ │ ├── lc0150 │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0151 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0152 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0153 │ │ │ ├── SolutionApproach0DivideAndConquer.java │ │ │ ├── SolutionApproach1BinarySearch.java │ │ │ ├── SolutionApproach1BinarySearch1.java │ │ │ └── similar_problems.txt │ │ ├── lc0156 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ └── SolutionApproach0Iteration.java │ │ ├── lc0162 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach0BinarySearchRecursive.java │ │ │ └── followup │ │ │ │ └── Solution.java │ │ ├── lc0163 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0167 │ │ │ └── SolutionApproach0HighLowPointers.java │ │ ├── lc0169 │ │ │ ├── SolutionApproach0BitManipulation.java │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0MooreVotingAlgorithm.java │ │ │ ├── SolutionApproach1DivideAndConquer.java │ │ │ └── SolutionApproach2Sorting.java │ │ ├── lc0186 │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ └── similar_problems.txt │ │ ├── lc0200 │ │ │ ├── Solution0Bfs.java │ │ │ ├── Solution0DfsRecursive.java │ │ │ ├── Solution0UnionFind.java │ │ │ └── similar_problems.txt │ │ ├── lc0207 │ │ │ ├── SolutionApproach0ColoringDFS.java │ │ │ ├── SolutionApproach0ColoringDFS1.java │ │ │ ├── SolutionApproach0TopologicalSortBFS.java │ │ │ ├── SolutionApproach0TopologicalSortBFS1.java │ │ │ ├── SolutionApproach0TopologicalSortDFS.java │ │ │ ├── SolutionApproach0TopologicalSortDFS1.java │ │ │ ├── SolutionApproach0TopologicalSortSimulatedDFS.java │ │ │ ├── SolutionApproach1DFS.java │ │ │ ├── SolutionApproach1DFS1.java │ │ │ └── SolutionApproach2DFSMemo.java │ │ ├── lc0209 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── followup │ │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0210 │ │ │ ├── SolutionApproach0TopologicalSimulatedSortDFS.java │ │ │ ├── SolutionApproach0TopologicalSortBFS.java │ │ │ ├── SolutionApproach0TopologicalSortBFS1.java │ │ │ ├── SolutionApproach0TopologicalSortBFS2.java │ │ │ ├── SolutionApproach0TopologicalSortDFS.java │ │ │ ├── followup │ │ │ │ └── SolutionApproach0TopologicalSortBFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0213 │ │ │ ├── SolutionApproach0DP0DImen1.java │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0216 │ │ │ └── SolutionApproach0Backtrack.java │ │ ├── lc0223 │ │ │ └── SolutionApproach0Geometry.java │ │ ├── lc0228 │ │ │ └── SolutionApproach0ParsingString.java │ │ ├── lc0229 │ │ │ └── SolutionApproach0BoyerMoorMajorityVoteAlgorithm.java │ │ ├── lc0234 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── SolutionApproach0Recursion.java │ │ ├── lc0235 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ ├── SolutionApproach0Iteration.java │ │ │ ├── followup │ │ │ │ └── followups.txt │ │ │ └── similar_problems.txt │ │ ├── lc0236 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ ├── SolutionApproach0DFSRecursive2.java │ │ │ ├── SolutionApproach0DFSRecursive3.java │ │ │ ├── SolutionApproach1BFS.java │ │ │ ├── SolutionApproach1DFS1.java │ │ │ ├── followups │ │ │ │ └── followups.txt │ │ │ └── similar_problems.txt │ │ ├── lc0238 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0247 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0Iteration.java │ │ │ └── similar_problems.txt │ │ ├── lc0253 │ │ │ ├── SolutionApproach0GreedyMinPQ.java │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ ├── followups │ │ │ │ └── followup0 │ │ │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ │ │ ├── SolutionApproach0SweepLine1.java │ │ │ │ │ └── problem_description.txt │ │ │ └── similar_problems.txt │ │ ├── lc0254 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── SolutionApproach0Backtrack1.java │ │ ├── lc0256 │ │ │ ├── SolutionAppraoch0DP0Dimen.java │ │ │ ├── SolutionApproach0DP0Dimen1.java │ │ │ ├── SolutionApproach0DP0Dimen2.java │ │ │ ├── SolutionApproach0DP0Dimen3.java │ │ │ ├── followup │ │ │ │ └── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0259 │ │ │ ├── SolutionApproach0ThreePointers.java │ │ │ └── similar_problems.txt │ │ ├── lc0260 │ │ │ ├── bit_manipulation │ │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ │ └── SolutionApproach0LinearScan1.java │ │ │ └── similar_problems.txt │ │ ├── lc0261 │ │ │ ├── Solution0DfsRecursive.java │ │ │ ├── Solution0TopologicalSort.java │ │ │ ├── Solution0TopologicalSort1.java │ │ │ └── Solution0UnionFind.java │ │ ├── lc0270 │ │ │ ├── SolutionApproach0BinarySearchIterative.java │ │ │ ├── SolutionApproach0BinarySearchIterative1.java │ │ │ ├── SolutionApproach0BinarySearchRecursive.java │ │ │ ├── SolutionApproach0InorderTraversalIterative.java │ │ │ ├── SolutionApproach0InorderTraversalIterative1.java │ │ │ └── SolutionApproach0InorderTravseralRecursive.java │ │ ├── lc0275 │ │ │ ├── SolutionApproach0BinarySeach.java │ │ │ └── similar_problemx.txt │ │ ├── lc0276 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP0Dimen1.java │ │ │ ├── SolutionApproach0DP0Dimen2.java │ │ │ ├── SolutionApproach0DP0Dimen3.java │ │ │ └── similar_problems.txt │ │ ├── lc0277 │ │ │ ├── FakeAPI.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0DFS1.java │ │ ├── lc0279 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ ├── SolutionApproach0DP.java │ │ │ ├── SolutionApproach0DP1.java │ │ │ └── SolutionApproach1DFSMemo.java │ │ ├── lc0285 │ │ │ ├── SolutionApproach0InorderIterative.java │ │ │ ├── SolutionApproach0InorderRecursive.java │ │ │ ├── SolutionApproach0InorderRecursive1.java │ │ │ ├── SolutionApproach0Iteration.java │ │ │ ├── SolutionApproach0MorrisInorder.java │ │ │ └── followups │ │ │ │ ├── followup1 │ │ │ │ ├── SolutionApproach0InorderRecursive.java │ │ │ │ ├── SolutionApproach0InorderRecursive1.java │ │ │ │ └── SolutionApproach0Iteration.java │ │ │ │ ├── followup2 │ │ │ │ └── Solution.java │ │ │ │ └── followup3 │ │ │ │ └── Solution.java │ │ ├── lc0286 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc0289 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── followups │ │ │ │ ├── followup0 │ │ │ │ │ └── Solution.java │ │ │ │ └── followup1 │ │ │ │ │ └── Solution.java │ │ │ └── withbitmask │ │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0300 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach4DFSNaive.java │ │ │ ├── followup │ │ │ │ ├── SolutionApproach0DPWithBinarySearch.java │ │ │ │ ├── SolutionApproach0DPWithBinarySearch1.java │ │ │ │ ├── SolutionApproach0DPWithBinarySearch2.java │ │ │ │ └── SolutionApproach1DPWithBinarySearch.java │ │ │ └── similar_problems.txt │ │ ├── lc0304 │ │ │ ├── SolutionApproach0PrefixSums.java │ │ │ └── SolutionApproach0PrefixSums1.java │ │ ├── lc0319 │ │ │ └── SolutionAppraoch0Math.java │ │ ├── lc0320 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ └── SolutionApproach0Backtrack2.java │ │ ├── lc0322 │ │ │ ├── SolutionApproach0DFSGreedyPruning.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0KnapsackComplete.java │ │ │ ├── SolutionApproach0KnapsackComplete1.java │ │ │ ├── SolutionApproach0KnapsackComplete2.java │ │ │ └── SolutionApproach1DP1Dimen1.java │ │ ├── lc0323 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0UnionFindOptimal.java │ │ │ ├── SolutionApproach1UnionFindNaively.java │ │ │ └── SolutionApproach1UnionFindWPathCompression.java │ │ ├── lc0325 │ │ │ └── SolutionApproach0PrefixSums.java │ │ ├── lc0331 │ │ │ ├── SolutionApproach0CountInOutDegrees.java │ │ │ ├── SolutionApproach0PreorderIterative.java │ │ │ ├── SolutionApproach0Stack.java │ │ │ └── SolutionApproach0Stack1.java │ │ ├── lc0332 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ ├── SolutionApproach0HierholzersAlgorithm.java │ │ │ └── SolutionApproach0HierholzersAlgorithm1.java │ │ ├── lc0333 │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach0PostorderRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0334 │ │ │ ├── SolutionApproach0DP1DimenWithBinarySearch.java │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0338 │ │ │ └── SolutionApproach0DP1Dimen.java │ │ ├── lc0339 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc0340 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ ├── SolutionApproach0SlidingWindow1.java │ │ │ └── followup │ │ │ │ ├── FakeCharAPI.java │ │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc0357 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ └── SolutionApproach0Math.java │ │ ├── lc0360 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0367 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach1BinarySearch.java │ │ ├── lc0376 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach0DP1Dimen2.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0377 │ │ │ ├── SolutionApproach0Knapsack.java │ │ │ ├── SolutionApproach1DFSMemo.java │ │ │ ├── SolutionApproach1DFSMemo1.java │ │ │ ├── SolutionApproach2DFS.java │ │ │ └── followup │ │ │ │ └── Solution.java │ │ ├── lc0378 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach0BinarySearch1.java │ │ │ ├── SolutionApproach0MaxHeap.java │ │ │ └── SolutionApproach1ZigZagSearch.java │ │ ├── lc0388 │ │ │ ├── SolutionApproach0ParsingString.java │ │ │ └── SolutionApproach0ParsingString1.java │ │ ├── lc0393 │ │ │ └── SolutionApproach0BitManipulation.java │ │ ├── lc0394 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0400 │ │ │ └── SolutionApproach0Math.java │ │ ├── lc0401 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ └── SolutionApproach0Backtrack2.java │ │ ├── lc0402 │ │ │ ├── SolutionApproach0Stack.java │ │ │ ├── SolutionApproach0Stack1.java │ │ │ └── SolutionApproach0Stack2.java │ │ ├── lc0406 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0416 │ │ │ ├── SolutionApproach0Knapsack.java │ │ │ ├── SolutionApproach0Knapsack1.java │ │ │ ├── SolutionApproach0Knapsack2.java │ │ │ └── similar_problems.txt │ │ ├── lc0419 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0424 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── SolutionApproach0SlidingWindow1.java │ │ ├── lc0430 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach0PreorderIterative.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ ├── SolutionApproach0PreorderRecursive1.java │ │ │ ├── SolutionApproach0Recursion.java │ │ │ └── similar_problems.txt │ │ ├── lc0435 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ └── similar_problems.txt │ │ ├── lc0436 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach0TreeMap.java │ │ ├── lc0437 │ │ │ ├── SolutionApproach0DFSWithPrefixSums.java │ │ │ ├── SolutionApproach1DFSNaively.java │ │ │ └── similar_problems.txt │ │ ├── lc0439 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0444 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0TopologicalSort.java │ │ │ ├── lc0459 │ │ │ │ ├── SolutionApproach0KMPAlogrithm.java │ │ │ │ └── similar_problems.txt │ │ │ └── similar_problems.txt │ │ ├── lc0445 │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0450 │ │ │ ├── SolutionApproach0Iteration.java │ │ │ ├── SolutionApproach0Recursion.java │ │ │ └── similar_problems.txt │ │ ├── lc0452 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ └── similar_problems.txt │ │ ├── lc0454 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ └── SolutionApproach1HashMap.java │ │ ├── lc0468 │ │ │ ├── SolutionApproach0.java │ │ │ └── SolutionApproach1.java │ │ ├── lc0470 │ │ │ ├── FakeRand7.java │ │ │ └── SolutionApproach0Math.java │ │ ├── lc0477 │ │ │ ├── SolutionApproach0BitManipulation.java │ │ │ ├── SolutionApproach0BitManipulation1.java │ │ │ └── SolutionApproach0BitManipulation2.java │ │ ├── lc0484 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ ├── SolutionApproach0TwoPointers1.java │ │ │ ├── SolutionApproach0TwoPointers2.java │ │ │ ├── SolutionApproach1MonoStack.java │ │ │ ├── SolutionApproach1MonoStack1.java │ │ │ └── similar_problems.txt │ │ ├── lc0487 │ │ │ ├── Solution0DP0Dimen.java │ │ │ ├── Solution0DP0Dimen1.java │ │ │ ├── Solution0DP1Dimen.java │ │ │ ├── Solution0DP2Dimen.java │ │ │ ├── Solution0SlidingWindow.java │ │ │ ├── Solution0SlidingWindow1.java │ │ │ ├── Solution0TwoPointers.java │ │ │ ├── followup │ │ │ │ └── Solution0SlidingWindow.java │ │ │ └── similar_problems.txt │ │ ├── lc0490 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0491 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── SolutionApproach0Backtrack1.java │ │ ├── lc0494 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0Knapsack.java │ │ │ ├── SolutionApproach0Knapsack1.java │ │ │ ├── SolutionApproach1DFSNaively.java │ │ │ ├── SolutionApproach1DFSNaively1.java │ │ │ └── similar_problems.txt │ │ ├── lc0497 │ │ │ └── SolutionApproach0TreeMap.java │ │ ├── lc0498 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── similar_problems.txt │ │ ├── lc0501 │ │ │ └── SolutionApproach0Postorder.java │ │ ├── lc0503 │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach0MonoStack1.java │ │ │ └── similar_problems.txt │ │ ├── lc0510 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0Iteration.java │ │ │ └── followup │ │ │ │ └── followup0 │ │ │ │ ├── Node.java │ │ │ │ ├── SolutionApproach0Iteration.java │ │ │ │ └── problem_description.txt │ │ ├── lc0513 │ │ │ ├── SolutionApproachBFS.java │ │ │ └── SolutionApproachPostOrder.java │ │ ├── lc0515 │ │ │ ├── SolutionApproachBFS.java │ │ │ └── SolutionApproachDFSTopDown.java │ │ ├── lc0518 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── SolutionApproach0DP2Dimen.java │ │ ├── lc0523 │ │ │ ├── SolutionApproach0PrefixSums.java │ │ │ ├── SolutionApproach0PrefixSums1.java │ │ │ ├── SolutionApproach0PrefixSums2.java │ │ │ ├── SolutionApproach0Set.java │ │ │ ├── SolutionApproach1PrefixSums.java │ │ │ ├── SolutionApproach1PrefixSums1.java │ │ │ └── similar_problems.txt │ │ ├── lc0524 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0525 │ │ │ └── SolutionApproachPreSum.java │ │ ├── lc0526 │ │ │ └── SolutionApproachMemorizedDFS.java │ │ ├── lc0530 │ │ │ ├── SolutionApproach0InorderIterative.java │ │ │ ├── SolutionApproach0InorderRecursive.java │ │ │ ├── SolutionApproach0MorrisInorder.java │ │ │ └── followup │ │ │ │ └── SolutionApproach0PreorderTreeSet.java │ │ ├── lc0531 │ │ │ └── Solution.java │ │ ├── lc0532 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0533 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ └── SolutionApproach0HashMap1.java │ │ ├── lc0536 │ │ │ ├── SolutionApproach0PreorderIterative.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc0542 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc0543 │ │ │ ├── Solution0PostorderRecursive.java │ │ │ ├── Solution0PostorderRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0547 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ └── SolutionApproach0UnionFind1.java │ │ ├── lc0548 │ │ │ └── SolutionApproach0PrefixSums.java │ │ ├── lc0560 │ │ │ ├── SolutionApproach0PrefixSums.java │ │ │ ├── SolutionApproach0PrefixSums1.java │ │ │ └── similar_problems.txt │ │ ├── lc0562 │ │ │ ├── SolutionApproachDP.java │ │ │ └── followup │ │ │ │ └── NotYetVerifiedSolutionApproachDP.java │ │ ├── lc0572 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0PreorderIterative.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ ├── SolutionApproach0PreorderRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0582 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc0583 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0593 │ │ │ └── SolutionApproach0Geometry.java │ │ ├── lc0609 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ └── followups │ │ │ │ └── Questions.java │ │ ├── lc0611 │ │ │ ├── SolutionApproach0ThreePointers.java │ │ │ ├── SolutionApproach0ThreePointers1.java │ │ │ └── similar_problems.txt │ │ ├── lc0623 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0DFS1.java │ │ ├── lc0624 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0628 │ │ │ └── SolutionApproachGreedy.java │ │ ├── lc0638 │ │ │ └── SolutionApproach0Backtrack.java │ │ ├── lc0640 │ │ │ └── Solution.java │ │ ├── lc0647 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0ExtendPalindrome.java │ │ │ └── similar_problems.txt │ │ ├── lc0648 │ │ │ └── SolutionApproachTrie.java │ │ ├── lc0652 │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach0PostorderRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0654 │ │ │ ├── SolutionApproach0Deque.java │ │ │ └── SolutionApproach0PreorderRecursive.java │ │ ├── lc0659 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0Greedy1.java │ │ │ ├── SolutionApproach0MinHeap.java │ │ │ └── SolutionApproach0MinHeap1.java │ │ ├── lc0662 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0663 │ │ │ └── SolutionApproach0PostorderRecursive.java │ │ ├── lc0666 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ ├── SolutionApproach0PreorderRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0670 │ │ │ ├── SolutionApproach0BucketSort1.java │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── similar_problems.txt │ │ ├── lc0678 │ │ │ └── Solution.java │ │ ├── lc0680 │ │ │ ├── SolutionApproach0HighLowPointers.java │ │ │ └── SolutionApproach0HighLowPointers1.java │ │ ├── lc0681 │ │ │ ├── SolutionApproach0TreeSet.java │ │ │ └── SolutionApproach1Sorting.java │ │ ├── lc0684 │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ ├── SolutionApproach0UnionFind1.java │ │ │ └── similar_problems.txt │ │ ├── lc0686 │ │ │ ├── SolutionApproach0KMPAlgorithm.java │ │ │ └── similar_problems.txt │ │ ├── lc0687 │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc0694 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ └── similar_problems.txt │ │ ├── lc0696 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── SolutionApproach0SlidingWindow1.java │ │ ├── lc0702 │ │ │ ├── FakeArrayReader.java │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0707 │ │ │ └── SolutionApproach0DoublyLinkedList.java │ │ ├── lc0708 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0OnePass.java │ │ │ └── SolutionApproach0OnePass1.java │ │ ├── lc0712 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0713 │ │ │ └── Solution0SlidingWindow.java │ │ ├── lc0714 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP0Dimen1.java │ │ │ ├── SolutionApproach0DP0Dimen2.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc0716 │ │ │ ├── SolutionApproach0DLinkedListWithTreeMap.java │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0718 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── SolutionApproach0DP2Dimen.java │ │ ├── lc0721 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc0723 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0725 │ │ │ └── Solution.java │ │ ├── lc0732 │ │ │ ├── SolutionApproach02DimenArray.java │ │ │ ├── SolutionApproach0ArrayOfBSTs.java │ │ │ └── SolutionApproach0ArrayOfDLinkedLists.java │ │ ├── lc0733 │ │ │ ├── SolutionApproachBFS.java │ │ │ └── SolutionApproachDFS.java │ │ ├── lc0735 │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0737 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ ├── SolutionApproach0UnionFind1.java │ │ │ ├── followup │ │ │ │ └── SolutionApproach0UnionFind.java │ │ │ └── similar_problems.txt │ │ ├── lc0739 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ └── similar_problems.txt │ │ ├── lc0743 │ │ │ ├── SolutionApproach0DijkstrasSPF.java │ │ │ ├── SolutionApproach0DijkstrasSPF1.java │ │ │ ├── SolutionApproach1BellmanFord.java │ │ │ ├── SolutionApproach2FloydWarshall.java │ │ │ └── similar_problems.txt │ │ ├── lc0750 │ │ │ ├── SolutionApproach0DP.java │ │ │ ├── SolutionApproach0Geometry1.java │ │ │ └── followup │ │ │ │ └── Solution.java │ │ ├── lc0756 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0758 │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ └── similar_problems.txt │ │ ├── lc0763 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ └── similar_problems.txt │ │ ├── lc0764 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── SolutionApproach0DP2Dimen1.java │ │ ├── lc0775 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ └── SolutionApproach0Greedy1.java │ │ ├── lc0776 │ │ │ ├── SolutionApproach0Iteration.java │ │ │ ├── SolutionApproach0Recursion.java │ │ │ ├── SolutionApproach0Recursion1.java │ │ │ └── similar_problems.txt │ │ ├── lc0783 │ │ │ ├── SolutionApproach0InorderIterative.java │ │ │ ├── SolutionApproach0InorderRecursive.java │ │ │ ├── SolutionApproach0MorrisInorder.java │ │ │ └── followup │ │ │ │ └── SolutionApproach0PreorderTreeSet.java │ │ ├── lc0785 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ └── similar_problems.txt │ │ ├── lc0787 │ │ │ ├── SolutionApproach0DijkstrasSPF.java │ │ │ ├── SolutionApproach0DijkstrasSPF1.java │ │ │ └── similiar_problems.txt │ │ ├── lc0792 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach1.java │ │ │ └── SolutionApproach1Trie.java │ │ ├── lc0797 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0802 │ │ │ ├── Solution0DfsRecursive.java │ │ │ ├── Solution0DfsRecursive1.java │ │ │ ├── Solution0DfsRecursive2.java │ │ │ ├── Solution0DfsRecursive3.java │ │ │ ├── Solution0KahnsAlgorithm.java │ │ │ ├── Solution0KahnsAlgorithm1.java │ │ │ └── similar_problems.txt │ │ ├── lc0825 │ │ │ ├── SolutionApproach0SlidingSum.java │ │ │ └── SolutionApproach0SlidingSum1.java │ │ ├── lc0835 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0LinearScan1.java │ │ │ └── SolutionApproach1LinearScan.java │ │ ├── lc0838 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0840 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0841 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0SimulateRecursion.java │ │ ├── lc0842 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── SolutionApproach0Backtrack1.java │ │ ├── lc0845 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0846 │ │ │ ├── SolutionApproach0TreeMap.java │ │ │ ├── SolutionApproach0TreeMapWithDeque.java │ │ │ └── SolutionApproach1MinHeap.java │ │ ├── lc0851 │ │ │ ├── SolutionApproachDFSWithMemoization.java │ │ │ ├── SolutionApproachTSort.java │ │ │ └── similar_problems.txt │ │ ├── lc0856 │ │ │ ├── Solution0ApproachArray.java │ │ │ ├── Solution0ApproachStack.java │ │ │ └── withBit │ │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0865 │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach1DFSRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc0873 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ ├── SolutionApproach0DP2Dimen2.java │ │ │ └── similar_problems.txt │ │ ├── lc0875 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach0BinarySearch1.java │ │ ├── lc0886 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ ├── SolutionApproach0UnionFind1.java │ │ │ └── similar_problems.txt │ │ ├── lc0904 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ ├── SolutionApproach0SlidingWindow1.java │ │ │ └── similar_problems.txt │ │ ├── lc0909 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc0911 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0912 │ │ │ ├── SolutionApproach0QuickSort.java │ │ │ ├── SolutionAproach0MergeSortBottomUp.java │ │ │ └── SolutionAproach0MergeSortTopDown.java │ │ ├── lc0922 │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ ├── SolutionApproach0TwoPointers1.java │ │ │ └── similar_problems.txt │ │ ├── lc0923 │ │ │ ├── SolutionApproach0FreqsMap.java │ │ │ ├── SolutionApproach0Knapsack.java │ │ │ ├── SolutionApproach0ThreePointers.java │ │ │ └── SolutionApproach0ThreePointers1.java │ │ ├── lc0931 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0934 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0935 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DFSMemo1.java │ │ │ └── SolutionApproach0DP.java │ │ ├── lc0938 │ │ │ ├── SolutionApproach0DFSIterative.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── SolutionApproach0DFSRecursive1.java │ │ ├── lc0939 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ ├── SolutionApproach0Set.java │ │ │ ├── SolutionApproach0Set1.java │ │ │ └── SolutionApproach1TreeMap.java │ │ ├── lc0946 │ │ │ ├── SolutionApproach0Stack.java │ │ │ ├── SolutionApproach0Stack1.java │ │ │ └── SolutionApproach0Stack2.java │ │ ├── lc0948 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0949 │ │ │ ├── SolutionApproach0ParsingString.java │ │ │ └── SolutionApproach0ParsingString1.java │ │ ├── lc0957 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ └── SolutionApproach0HashMap.java │ │ ├── lc0962 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ ├── SolutionApproach1Sorting.java │ │ │ └── similar_problems.txt │ │ ├── lc0966 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ ├── SolutionApproach0HashMap1.java │ │ │ └── SolutionApproach0Trie.java │ │ ├── lc0967 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0DFS1.java │ │ ├── lc0969 │ │ │ ├── SolutionApproach0Sorting.java │ │ │ ├── SolutionApproach0Sorting1.java │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0974 │ │ │ ├── SolutionApproach0PrefixSums.java │ │ │ └── SolutionApproach0PrefixSums1.java │ │ ├── lc0978 │ │ │ ├── SolutionApproach0DP.java │ │ │ ├── SolutionApproach0DP1.java │ │ │ ├── SolutionApproach0DP2.java │ │ │ └── SolutionApproach0DP3.java │ │ ├── lc0981 │ │ │ └── SolutionApproach0TreeMap.java │ │ ├── lc0986 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0987 │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ ├── SolutionApproach0PreorderRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0990 │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc0994 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc1003 │ │ │ └── SolutionApproachStack.java │ │ ├── lc1004 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── SolutionApproach0SlidingWindow1.java │ │ ├── lc1019 │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach0MonoStack1.java │ │ │ └── similar_problems.txt │ │ ├── lc1020 │ │ │ ├── SolutionAppraoch1UnionFind.java │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1023 │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ ├── SolutionApproach1Trie.java │ │ │ └── SolutionApproach2Regex.java │ │ ├── lc1031 │ │ │ ├── SolutionApproach0KadanesAlgorithm.java │ │ │ ├── SolutionApproach0PrefixSums.java │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── similar_problems.txt │ │ ├── lc1033 │ │ │ ├── SolutionApproach0Math.java │ │ │ └── similar_problems.txt │ │ ├── lc1034 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1042 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc1048 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach1DFSMemo.java │ │ │ ├── SolutionApproach1DP.java │ │ │ └── similar_problems.txt │ │ ├── lc1053 │ │ │ ├── SolutionApproach0Math.java │ │ │ ├── SolutionApproach0Math1.java │ │ │ └── similar_problems.txt │ │ ├── lc1054 │ │ │ ├── SolutionApproach0.java │ │ │ ├── SolutionApproach0MaxHeap.java │ │ │ └── similar_problems.txt │ │ ├── lc1055 │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ └── followups │ │ │ │ ├── followup1 │ │ │ │ └── Solution.java │ │ │ │ ├── followup2 │ │ │ │ └── Solution.java │ │ │ │ ├── followup3 │ │ │ │ └── Solution.java │ │ │ │ └── followup4 │ │ │ │ └── Solution.java │ │ ├── lc1057 │ │ │ ├── SolutionApproach0BucketSort.java │ │ │ ├── SolutionApproach0BucketSort1.java │ │ │ └── SolutionApproach1MinHeap.java │ │ ├── lc1059 │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0TopologicalSort.java │ │ ├── lc1060 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc1061 │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ ├── SolutionApproach1BFS.java │ │ │ ├── SolutionApproach1DFS.java │ │ │ └── similar_problems.txt │ │ ├── lc1065 │ │ │ └── SolutionApproach0Trie.java │ │ ├── lc1079 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ ├── SolutionApproach0Backtrack2.java │ │ │ └── SolutionApproach1BacktrackNaively.java │ │ ├── lc1080 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc1087 │ │ │ └── SolutionApproach0Backtrack.java │ │ ├── lc1091 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0BFS1.java │ │ ├── lc1101 │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc1104 │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1109 │ │ │ ├── SolutionApproach0SegmentTree.java │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ └── similar_problems.txt │ │ ├── lc1111 │ │ │ ├── SolutionApproach0OnePass.java │ │ │ ├── SolutionApproach1OnePass.java │ │ │ └── SolutionApproach1OnePass1.java │ │ ├── lc1123 │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach0PostorderRecursive1.java │ │ │ ├── SolutionApproach1BFS.java │ │ │ └── similar_problems.txt │ │ ├── lc1129 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1138 │ │ │ └── SolutionApproach0ParsingString.java │ │ ├── lc1139 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ ├── SolutionApproach0DP3Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc1143 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2DimenSpaceOptimized.java │ │ │ └── similar_problems.txt │ │ ├── lc1146 │ │ │ ├── SolutionApproach0ListOfHashMaps.java │ │ │ └── SolutionApproach0ListOfTreeMaps.java │ │ ├── lc1155 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DFSMemo1.java │ │ │ ├── SolutionApproach0DFSMemo2.java │ │ │ ├── SolutionApproach0DP.java │ │ │ ├── SolutionApproach0DPMemoization.java │ │ │ └── SolutionApproachDPTabulation.java │ │ ├── lc1156 │ │ │ └── SolutionApproach0BucketSort.java │ │ ├── lc1162 │ │ │ └── SolutionApproachBFS.java │ │ ├── lc1171 │ │ │ ├── SolutionApproach0PrefixSums.java │ │ │ └── SolutionApproach0PrefixSums1.java │ │ ├── lc1197 │ │ │ ├── SolutionApproachBFS.java │ │ │ ├── SolutionApproachMemorizedDFS.java │ │ │ ├── SolutionApproachMemorizedDFS1.java │ │ │ └── SolutionApproachMemorizedDFS2.java │ │ ├── lc1198 │ │ │ ├── SolutionApproach0BrutalForce.java │ │ │ └── SolutionApproach1TreeMap.java │ │ ├── lc1201 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── similar_problems.txt │ │ ├── lc1208 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── SolutionApproach0SlidingWindow1.java │ │ ├── lc1209 │ │ │ └── SolutionApproachStack.java │ │ ├── lc1213 │ │ │ └── SolutionApproach0TreePointers.java │ │ ├── lc1215 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc1219 │ │ │ └── SolutionApproach0Backtrack.java │ │ ├── lc1229 │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ └── similar_problems.txt │ │ ├── lc1233 │ │ │ ├── SolutionApproach0Sorting.java │ │ │ ├── SolutionApproach0Sorting1.java │ │ │ └── SolutionApproach0Trie.java │ │ ├── lc1236 │ │ │ ├── FakeHtmlParser.java │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc1239 │ │ │ └── SolutionApproach0Backtrack1.java │ │ ├── lc1245 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ ├── SolutionApproach0DFS2.java │ │ │ ├── SolutionApproach0DFS3.java │ │ │ └── similar_problems.txt │ │ ├── lc1247 │ │ │ ├── SolutionApproach0Math.java │ │ │ └── SolutionApproach0Math1.java │ │ ├── lc1249 │ │ │ ├── SolutionApproach0Stack.java │ │ │ ├── SolutionApproach0Stack1.java │ │ │ └── followup │ │ │ │ └── SolutionApproach0Backtrack.java │ │ ├── lc1254 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ └── similar_problems.txt │ │ ├── lc1257 │ │ │ └── SolutionApproach0HashMap.java │ │ ├── lc1268 │ │ │ └── SolutionApproachTreeMap.java │ │ ├── lc1272 │ │ │ ├── Solution.java │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ ├── SolutionApproach0SweepLine1.java │ │ │ ├── followup │ │ │ │ └── followup1 │ │ │ │ │ └── Solution.java │ │ │ └── similar_problems.txt │ │ ├── lc1273 │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0Set.java │ │ ├── lc1275 │ │ │ ├── SolutionApproach0BrutalForce.java │ │ │ └── followup │ │ │ │ └── Solution.java │ │ ├── lc1277 │ │ │ └── SolutionApproach0DP2D.java │ │ ├── lc1283 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc1288 │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ └── similar_problems.txt │ │ ├── lc1291 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc1306 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── similar_problems.txt │ │ ├── lc1311 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc1319 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc1339 │ │ │ └── SolutionApproach0PostorderRecursive.java │ │ ├── lc1353 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0Greedy1.java │ │ │ ├── SolutionApproach0Greedy2.java │ │ │ ├── SolutionApproach0SegmentTree.java │ │ │ └── similar_problems.txt │ │ ├── lc1358 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── similar_problems.txt │ │ ├── lc1360 │ │ │ └── SolutionApproach0Since1971.java │ │ ├── lc1367 │ │ │ ├── SolutionApproach0KMPAlgorithm.java │ │ │ ├── SolutionApproach1DFSRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc1372 │ │ │ └── SolutionApproach0PreorderRecursive.java │ │ ├── lc1376 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1382 │ │ │ ├── SolutionApproach0DSWAlgorithm.java │ │ │ └── SolutionApproach0RecontructingBBST.java │ │ ├── lc1391 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach1UnionFind.java │ │ ├── lc1405 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ └── SolutionApproach0Greedy1.java │ │ ├── lc1415 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0Math.java │ │ ├── lc1424 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ ├── SolutionApproach0TreeMap.java │ │ │ └── similar_problems.txt │ │ ├── lc1443 │ │ │ └── SolutionApproachDFS.java │ │ ├── lc1448 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ └── SolutionApproach1BFS.java │ │ ├── lc1457 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ └── SolutionApproach0Preorder1.java │ │ ├── lc1466 │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1472 │ │ │ ├── SolutionApproach0ArrayList.java │ │ │ └── SolutionApproach0DoubleLinkedList.java │ │ ├── lc1485 │ │ │ ├── Node.java │ │ │ ├── NodeCopy.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ └── SolutionApproach0DFSMemo.java │ │ ├── lc1488 │ │ │ └── SolutionApproach0TreeSet.java │ │ ├── lc1498 │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ └── similar_problems.txt │ │ ├── lc1514 │ │ │ ├── SolutionApproach0DijkstrasSPF.java │ │ │ ├── SolutionApproach0DijkstrasSPF1.java │ │ │ └── similar_problems.txt │ │ ├── lc1519 │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1522 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc1530 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── similar_problems.txt │ │ ├── lc1535 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0Greedy1.java │ │ │ └── SolutionApproach1DLL.java │ │ ├── lc1541 │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc1577 │ │ │ ├── SolutionApproach0ThreePointers.java │ │ │ └── similar_problems.txt │ │ ├── lc1612 │ │ │ ├── Node.java │ │ │ └── SolutionApproach0PreorderRecursive.java │ │ ├── lc1616 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc1626 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── similar_problems.txt │ │ └── lc1660 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFSRecursive.java │ ├── lvl4 │ │ ├── all_problems.txt │ │ ├── lc0018 │ │ │ ├── Solution0FourPointers.java │ │ │ ├── Solution0FourPointers1.java │ │ │ ├── followup │ │ │ │ └── Solution.java │ │ │ └── similar_problems.txt │ │ ├── lc0023 │ │ │ ├── Solution0DivideAndConquer.java │ │ │ ├── Solution1MinHeap.java │ │ │ └── similar_problems.txt │ │ ├── lc0025 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0LinearScan1.java │ │ │ └── similar_problems.txt │ │ ├── lc0030 │ │ │ ├── SolutionApproach0HashMap.java │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc0031 │ │ │ ├── SolutionApproach0Math.java │ │ │ ├── followups │ │ │ │ └── SolutionApproach0Math.java │ │ │ └── similar_problems.txt │ │ ├── lc0041 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── SolutionApproach0LinearScan1.java │ │ ├── lc0042 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ ├── SolutionApproach0TwoPointers1.java │ │ │ ├── SolutionApproach0TwoPointers2.java │ │ │ ├── followup │ │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ │ ├── SolutionApproach1DP.java │ │ │ │ └── SolutionApproach1TwoPointers.java │ │ │ └── similar_problems.txt │ │ ├── lc0043 │ │ │ └── SolutionApproach0ParsingString.java │ │ ├── lc0044 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── SolutionApproach1DivideAndConquer.java │ │ ├── lc0045 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0Greedy.java │ │ │ └── similar_problems.txt │ │ ├── lc0051 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ └── similar_problems.txt │ │ ├── lc0057 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0059 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0065 │ │ │ └── SolutionApproach0ParsingString.java │ │ ├── lc0068 │ │ │ └── SolutionApproach0DP.java │ │ ├── lc0072 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── followups │ │ │ │ └── followup0 │ │ │ │ │ └── Solution.java │ │ │ └── similar_problems.txt │ │ ├── lc0076 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ ├── SolutionApproach0SlidingWindow1.java │ │ │ └── similar_problems.txt │ │ ├── lc0079 │ │ │ ├── Solution0Backtrack.java │ │ │ └── similar_problems.txt │ │ ├── lc0081 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach0BinarySearch1.java │ │ │ └── similar_problems.txt │ │ ├── lc0084 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach0MonoStack1.java │ │ │ ├── SolutionApproach0MonoStack2.java │ │ │ ├── SolutionApproach1DivideAndConquer.java │ │ │ ├── followup │ │ │ │ └── followup0 │ │ │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ │ │ └── problem_description.txt │ │ │ └── similar_problems.txt │ │ ├── lc0097 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DFSMemo1.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0115 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach1DFSMemo.java │ │ │ └── similar_problems.txt │ │ ├── lc0117 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFSWithoutQueue.java │ │ │ └── similar_problems.txt │ │ ├── lc0120 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc0124 │ │ │ ├── SolutionApproach0PostorderRecursive.java │ │ │ ├── SolutionApproach0PostorderRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0126 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ └── similar_problems.txt │ │ ├── lc0127 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ ├── SolutionApproach0BFS2.java │ │ │ ├── SolutionApproach0BFS3.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0128 │ │ │ ├── SolutionApproach0Set.java │ │ │ ├── SolutionApproach0Set1.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ └── similar_problems.txt │ │ ├── lc0135 │ │ │ └── SolutionApproach0DP1Dimen.java │ │ ├── lc0138 │ │ │ ├── Node.java │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach1DFSRecursive.java │ │ │ ├── SolutionApproach1DFSRecursive1.java │ │ │ ├── SolutionApproach1LinearScan.java │ │ │ ├── SolutionApproach1LinearScan1.java │ │ │ └── similar_problems.txt │ │ ├── lc0139 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFSWithTrie.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach0DP1Dimen2.java │ │ │ ├── SolutionApproach0DPWithTrie.java │ │ │ └── similar_problems.txt │ │ ├── lc0142 │ │ │ ├── SolutionApproach0SlowFastPointers.java │ │ │ └── SolutionApproach1HashMap.java │ │ ├── lc0143 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0145 │ │ │ ├── SolutionApproach0PostorderIterative.java │ │ │ ├── SolutionApproach1DFSIterative.java │ │ │ ├── SolutionApproach1DFSRecursive.java │ │ │ ├── SolutionApproach1DFSRecursive1.java │ │ │ ├── SolutionApproach1MorrisPostorderTraversal.java │ │ │ ├── SolutionApproach1ReversePreorderRecursive.java │ │ │ └── SolutionApproach1ReversingPreorderIterative.java │ │ ├── lc0148 │ │ │ └── SolutionApproach0MergeSort.java │ │ ├── lc0154 │ │ │ ├── SolutionApproach0DivideAndConquer.java │ │ │ ├── SolutionApproach1BinarySearch.java │ │ │ └── similar_problems.txt │ │ ├── lc0158 │ │ │ ├── FakeReader4.java │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ └── SolutionApproach0LinearScan1.java │ │ ├── lc0159 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ ├── SolutionApproach0SlidingWindow1.java │ │ │ ├── SolutionApproach0SlidingWindow2.java │ │ │ ├── SolutionApproach0SlidingWindow3.java │ │ │ └── similar_problems.txt │ │ ├── lc0161 │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ ├── SolutionApproach0TwoPointers1.java │ │ │ ├── SolutionApproach1DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0162 │ │ │ ├── SolutionApproachIterativeBinarySearch.java │ │ │ ├── SolutionApproachLinearScan.java │ │ │ └── SolutionApproachRecursiveBinarySearch.java │ │ ├── lc0174 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach1DFSTopDown.java │ │ │ └── SolutionApproach1DFSTopDown1.java │ │ ├── lc0179 │ │ │ ├── SolutionApproach0MaxHeap.java │ │ │ └── SolutionApproach0SortedArray.java │ │ ├── lc0187 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── SolutionApproach0TwoSets.java │ │ ├── lc0188 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc0200 │ │ │ ├── SolutionApproachBFS.java │ │ │ ├── SolutionApproachDFS.java │ │ │ └── SolutionApproachUnionFind.java │ │ ├── lc0201 │ │ │ └── Solution.java │ │ ├── lc0208 │ │ │ └── SolutionTrie.java │ │ ├── lc0210 │ │ │ ├── SolutionApproachBFS.java │ │ │ └── SolutionApproachTopologicalSort.java │ │ ├── lc0211 │ │ │ ├── SolutionApproach0TrieWithDFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0218 │ │ │ ├── SolutionApproach0BinaryIndexedTree.java │ │ │ ├── SolutionApproach0DivideAndConquer.java │ │ │ ├── SolutionApproach0SegmentTree.java │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ ├── SolutionApproach0SweepLine1.java │ │ │ └── similar_problems.txt │ │ ├── lc0220 │ │ │ └── Solution0ApproachTreeSet.java │ │ ├── lc0221 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc0222 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach0PreorderRecursive.java │ │ │ └── SolutionApproach0PreorderRecursive1.java │ │ ├── lc0227 │ │ │ ├── SolutionApproach0Stack.java │ │ │ └── SolutionApproach0Stack1.java │ │ ├── lc0230 │ │ │ ├── SolutionApproach0InorderIteration.java │ │ │ ├── SolutionApproach0InorderIteration1.java │ │ │ ├── SolutionApproach0InorderIteration2.java │ │ │ ├── SolutionApproach0InorderTraversal.java │ │ │ ├── SolutionApproach0MorrisInorderTraversal.java │ │ │ ├── SolutionApproach1BinarySearch.java │ │ │ └── follow_up │ │ │ │ └── Solution.java │ │ ├── lc0239 │ │ │ ├── SolutionApproach0MonoQueue.java │ │ │ ├── SolutionApproach1BST.java │ │ │ └── similar_problems.txt │ │ ├── lc0240 │ │ │ ├── SolutionApproachBinarySearch.java │ │ │ └── SolutionApproachOnePass.java │ │ ├── lc0248 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0DFSRecursive1.java │ │ │ └── similar_problems.txt │ │ ├── lc0249 │ │ │ └── SolutionApproach0LinearScan.java │ │ ├── lc0250 │ │ │ └── SolutionApproach0Postorder.java │ │ ├── lc0264 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach1TreeSet.java │ │ │ └── similar_problems.txt │ │ ├── lc0265 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ ├── SolutionApproach1DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0267 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── SolutionApproach0Backtrack1.java │ │ ├── lc0269 │ │ │ ├── SolutionApproach0TopologicalSort.java │ │ │ ├── SolutionApproach0TopologicalSort1.java │ │ │ ├── SolutionApproach0TopologicalSort2.java │ │ │ ├── SolutionApproach1DFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0287 │ │ │ ├── SolutionApproach0Guess.java │ │ │ ├── SolutionApproach0Guess1.java │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ └── SolutionApproach1OnePass.java │ │ ├── lc0294 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DFSMemo1.java │ │ │ └── SolutionApproach1DFSNaively.java │ │ ├── lc0295 │ │ │ ├── SolutionApproach0BalancedBST.java │ │ │ ├── SolutionApproach0Heaps.java │ │ │ ├── SolutionApproach0Heaps1.java │ │ │ ├── followups │ │ │ │ ├── FollowUp1.java │ │ │ │ └── FollowUp2.java │ │ │ └── similar_problems.txt │ │ ├── lc0296 │ │ │ ├── SolutionApproach0FindMedian.java │ │ │ └── SolutionApproach0FindMedian1.java │ │ ├── lc0298 │ │ │ ├── SolutionApproach0Preorder.java │ │ │ └── SolutionApproach0Preorder1.java │ │ ├── lc0302 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach0BinarySearch1.java │ │ ├── lc0305 │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ ├── SolutionApproach0UnionFind1.java │ │ │ ├── SolutionApproach0UnionFind2.java │ │ │ └── similar_problems.txt │ │ ├── lc0306 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ └── SolutionApproach0BrutalForce.java │ │ ├── lc0309 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP0Dimen1.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0311 │ │ │ └── SolutionApproach0Math.java │ │ ├── lc0312 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0313 │ │ │ ├── SolutionApproach0DP.java │ │ │ ├── SolutionApproach0DP1.java │ │ │ ├── SolutionApproach0MinHeap.java │ │ │ ├── SolutionApproach0MinHeap1.java │ │ │ └── similar_problems.txt │ │ ├── lc0314 │ │ │ ├── Solution0BFS.java │ │ │ ├── Solution0PreorderRecursive.java │ │ │ └── similar_problems.txt │ │ ├── lc0316 │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ └── similar_problems.txt │ │ ├── lc0317 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0321 │ │ │ └── SolutionApproachGreedyAndDP.java │ │ ├── lc0329 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DFSMemo1.java │ │ │ ├── SolutionApproach0DFSMemo2.java │ │ │ └── SolutionApproach1DP2Dimen.java │ │ ├── lc0337 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DFSMemo1.java │ │ │ ├── SolutionApproach1DFSNaive.java │ │ │ └── similar_problems.txt │ │ ├── lc0351 │ │ │ └── SolutionApproach0Backtrack.java │ │ ├── lc0353 │ │ │ ├── SolutionApproach0Deque.java │ │ │ └── SolutionApproach0LinkedList.java │ │ ├── lc0354 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── SolutionApproach0DP1DimenWithBinarySearch.java │ │ ├── lc0358 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0Greedy1.java │ │ │ └── similar_problems.txt │ │ ├── lc0368 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach1DFSMemo.java │ │ │ └── similar_problems.txt │ │ ├── lc0373 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach0MinHeap.java │ │ ├── lc0375 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0395 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ ├── SolutionApproach1DFSRecursive.java │ │ │ ├── SolutionApproach1DFSRecursive1.java │ │ │ ├── SolutionApproach1DFSRecursive2.java │ │ │ └── similar_problems.txt │ │ ├── lc0399 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ ├── SolutionApproach0UnionFind1.java │ │ │ └── SolutionApproach1FloydWarshall.java │ │ ├── lc0407 │ │ │ ├── SolutionApproach0DijkstrasSPF.java │ │ │ ├── SolutionApproach0DijkstrasSPF1.java │ │ │ └── similar_problems.txt │ │ ├── lc0410 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach0BinarySearch1.java │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc0421 │ │ │ ├── SolutionApproach0Trie.java │ │ │ └── SolutionApproach1Trie.java │ │ ├── lc0423 │ │ │ └── Solution.java │ │ ├── lc0428 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc0442 │ │ │ └── SolutionApproach0HashMap.java │ │ ├── lc0446 │ │ │ └── SolutionApproach0DP.java │ │ ├── lc0456 │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach0MonoStack1.java │ │ │ └── similar_problems.txt │ │ ├── lc0457 │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach1FloydCycle.java │ │ ├── lc0464 │ │ │ └── SolutionApproachDFSWithMemorization.java │ │ ├── lc0467 │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc0474 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0Knapsack.java │ │ │ ├── SolutionApproach0Knapsack1.java │ │ │ ├── SolutionApproach0Knapsack2.java │ │ │ └── similar_problems.txt │ │ ├── lc0478 │ │ │ └── SolutionApproach0PolarCoordinate.java │ │ ├── lc0489 │ │ │ ├── FakeRobot.java │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── SolutionApproach0Backtrack1.java │ │ ├── lc0502 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0505 │ │ │ ├── SolutionApproach0DijkstrasSPF.java │ │ │ ├── SolutionApproach0DijkstrasSPF1.java │ │ │ ├── SolutionApproach0DijkstrasSPF2.java │ │ │ ├── SolutionApproach1BFS.java │ │ │ ├── SolutionApproach1DFS.java │ │ │ ├── SolutionApproach1DjikstrasAlgorithm.java │ │ │ └── similar_problems.txt │ │ ├── lc0516 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ ├── SolutionApproach0DP2Dimen2.java │ │ │ └── similar_problems.txt │ │ ├── lc0529 │ │ │ ├── SolutionApproachBFS.java │ │ │ ├── SolutionApproachBFS1.java │ │ │ └── SolutionApproachDFS.java │ │ ├── lc0538 │ │ │ ├── SolutionApproach0ReversedInorderTraversal.java │ │ │ ├── SolutionApproach0ReversedInorderTraversal1.java │ │ │ ├── SolutionApproach0ReversedInorderTraversal2.java │ │ │ ├── SolutionApproach0ReversedMorrisInorderTraversal.java │ │ │ ├── SolutionApprocah0Stack.java │ │ │ └── similar_problems.txt │ │ ├── lc0540 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach1BinarySearch.java │ │ │ ├── SolutionApproach2OnePass.java │ │ │ ├── SolutionApproach2OnePass1.java │ │ │ └── SolutionApproach2OnePass2.java │ │ ├── lc0545 │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0549 │ │ │ ├── SolutionApproach0Postorder.java │ │ │ ├── SolutionApproach0Postorder1.java │ │ │ └── similar_problems.txt │ │ ├── lc0556 │ │ │ ├── SolutionApproach0Math.java │ │ │ └── similar_problems.txt │ │ ├── lc0576 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DFSMemo1.java │ │ │ └── SolutionApproach0DP2Dimen.java │ │ ├── lc0616 │ │ │ ├── SolutionApproach0MarkPositions.java │ │ │ ├── SolutionApproach0MarkPositions1.java │ │ │ ├── SolutionApproach0MarkPositions2.java │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ ├── SolutionApproach1MergeIntervals.java │ │ │ └── similar_problems.txt │ │ ├── lc0621 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach1MaxHeap.java │ │ │ └── similar_problems.txt │ │ ├── lc0630 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0632 │ │ │ ├── SolutionApproach0MinHeap.java │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc0636 │ │ │ ├── SolutionApproach0Stack.java │ │ │ ├── SolutionApproach0Stack1.java │ │ │ ├── SolutionApproach0Stack2.java │ │ │ └── similar_problems.txt │ │ ├── lc0639 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP0Dimen1.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0646 │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0Greedy1.java │ │ │ ├── SolutionApproach1DP1Dimen.java │ │ │ ├── SolutionApproach1DP1Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc0668 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0673 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach0DPWithBinarySearch.java │ │ │ └── similar_problems.txt │ │ ├── lc0675 │ │ │ └── SolutionApproachPQAndBFS.java │ │ ├── lc0688 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP3Dimen.java │ │ │ └── SolutionApproach1DFSMemo.java │ │ ├── lc0689 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── followup │ │ │ │ └── Solution.java │ │ ├── lc0698 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ ├── SolutionApproach0KnapsackBitMasking.java │ │ │ └── similar_problems.txt │ │ ├── lc0719 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach0BinarySearchWithMonoDeque.java │ │ │ └── SolutionApproach1MinHeap.java │ │ ├── lc0721 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc0726 │ │ │ ├── SolutionApproach0Recursion.java │ │ │ └── SolutionApproach0TreeMap.java │ │ ├── lc0727 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ └── similar_problems.txt │ │ ├── lc0735 │ │ │ ├── SolutionApproach0Stack.java │ │ │ ├── SolutionApproach0Stack1.java │ │ │ ├── SolutionApproach0Stack2.java │ │ │ └── SolutionApproach0Stack3.java │ │ ├── lc0740 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach1DFSMemo.java │ │ │ └── similar_problems.txt │ │ ├── lc0742 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0BFS1.java │ │ │ ├── SolutionApproach0BFS2.java │ │ │ ├── SolutionApproach0BFS3.java │ │ │ ├── SolutionApproach1DFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0745 │ │ │ ├── SolutionApproachTrie1HashMap.java │ │ │ └── UnfinishedSolutionApproach0Trie.java │ │ ├── lc0752 │ │ │ └── SolutionApproachBFS.java │ │ ├── lc0753 │ │ │ └── SolutionApproach0Backtrack.java │ │ ├── lc0759 │ │ │ ├── Interval.java │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0Greedy1.java │ │ │ ├── SolutionApproach0Greedy2.java │ │ │ ├── SolutionApproach0Greedy3.java │ │ │ ├── SolutionApproach0Greedy4.java │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ └── similar_problems.txt │ │ ├── lc0765 │ │ │ ├── SolutionApproach0CyclicSwapping.java │ │ │ ├── SolutionApproach0CyclicSwapping1.java │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc0768 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0Greedy1.java │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ └── similar_problems.txt │ │ ├── lc0769 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach1Greedy.java │ │ │ └── similar_problems.txt │ │ ├── lc0778 │ │ │ └── SolutionApproachPQ.java │ │ ├── lc0794 │ │ │ ├── SolutionApproach0Array.java │ │ │ └── SolutionApproach0Geometry1.java │ │ ├── lc0801 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0809 │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lc0813 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0815 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc0839 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ └── similar_problems.txt │ │ ├── lc0854 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFSMemo.java │ │ ├── lc0855 │ │ │ ├── SolutionApproach0MaxHeap.java │ │ │ ├── SolutionApproach0TreeSet.java │ │ │ └── SolutionApproach1ArrayList.java │ │ ├── lc0863 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0ForestBFS.java │ │ │ └── similar_problems.txt │ │ ├── lc0864 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc0871 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0Greedy.java │ │ │ ├── SolutionApproach0Greedy1.java │ │ │ ├── SolutionApproach0Greedy2.java │ │ │ └── similar_problems.txt │ │ ├── lc0879 │ │ │ ├── SolutionApproach0Knapsack2Dimen.java │ │ │ ├── SolutionApproach0Knapsack2Dimen1.java │ │ │ ├── SolutionApproach0Knapsack3Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0882 │ │ │ └── SolutionApproachDjikstraAlgorithm.java │ │ ├── lc0887 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── SolutionApproach1DFSMemo.java │ │ ├── lc0889 │ │ │ ├── SolutionApproach0DivideAndConquer.java │ │ │ └── SolutionApproach0SimulateDFS.java │ │ ├── lc0894 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP.java │ │ │ └── SolutionApproach1DFSRecursive.java │ │ ├── lc0895 │ │ │ ├── SolutionApproach0BucketSort.java │ │ │ ├── SolutionApproach0HashMaps.java │ │ │ └── SolutionApproach1MaxHeap.java │ │ ├── lc0907 │ │ │ ├── SolutionApproach0DP1DimenWithMonoStack.java │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach0MonoStack1.java │ │ │ └── similar_problems.txt │ │ ├── lc0916 │ │ │ ├── SolutionApproach0PreprocessingB.java │ │ │ └── SolutionApproach0PreprocessingB1.java │ │ ├── lc0918 │ │ │ └── SolutionApproach0KadanesAlgorithm.java │ │ ├── lc0924 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc0930 │ │ │ ├── SolutionApproach0PrefixSums.java │ │ │ ├── SolutionApproach0PrefixSums1.java │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── similar_problems.txt │ │ ├── lc0936 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0947 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ ├── SolutionApproach0UnionFind1.java │ │ │ └── similar_problems.txt │ │ ├── lc0952 │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc0956 │ │ │ ├── SolutionApproach0Knapsack1Dimen.java │ │ │ ├── SolutionApproach0Knapsack2Dimen.java │ │ │ ├── SolutionApproach0KnapsackHashMap.java │ │ │ └── similar_problems.txt │ │ ├── lc0963 │ │ │ ├── SolutionApproach0Geometry.java │ │ │ └── SolutionApproach0Geometry1.java │ │ ├── lc0968 │ │ │ ├── SolutionApproach0DFSAndGreedy.java │ │ │ └── SolutionApproachDFSAndGreedy1.java │ │ ├── lc0979 │ │ │ ├── SolutionApproach0Postorder.java │ │ │ ├── SolutionApproach0Postorder1.java │ │ │ └── SolutionApproach0Postorder2.java │ │ ├── lc0980 │ │ │ └── SolutionApproach0Backtrack.java │ │ ├── lc0983 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── SolutionApproach0DP1Dimen1.java │ │ ├── lc0992 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ ├── SolutionApproach0SlidingWindow1.java │ │ │ └── similar_problems.txt │ │ ├── lc0995 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── SolutionApproach0SlidingWindow1.java │ │ ├── lc1008 │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1011 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc1024 │ │ │ └── SolutionApproachGreedy.java │ │ ├── lc1027 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach1DP1.java │ │ │ ├── SolutionApproach1DP2.java │ │ │ └── similar_problems.txt │ │ ├── lc1028 │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc1035 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc1038 │ │ │ ├── SolutionApproach0ReversedInorderTraversal.java │ │ │ ├── SolutionApproach0ReversedInorderTraversal1.java │ │ │ ├── SolutionApproach0ReversedInorderTraversal2.java │ │ │ ├── SolutionApproach0ReversedMorrisInorderTraversal.java │ │ │ ├── SolutionApprocah0Stack.java │ │ │ └── similar_problems.txt │ │ ├── lc1040 │ │ │ ├── SolutionApproach0Math.java │ │ │ └── similar_problems.txt │ │ ├── lc1043 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc1049 │ │ │ ├── SolutionApproach0Knapsack.java │ │ │ ├── SolutionApproach0Knapsack1.java │ │ │ ├── followup │ │ │ │ └── Solution.java │ │ │ └── similar_problems.txt │ │ ├── lc1062 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0KMPAlgorithm.java │ │ │ ├── SolutionApproach0UkkonensAlgorithm.java │ │ │ ├── SolutionApproach2Sorting.java │ │ │ └── similar_problems.txt │ │ ├── lc1066 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DFSMemo1.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ └── SolutionApproach0DjikstrasSPF.java │ │ ├── lc1081 │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ └── similar_problems.txt │ │ ├── lc1092 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach1DFSMemo.java │ │ │ └── similar_problems.txt │ │ ├── lc1093 │ │ │ ├── SolutionApproach0Math.java │ │ │ └── SolutionApproach0Math1.java │ │ ├── lc1102 │ │ │ ├── SolutionApproach0BinarySearchWithDFS.java │ │ │ ├── SolutionApproach0DijkstraSPF.java │ │ │ └── SolutionApproach0KruskalMST.java │ │ ├── lc1105 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach0DP1Dimen2.java │ │ │ ├── SolutionApproach0DP1Dimen3.java │ │ │ ├── SolutionApproach1DFSMemo.java │ │ │ └── similar_problems.txt │ │ ├── lc1124 │ │ │ └── SolutionApproachPrefixSum1.java │ │ ├── lc1130 │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach1DFSMemo.java │ │ │ ├── SolutionApproach1DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc1135 │ │ │ ├── SolutionApproach0KruskalsMST.java │ │ │ └── SolutionApproach0KruskalsMST1.java │ │ ├── lc1136 │ │ │ └── SolutionApproachTSort.java │ │ ├── lc1152 │ │ │ └── SolutionApproach0BrutalForce.java │ │ ├── lc1163 │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc1168 │ │ │ ├── SolutionApproachPQ.java │ │ │ └── SolutionApproachPQ1.java │ │ ├── lc1177 │ │ │ ├── SolutionApproach0BitMasking.java │ │ │ ├── SolutionApproach0PrefixBooleans.java │ │ │ └── SolutionApproach0PrefixFreqs.java │ │ ├── lc1186 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP1Dimen1.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc1187 │ │ │ ├── SolutionApproach0DP1DimenWithTreeSet.java │ │ │ └── similar_problems.txt │ │ ├── lc1192 │ │ │ ├── SolutionApproach0TarjansAlgorithm.java │ │ │ └── followup │ │ │ │ └── SolutionApproach0TarjansAlgorithm.java │ │ ├── lc1202 │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc1210 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc1216 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc1231 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach1BinarySearch.java │ │ ├── lc1234 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ ├── SolutionApproach0SlidingWindow1.java │ │ │ ├── SolutionApproach0SlidingWindow2.java │ │ │ ├── SolutionApproach0SlidingWindow3.java │ │ │ └── similar_problems.txt │ │ ├── lc1235 │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DPWithBinarySearch.java │ │ │ ├── SolutionApproach1DPByTreeMap.java │ │ │ ├── SolutionApproach1DPWithBinarySearch1.java │ │ │ └── similar_problems.txt │ │ ├── lc1246 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DFSMemo1.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc1248 │ │ │ ├── SolutionApproach0LinearScan.java │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── similar_problems.txt │ │ ├── lc1250 │ │ │ └── SolutionApproach0Math.java │ │ ├── lc1258 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc1269 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ └── SolutionApproach0DP2Dimen.java │ │ ├── lc1278 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ ├── SolutionApproach0DP2Dimen2.java │ │ │ └── similar_problems.txt │ │ ├── lc1284 │ │ │ └── with_bitmask │ │ │ │ ├── SolutionApproach0BFS.java │ │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1289 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ ├── SolutionApproach0MinHeap.java │ │ │ └── similar_problems.txt │ │ ├── lc1292 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach0OnePass.java │ │ ├── lc1293 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc1297 │ │ │ ├── SolutionApproach0RollingHash.java │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── SolutionApproach0SlidingWindow1.java │ │ ├── lc1298 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1300 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach1Sorting.java │ │ │ └── similar_problems.txt │ │ ├── lc1312 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc1316 │ │ │ ├── SolutionApproach0RollingHash.java │ │ │ ├── SolutionApproach0RollingHash1.java │ │ │ ├── SolutionApproach1DP2Dimen.java │ │ │ ├── SolutionApproach1KMPAlgorithm.java │ │ │ ├── SolutionApproach1RollingCounter.java │ │ │ └── similar_problems.txt │ │ ├── lc1326 │ │ │ ├── SolutionApproachGreedy1.java │ │ │ └── SolutionApproachGreedy2.java │ │ ├── lc1335 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DPWithMonoStack.java │ │ │ └── similar_problems.txt │ │ ├── lc1340 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DPWithMonoStack.java │ │ │ └── SolutionApproach0DPWithSegmentTree.java │ │ ├── lc1345 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0BFS1.java │ │ ├── lc1361 │ │ │ ├── SolutionApproach0DFS.java │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc1368 │ │ │ ├── Solution0DijkstrasSPF.java │ │ │ ├── SolutionApproach0BFSWithDFS.java │ │ │ ├── SolutionApproach0Deque.java │ │ │ ├── SolutionApproach0DijkstrasSPF1.java │ │ │ ├── SolutionApproach1DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc1371 │ │ │ └── SolutionApproach0PrefixSums.java │ │ ├── lc1373 │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ └── SolutionApproach0DFSRecursive1.java │ │ ├── lc1411 │ │ │ └── SolutionApproach0DP.java │ │ ├── lc1425 │ │ │ ├── SolutionApproach0MonoDeque.java │ │ │ ├── SolutionApproach0MonoDeque1.java │ │ │ └── similar_problems.txt │ │ ├── lc1438 │ │ │ ├── SolutionApproach0MonoDeque.java │ │ │ ├── SolutionApproach1TreeMap.java │ │ │ └── similar_problems.txt │ │ ├── lc1439 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0Guess.java │ │ │ └── SolutionApproach1Greedy.java │ │ ├── lc1458 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DP1Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc1477 │ │ │ ├── SolutionApproach0PrefixSums.java │ │ │ ├── SolutionApproach0PrefixSums1.java │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc1483 │ │ │ ├── SolutionApproach1ControlledDFSMemo.java │ │ │ └── SolutionApproach2NaivelyDFSMemo.java │ │ ├── lc1499 │ │ │ ├── SolutionApproach0SlidingWindow.java │ │ │ └── SolutionApproach0SlidingWindow1.java │ │ ├── lc1510 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ └── SolutionApproach0Knapsack.java │ │ ├── lc1516 │ │ │ ├── Node.java │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc1537 │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ └── SolutionApproach1DFSMemo.java │ │ ├── lc1553 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFSMemo.java │ │ ├── lc1579 │ │ │ └── SolutionApproach0UnionFind.java │ │ ├── lc1584 │ │ │ ├── SolutionApproach0KruskalsMST.java │ │ │ └── SolutionApproach0PrimsMST.java │ │ ├── lc1610 │ │ │ └── SolutionApproach0Geometry.java │ │ └── lc1627 │ │ │ └── SolutionApproach0UnionFind.java │ ├── lvl5 │ │ ├── lc0004 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ ├── SolutionApproach0BinarySearch1.java │ │ │ ├── SolutionApproach0DivideAndConquer.java │ │ │ ├── SolutionApproach1BinarySearch.java │ │ │ └── similar_problems.txt │ │ ├── lc0010 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ └── SolutionApproach1DFSRecursive.java │ │ ├── lc0037 │ │ │ └── SolutionApproach0Backtrack.java │ │ ├── lc0085 │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ ├── SolutionApproach0MonoStack1.java │ │ │ └── similar_problems.txt │ │ ├── lc0099 │ │ │ ├── SolutionApproach0InorderRecoverByValue.java │ │ │ ├── SolutionApproach0InorderRecoverByValue1.java │ │ │ └── SolutionApproach0MorrisInorder.java │ │ ├── lc0123 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ ├── SolutionApproach0DP0Dimen1.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ └── similar_problems.txt │ │ ├── lc0140 │ │ │ ├── Solution0DfsMemo.java │ │ │ ├── Solution0DfsMemo1.java │ │ │ ├── SolutionDP.java │ │ │ └── similar_problems.txt │ │ ├── lc0212 │ │ │ ├── SolutionApproach0BacktrackWithTrie.java │ │ │ ├── SolutionApproach1Backtrack.java │ │ │ ├── SolutionApproach1BacktrackWithTrie.java │ │ │ └── similar_problems.txt │ │ ├── lc0214 │ │ │ ├── SolutionApproach0KMPAlgorithm.java │ │ │ ├── SolutionApproach0RollingHash.java │ │ │ └── similar_problems.txt │ │ ├── lc0224 │ │ │ └── SolutionApproach0Stack.java │ │ ├── lc0272 │ │ │ └── SolutionApproachStack.java │ │ ├── lc0273 │ │ │ ├── SolutionApproach0ParsingString.java │ │ │ ├── SolutionApproach0ParsingString1.java │ │ │ └── followups │ │ │ │ └── followup0 │ │ │ │ └── Solution.java │ │ ├── lc0282 │ │ │ ├── Solution0Backtrack.java │ │ │ └── Solution0Backtrack1.java │ │ ├── lc0291 │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── SolutionApproach0Backtrack1.java │ │ ├── lc0301 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ ├── SolutionApproach0DFS2.java │ │ │ └── SolutionApproach1BFS.java │ │ ├── lc0315 │ │ │ ├── SolutionApproach0BinaryIndexedTree.java │ │ │ ├── SolutionApproach0DivideAndConquer.java │ │ │ └── SolutionApproach0SegmentedTree.java │ │ ├── lc0324 │ │ │ ├── SolutionApproach0MedianPartitioning1.java │ │ │ ├── SolutionApproach1Sorting.java │ │ │ ├── followup │ │ │ │ └── Solution.java │ │ │ └── similar_problems.txt │ │ ├── lc0327 │ │ │ └── SolutionApproach0MergeSort.java │ │ ├── lc0335 │ │ │ └── SolutionApproach0Math.java │ │ ├── lc0336 │ │ │ └── SolutionApproach0Trie.java │ │ ├── lc0354 │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ ├── SolutionApproach0DP2Dimen1.java │ │ │ ├── SolutionApproach0DPWithBinarySearch.java │ │ │ ├── SolutionApproach1DPWithBinarySearch.java │ │ │ └── similar_problems.txt │ │ ├── lc0363 │ │ │ └── SolutionApproach0MergeSort.java │ │ ├── lc0403 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DFS1.java │ │ │ └── SolutionApproach1HashMap.java │ │ ├── lc0425 │ │ │ └── SolutionApproach0DFSWithTrie.java │ │ ├── lc0465 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ └── SolutionApproach0DP2Dimen.java │ │ ├── lc0472 │ │ │ ├── SolutionApproach1DFSwMemo.java │ │ │ ├── SolutionApproach1DFSwMemo1.java │ │ │ └── SolutionApproach2DFS.java │ │ ├── lc0480 │ │ │ ├── SolutionApproach0TreeSets.java │ │ │ ├── SolutionApproach1PriorityQueues.java │ │ │ └── similar_problems.txt │ │ ├── lc0483 │ │ │ └── SolutionApproach0BinarySearch.java │ │ ├── lc0493 │ │ │ ├── SolutionApproach0AVLTree.java │ │ │ ├── SolutionApproach0BIT.java │ │ │ ├── SolutionApproach0MergeSort.java │ │ │ └── SolutionApproach1BST.java │ │ ├── lc0499 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0DijkstrasSPF.java │ │ │ ├── SolutionApproach0DijkstrasSPF1.java │ │ │ └── similar_problems.txt │ │ ├── lc0527 │ │ │ └── SolutionApproach0Trie.java │ │ ├── lc0564 │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc0588 │ │ │ ├── SolutionApproach0TreeMap.java │ │ │ └── SolutionApproach0Trie.java │ │ ├── lc0642 │ │ │ ├── SolutionApproach0Trie.java │ │ │ └── SolutionApproach1Trie.java │ │ ├── lc0644 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach0BinarySearch1.java │ │ ├── lc0685 │ │ │ ├── Solution0UnionFind.java │ │ │ ├── Solution0UnionFind1.java │ │ │ └── similar_problems.txt │ │ ├── lc0691 │ │ │ └── SolutionApproach0DP1Dimen.java │ │ ├── lc0715 │ │ │ ├── SolutionApproach0SegmentTree.java │ │ │ └── SolutionApproach0TreeMap.java │ │ ├── lc0772 │ │ │ ├── SolutionApproach0DivideAndConquer.java │ │ │ └── SolutionApproach0DivideAndConquer1.java │ │ ├── lc0773 │ │ │ └── SolutionApproach0BFS.java │ │ ├── lc0774 │ │ │ ├── SolutionApproach0BinarySearch.java │ │ │ └── SolutionApproach1MinHeap.java │ │ ├── lc0786 │ │ │ └── SolutionApproach0MinHeap.java │ │ ├── lc0818 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DPBottomUp.java │ │ │ └── SolutionApproach0DPTopDown.java │ │ ├── lc0827 │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ └── similar_problems.txt │ │ ├── lc0828 │ │ │ ├── SolutionApproach0DP0Dimen.java │ │ │ └── SolutionApproach0DP0Dimen1.java │ │ ├── lc0834 │ │ │ └── SolutionApproach0DFSRecursive.java │ │ ├── lc0843 │ │ │ ├── FakeMaster.java │ │ │ └── SolutionApproach0Random.java │ │ ├── lc0847 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DPWithBFS.java │ │ ├── lc0850 │ │ │ ├── SolutionApproach0SegmentTree.java │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ ├── SolutionApproach0SweepLine1.java │ │ │ └── similar_problems.txt │ │ ├── lc0857 │ │ │ └── SolutionApproach0Greedy.java │ │ ├── lc0862 │ │ │ ├── SolutionApproach0MonoDeque.java │ │ │ ├── SolutionApproach1DP1Dimen.java │ │ │ └── similar_problems.txt │ │ ├── lc0959 │ │ │ ├── SolutionApproach0BFS.java │ │ │ ├── SolutionApproach0DFS.java │ │ │ ├── SolutionApproach0UnionFind.java │ │ │ └── SolutionApproach0UnionFind1.java │ │ ├── lc1036 │ │ │ ├── SolutionApproach0BFS.java │ │ │ └── SolutionApproach0DFS.java │ │ ├── lc1044 │ │ │ └── SolutionApproach0BinarySearchWithRabinKarp.java │ │ ├── lc1074 │ │ │ └── SolutionApproach0SlidingWindow.java │ │ ├── lc1203 │ │ │ ├── SolutionApproach0TopologicalSortBFS.java │ │ │ ├── SolutionApproach0TopologicalSortDFS.java │ │ │ └── similar_problems.txt │ │ ├── lc1349 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ └── SolutionApproach0DP1Dimen.java │ │ └── lc1483 │ │ │ ├── SolutionApproach0BinaryLifting.java │ │ │ ├── SolutionApproach0BinaryLifting1.java │ │ │ └── similar_problems.txt │ ├── lvl6 │ │ ├── lc0391 │ │ │ ├── SolutionApproach0Math.java │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ ├── SolutionApproach0SweepLine1.java │ │ │ └── similar_problems.txt │ │ ├── lc0420 │ │ │ └── Solution.java │ │ ├── lc0488 │ │ │ ├── SolutionApproach1DFSNaively.java │ │ │ └── SolutionApproach2Backtrack.java │ │ └── lc1000 │ │ │ ├── SolutionApproach0DFSMemo.java │ │ │ ├── SolutionApproach0DFSMemo1.java │ │ │ ├── SolutionApproach0DP2Dimen.java │ │ │ └── SolutionApproach0DP3Dimen.java │ ├── multithread │ │ └── lc1242 │ │ │ ├── FakeHtmlParser.java │ │ │ └── Solution.java │ ├── ood │ │ ├── lvl1 │ │ │ └── lc0346 │ │ │ │ └── SolutionApproach0Queue.java │ │ ├── lvl2 │ │ │ ├── lc0170 │ │ │ │ ├── SolutionApproach0HashMap.java │ │ │ │ └── SolutionApproach0HashMap1.java │ │ │ ├── lc0251 │ │ │ │ ├── SolutionApproach0TwoPointers.java │ │ │ │ └── followups │ │ │ │ │ └── SolutionApproach0IteratorsOnly.java │ │ │ ├── lc0359 │ │ │ │ ├── SolutionApproach0HashMap.java │ │ │ │ └── SolutionApproach0HashMap1.java │ │ │ ├── lc0384 │ │ │ │ ├── SolutionApproach0FisherYatesShuffle.java │ │ │ │ └── SolutionApproach1Swap.java │ │ │ ├── lc0398 │ │ │ │ ├── SolutionApproach0ReservoirSampling.java │ │ │ │ └── SolutionApproach1HashMap.java │ │ │ ├── lc0535 │ │ │ │ ├── SolutionApproach0HashMap1.java │ │ │ │ ├── SolutionApproach0Hashmap.java │ │ │ │ └── SolutionApproach1HashMap.java │ │ │ ├── lc0622 │ │ │ │ ├── SolutionDesignCircularQueue.java │ │ │ │ └── similar_problems.txt │ │ │ ├── lc0641 │ │ │ │ └── similar_problems.txt │ │ │ ├── lc0706 │ │ │ │ ├── SolutionApproach0Array.java │ │ │ │ └── SolutionApproach0Hash.java │ │ │ ├── lc0919 │ │ │ │ └── SolutionApproach0BFS.java │ │ │ ├── lc0933 │ │ │ │ ├── SolutionApproach0CircularArray.java │ │ │ │ ├── SolutionApproach1Queue.java │ │ │ │ ├── SolutionApproach2TreeMap.java │ │ │ │ └── SolutionApproach2TreeSet.java │ │ │ └── lc1570 │ │ │ │ └── SolutionApproach0TwoPointers.java │ │ ├── lvl3 │ │ │ ├── lc0155 │ │ │ │ ├── SolutionApproach0Stack.java │ │ │ │ ├── SolutionApproach0Stack1.java │ │ │ │ └── SolutionApproach0Stack2.java │ │ │ ├── lc0170 │ │ │ │ └── SolutionApproach0HashMap.java │ │ │ ├── lc0173 │ │ │ │ ├── SolutionApproach0ControlledInorderTraversalIterative.java │ │ │ │ ├── SolutionApproach1FlattenBST.java │ │ │ │ ├── followup │ │ │ │ │ └── Solution.java │ │ │ │ └── similar_problems.txt │ │ │ ├── lc0208 │ │ │ │ └── SolutionApproach0Trie.java │ │ │ ├── lc0284 │ │ │ │ └── SolutionApproach0CachingNextElement.java │ │ │ ├── lc0341 │ │ │ │ ├── SolutionApproach0Stack.java │ │ │ │ └── similar_problems.txt │ │ │ ├── lc0348 │ │ │ │ └── SolutionApproach0LinearScan.java │ │ │ ├── lc0357 │ │ │ │ └── SolutiuonApproach0HashMap.java │ │ │ ├── lc0379 │ │ │ │ ├── SolutionApproach0BitSet.java │ │ │ │ ├── SolutionApproach0SegmentTree.java │ │ │ │ ├── SolutionApproach1QueueAndSet.java │ │ │ │ ├── SolutionApproach1Set.java │ │ │ │ └── followups │ │ │ │ │ └── followup0 │ │ │ │ │ ├── SolutionApproach0Trie.java │ │ │ │ │ └── question.txt │ │ │ ├── lc0380 │ │ │ │ ├── SolutionApproach0ListTailReplacement.java │ │ │ │ └── similar_problems.txt │ │ │ ├── lc0449 │ │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ │ └── SolutionApproach0DFSRecursive1.java │ │ │ ├── lc0528 │ │ │ │ └── SolutionApproach0BinarySearch.java │ │ │ ├── lc0729 │ │ │ │ ├── SolutionApproach0SegmentedTree.java │ │ │ │ ├── SolutionApproach0SweepLine.java │ │ │ │ ├── SolutionApproach0TreeSet.java │ │ │ │ ├── SolutionApproach1BrutalForce.java │ │ │ │ └── similar_problems.txt │ │ │ ├── lc0731 │ │ │ │ ├── SolutionApproach0BinarySearchTree.java │ │ │ │ ├── SolutionApproach0SegmentedTree.java │ │ │ │ ├── SolutionApproach1BrutalForce.java │ │ │ │ ├── SolutionApproach1BrutalForce1.java │ │ │ │ ├── SolutionApproach2SweepLine.java │ │ │ │ └── similar_problems.txt │ │ │ ├── lc0901 │ │ │ │ ├── SolutionApproach0MonoStack.java │ │ │ │ ├── SolutionApproach0MonoStack1.java │ │ │ │ └── similar_problems.txt │ │ │ ├── lc1261 │ │ │ │ ├── SolutionApproach0BFS.java │ │ │ │ └── SolutionApproach0DFSRecursive.java │ │ │ ├── lc1286 │ │ │ │ ├── SolutionApproach0Backtrack.java │ │ │ │ ├── SolutionApproach0Backtrack1.java │ │ │ │ ├── bit_masking │ │ │ │ │ └── SolutionApproach0Backtrack.java │ │ │ │ └── similar_problems.txt │ │ │ └── lc1586 │ │ │ │ └── SolutionApproach0StackWithDLL.java │ │ ├── lvl4 │ │ │ ├── lc0146 │ │ │ │ ├── SolutionApproach0DoublyLinkedList.java │ │ │ │ ├── SolutionApproach0DoublyLinkedList1.java │ │ │ │ └── SolutionApproach1LinkedHashMap.java │ │ │ ├── lc0297 │ │ │ │ ├── SolutionApproach0DFSRecursive.java │ │ │ │ ├── SolutionApproach1BFS.java │ │ │ │ └── SolutionApproach1BFS1.java │ │ │ ├── lc0307 │ │ │ │ ├── SolutionApproach0BinaryIndexedTree.java │ │ │ │ ├── SolutionApproach0SegmentTree.java │ │ │ │ ├── SolutionApproach0SegmentTree1.java │ │ │ │ └── similar_problems.txt │ │ │ ├── lc0355 │ │ │ │ └── SolutionDesignTwitter.java │ │ │ ├── lc0431 │ │ │ │ ├── Node.java │ │ │ │ └── SolutionApproach0DFSRecursive.java │ │ │ ├── lc0732 │ │ │ │ ├── SolutionApproach0BinarySearchTree.java │ │ │ │ ├── SolutionApproach0SegmentTree.java │ │ │ │ ├── SolutionApproach1SweepLine.java │ │ │ │ └── similar_problems.txt │ │ │ └── lc1032 │ │ │ │ ├── SolutionApproach0Trie.java │ │ │ │ └── SolutionApproach0Trie1.java │ │ ├── lvl5 │ │ │ └── lc0381 │ │ │ │ ├── SolutionApproach0HashMap.java │ │ │ │ └── similar_problems.txt │ │ └── lvl6 │ │ │ └── lc0460 │ │ │ └── SolutionApproach0HashMapWithDLL.java │ └── sql │ │ └── problems_list.txt │ ├── summary │ ├── bit_manipulation │ │ └── NextPowerOf2.java │ ├── dynamic_programming │ │ ├── DPWithMemoization.java │ │ ├── LongestCommonSubsequence.java │ │ └── LongestIncreasingSubsequence.java │ ├── graph │ │ └── minimum_spanning_tree │ │ │ ├── KruskalsAlgorithm.java │ │ │ └── PrimsAlgorithm.java │ ├── recursion │ │ ├── Combination.java │ │ └── Permutation.java │ ├── resources.txt │ ├── search │ │ ├── binary_search │ │ │ ├── BinarySearch.java │ │ │ ├── BinarySearchLowerBound.java │ │ │ ├── BinarySearchRecursively.java │ │ │ ├── DemoApp.java │ │ │ ├── DemoBinarySearch.java │ │ │ └── KthSmallest.java │ │ ├── biselect_search │ │ │ └── KthSmallest.java │ │ └── zigzag_search │ │ │ └── KthSmallest.java │ ├── sort │ │ ├── bubble_sort │ │ │ └── BubbleSort.java │ │ ├── heap_sort │ │ │ ├── HeapSort.java │ │ │ └── KthSmallest.java │ │ ├── insertion_sort │ │ │ └── InsertionSort.java │ │ ├── merge_sort │ │ │ ├── MergeSortBottomUp.java │ │ │ └── MergeSortTopDown.java │ │ ├── quick_sort │ │ │ └── single_way │ │ │ │ ├── QuickSelectWithRandomPivot.java │ │ │ │ ├── QuickSort1.java │ │ │ │ ├── QuickSortPartitionEnd.java │ │ │ │ └── QuickSortPartitionMid.java │ │ └── selection_sort │ │ │ └── SelectionSort.java │ ├── string │ │ └── pattern_matching │ │ │ ├── KMPAlgorithm.java │ │ │ ├── RabinKarpSearch.java │ │ │ └── ZAlgorithm.java │ ├── tree │ │ ├── binary_indexed_tree │ │ │ └── BinaryIndexedTree.java │ │ ├── segmented_tree │ │ │ └── SegmentedTreeMinimumRangeQuery.java │ │ └── traversal │ │ │ ├── inorder │ │ │ ├── InorderTraversalRecursive.java │ │ │ ├── InorderTraversalterative.java │ │ │ ├── InorderTraversalterative1.java │ │ │ └── MorrisInorderTraversal.java │ │ │ ├── postorder │ │ │ ├── MorrisPostorderTraversal.java │ │ │ ├── PostorderTraversalRecursive.java │ │ │ └── ReversePostorderIterative.java │ │ │ └── preorder │ │ │ ├── MorrisPreorderTraversal.java │ │ │ ├── PreorderTraversalIterative.java │ │ │ └── PreorderTraversalRecursive.java │ └── union_find │ │ ├── UnionFind.java │ │ ├── UnionFindInMap.java │ │ └── UnionFindLightWeight.java │ └── util │ ├── Constant.java │ ├── NestedInteger.java │ └── data_structure │ ├── graph │ └── Vertex.java │ ├── linkedlist │ └── ListNode.java │ ├── tree │ ├── NaryTreeNode.java │ ├── TreeNode.java │ └── TreeNodeWithParentPointer.java │ └── trie │ ├── Trie.java │ └── TrieNode.java └── test └── java └── com └── idiotleon ├── bycompany ├── amazon │ └── ood │ │ └── first_unique_number_in_data_stream │ │ ├── TestSolutionApproach0DoublyLinkedList.java │ │ └── followup │ │ └── TestSolutionApproach0DoublyLinkedList.java ├── facebook │ └── string │ │ └── first_index_of_anagram │ │ └── TestSolutionApproachSlidingWindow.java └── others │ ├── matrix │ ├── hungary_rabbit │ │ └── TestSolution0DfsRecursiveRecursive.java │ └── most_connected_pixels │ │ ├── TestSolution0DfsRecursive.java │ │ └── TestSolution0DfsRecursive1.java │ └── tree │ └── traverse_binary_tree_with_parent_pointer │ └── TestSolution.java ├── leetcode ├── explore │ └── challenge30days │ │ └── first_unique_number │ │ ├── TestSolutionApproachDLinkedList.java │ │ ├── Utils.java │ │ ├── testcase01.txt │ │ ├── testcase02.txt │ │ ├── testcase03.txt │ │ └── testcase13.txt ├── lvl2 │ ├── lc0053 │ │ └── followups │ │ │ ├── followup0 │ │ │ └── TestSolutionApproach0KadanesAlgorithm.java │ │ │ └── followup1 │ │ │ └── TestSolutionApproach0KadanesAlgorithm.java │ ├── lc0074 │ │ ├── SolutionTestsApproachBinarySearch1.java │ │ └── SolutionTestsBinarySearch.java │ └── lc0209 │ │ └── SolutionTestsApproachSlidingWindow.java ├── lvl3 │ ├── lc0033 │ │ └── SolutionTestsApproachBinarySearch.java │ ├── lc0153 │ │ └── SolutionTestsApproachBinarySearch.java │ ├── lc0253 │ │ └── folllowups │ │ │ └── followup0 │ │ │ └── TestSolutionApproachSweepLine.java │ └── lc0378 │ │ ├── SolutionTestsApproachBinarySearch.java │ │ └── SolutionTestsApproachHeap.java ├── lvl4 │ ├── lc0031 │ │ └── followups │ │ │ └── TestSolutionApproach0Math.java │ ├── lc0042 │ │ └── followup │ │ │ ├── TestSolutionApproach0Stack.java │ │ │ ├── TestSolutionApproach1DP.java │ │ │ └── TestSolutionApproach1TwoPtrs.java │ ├── lc0081 │ │ └── SolutionTestsApproachBinarySearch.java │ ├── lc0240 │ │ └── SolutionTests.java │ ├── lc0305 │ │ └── SolutionTestsApproachUnionFind.java │ ├── lc0355 │ │ └── TestSolutionDesignTwitter.java │ ├── lc0745 │ │ └── TestSolutionApproach0Trie.java │ └── lc1483 │ │ └── SolutionTestApproach1ControlledDFSMemo.java ├── lvl5 │ └── lc0499 │ │ └── TestSolutionApproach0DjikstrasAlgorithm.java └── ood │ └── lvl3 │ └── lc0901 │ └── TestSolutionApproach0MonoStack1.java └── util ├── Constants.java └── data_structure └── tree ├── Constants.java └── TreeUtils.java /.gitattributes: -------------------------------------------------------------------------------- 1 | # 2 | # https://help.github.com/articles/dealing-with-line-endings/ 3 | # 4 | # These are explicitly windows files and should use crlf 5 | *.bat text eol=crlf 6 | 7 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | LC problem by tag - [github](https://github.com/idiotleon/lc-problem-by-tag-leon) -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-bin.zip 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | -------------------------------------------------------------------------------- /settings.gradle: -------------------------------------------------------------------------------- 1 | pluginManagement { 2 | plugins { 3 | id 'org.jetbrains.kotlin.jvm' version '2.1.0' 4 | } 5 | } 6 | plugins { 7 | id 'org.gradle.toolchains.foojay-resolver-convention' version '0.8.0' 8 | }/* 9 | * This file was generated by the Gradle 'init' task. 10 | * 11 | * The settings file is used to specify which projects to include in your build. 12 | * 13 | * Detailed information about configuring a multi-project build in Gradle can be found 14 | * in the user manual at https://docs.gradle.org/6.3/userguide/multi_project_builds.html 15 | */ 16 | 17 | rootProject.name = "leetcode-solution-java-leon" 18 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/App.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon; 2 | 3 | public class App { 4 | public static void main(String[] args) { 5 | System.out.println("Welcome to the real world!"); 6 | } 7 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/bycompany/amazon/ood/first_unique_number_in_data_stream/util/Constants.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.bycompany.amazon.ood.first_unique_number_in_data_stream.util; 2 | 3 | public class Constants { 4 | // the response to return where there is no unqiue number 5 | // to be finalized with the interviewer 6 | public static final int RESPONSE_IMPOSSIBLE = -1; 7 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/bycompany/facebook/array/leftmost/util/BinaryMatrix.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.bycompany.facebook.array.leftmost.util; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class BinaryMatrix { 7 | int[][] matrix; 8 | 9 | public BinaryMatrix(int[][] matrix){ 10 | this.matrix = matrix; 11 | } 12 | 13 | public int get(int row, int col){ 14 | return matrix[row][col]; 15 | } 16 | 17 | public List dimensions(){ 18 | return Arrays.asList(matrix.length, matrix[0].length); 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/bycompany/google/array/merge_interval_with_labels/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/discuss/interview-question/634115/Google-or-Onsite-or-Merge-Intervals-With-Labels 3 | * 4 | * 5 | */ 6 | package com.idiotleon.bycompany.google.array.merge_interval_with_labels; 7 | 8 | public class Solution { 9 | 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/bycompany/google/graph/how_many_blocks_turned_upside_down/SolutionApproachDijkstrasAlgorithm.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 给一个matrix类似于 3 | * 1 0 0 0 1 4 | * 0 1 0 1 1 5 | * 0 0 0 1 1 6 | * 1 0 1 1 1 7 | * 左上角和右下角都是1，1代表path可以直接走，0代表block，不能走，除非把0变成1 8 | * 9 | * 问从左上走到右下最少需要把多少个block(0)变成(flip) path(1) 10 | */ 11 | package com.idiotleon.bycompany.google.graph.how_many_blocks_turned_upside_down; 12 | 13 | public class SolutionApproachDijkstrasAlgorithm { 14 | 15 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/bycompany/others/array/insert_tags_into_the_string/SolutionApproach0SweepLine.java: -------------------------------------------------------------------------------- 1 | /** 2 | * input: 3 | * 1. a string: "hello" 4 | * 2. tags, with positions, to be inserted 5 | * [ 6 | * ["a", 1, 4], 7 | * ["b", 2, 5], 8 | * ["c", 1, 4] 9 | * ] 10 | * 11 | * output: 12 | * "h e l l o" 13 | * "h e l l o " 14 | * "h e l l o " 15 | */ 16 | package com.idiotleon.bycompany.others.array.insert_tags_into_the_string; 17 | 18 | public class SolutionApproach0SweepLine { 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/bycompany/others/matrix/most_connected_pixels/Pixel.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.bycompany.others.matrix.most_connected_pixels; 2 | 3 | class Pixel { 4 | protected final int R, G, B; 5 | protected final double AVERAGE; 6 | 7 | protected Pixel(int R, int G, int B){ 8 | this.R = R; 9 | this.G = G; 10 | this.B = B; 11 | 12 | this.AVERAGE = (R + G + B) / 3.0; 13 | } 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/bash/problem_list.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | 0192 https://leetcode.com/problems/word-frequency/ 7 | 8 | 9 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/interativeprogram/lvl2/FakeBinaryMatrix.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.interativeprogram.lvl2; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | class FakeBinaryMatrix { 7 | protected List dimensions() { 8 | return Arrays.asList(10, 10); 9 | } 10 | 11 | protected int get(int row, int col) { 12 | return 1; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0027/Solution.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl1.lc0027; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * https://leetcode.com/problems/remove-element/ 8 | * Time Complexity: O(`N`) 9 | * Space Complexity: O(1) 10 | */ 11 | @SuppressWarnings(Constant.WARNING.UNUSED) 12 | public class Solution { 13 | public int removeElement(int[] nums, int val) { 14 | if (nums == null || nums.length == 0) 15 | return 0; 16 | 17 | final int N = nums.length; 18 | 19 | int lo = 0; 20 | for (int hi = 0; hi < N; ++hi) { 21 | if (nums[hi] != val) 22 | nums[lo++] = nums[hi]; 23 | } 24 | 25 | return lo; 26 | } 27 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0058/SolutionApproach1LastIndexOf.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl1.lc0058; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * https://leetcode.com/problems/length-of-last-word/ 8 | *

9 | * Time Complexity: O(`L`) 10 | * Space Complexity: O(1) 11 | */ 12 | @SuppressWarnings(Constant.WARNING.UNUSED) 13 | public class SolutionApproach1LastIndexOf { 14 | public int lengthOfLastWord(String s) { 15 | final int L = s.trim().length(); 16 | return L - s.trim().lastIndexOf(" ") - 1; 17 | } 18 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0172/Solution.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl1.lc0172; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * https://leetcode.com/problems/factorial-trailing-zeroes/ 8 | * 9 | * Time Complexity: O(log`n`) 10 | * Space Complexity: O(1) 11 | */ 12 | @SuppressWarnings(Constant.WARNING.UNUSED) 13 | public class Solution { 14 | public int trailingZeroes(int n) { 15 | int zeroCount = 0; 16 | long currentMultiple = 5; 17 | 18 | while(n > 0){ 19 | n /= currentMultiple; 20 | zeroCount += n; 21 | } 22 | 23 | return zeroCount; 24 | } 25 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0189/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Rotated Array 7 | 8 | 1 0189 https://leetcode.com/problems/rotate-array/ 9 | 10 | 3 0153 https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/ 11 | 12 | 4 0081 https://leetcode.com/problems/search-in-rotated-sorted-array-ii/ 13 | 4 0154 https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0191/SolutionApproachBitManipulation.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/number-of-1-bits/ 3 | */ 4 | package com.idiotleon.leetcode.lvl1.lc0191; 5 | 6 | public class SolutionApproachBitManipulation{ 7 | public int hammingWeight(int n) { 8 | int ones = 0; 9 | while(n != 0){ 10 | ones = ones + (n & 1); 11 | n = n >>> 1; 12 | } 13 | 14 | return ones; 15 | } 16 | 17 | public int hammingWeight2(int n) { 18 | int count = 0; 19 | while(n != 0){ 20 | n = n & (n - 1); 21 | count++; 22 | } 23 | 24 | return count; 25 | } 26 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0258/SolutionApproach0Math.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/add-digits/ 3 | * 4 | * Time Complexity: O(1) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl1.lc0258; 8 | 9 | public class SolutionApproach0Math { 10 | public int addDigits(int num) { 11 | return 1 + (num - 1) % 9; 12 | } 13 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0258/SolutionApproach1DFSRecursivel.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/add-digits/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | */ 7 | package com.idiotleon.leetcode.lvl1.lc0258; 8 | 9 | public class SolutionApproach1DFSRecursivel { 10 | public int addDigits(int num) { 11 | String n = Integer.toString(num); 12 | if(n.length() == 1) return Integer.parseInt(n); 13 | 14 | int sum = 0; 15 | for(char ch : n.toCharArray()){ 16 | sum += Character.getNumericValue(ch); 17 | } 18 | return addDigits(sum); 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0258/SolutionApproach1Iteration.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/add-digits/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | */ 7 | package com.idiotleon.leetcode.lvl1.lc0258; 8 | 9 | public class SolutionApproach1Iteration { 10 | public int addDigits(int num) { 11 | while(num >= 10){ 12 | int temp = 0; 13 | while(num > 0){ 14 | temp += num % 10; 15 | num /= 10; 16 | } 17 | num = temp; 18 | } 19 | 20 | return num; 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0326/SolutionApproach0DFSRecursive.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/power-of-three/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/power-of-three/discuss/77876/**-A-summary-of-all-solutions-(new-method-included-at-15%3A30pm-Jan-8th) 9 | */ 10 | package com.idiotleon.leetcode.lvl1.lc0326; 11 | 12 | public class SolutionApproach0DFSRecursive { 13 | public boolean isPowerOfThree(int n) { 14 | return n > 0 && (n == 1 || (n % 3 == 0 && isPowerOfThree(n / 3))); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0415/followup/SolutionApproach0TwoPointers.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/add-strings/ 3 | * 4 | * if there are decimals, how to solve it please 5 | */ 6 | package com.idiotleon.leetcode.lvl1.lc0415.followup; 7 | 8 | public class SolutionApproach0TwoPointers { 9 | // public String addStrings(String num1, String num2) { 10 | 11 | // } 12 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0520/SolutionApproach0ParsingString.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/detect-capital/ 3 | * 4 | * 5 | */ 6 | package com.idiotleon.leetcode.lvl1.lc0520; 7 | 8 | public class SolutionApproach0ParsingString { 9 | public boolean detectCapitalUse(String word) { 10 | final int L = word.length(); 11 | char[] chs = word.toCharArray(); 12 | 13 | int count = 0; 14 | for (char ch : chs) 15 | if (isCapital(ch)) 16 | ++count; 17 | 18 | return (count == 0 || count == L || (count == 1 && isCapital(chs[0]))); 19 | } 20 | 21 | private boolean isCapital(char ch) { 22 | return 'Z' - ch >= 0; 23 | } 24 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0559/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl1.lc0559; 2 | 3 | import java.util.List; 4 | 5 | class Node { 6 | protected int val; 7 | protected List children; 8 | 9 | protected Node(int val){ 10 | this.val = val; 11 | } 12 | 13 | protected Node(int val, List children){ 14 | this.val = val; 15 | this.children = children; 16 | } 17 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0559/SolutionApproach0DFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/maximum-depth-of-n-ary-tree/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(H) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/maximum-depth-of-n-ary-tree/discuss/167010/DFS-and-BFS-solutions-in-C%2B%2B. 9 | */ 10 | package com.idiotleon.leetcode.lvl1.lc0559; 11 | 12 | public class SolutionApproach0DFS { 13 | public int maxDepth(Node root) { 14 | if(root == null) return 0; 15 | int depth = 0; 16 | for(Node child : root.children) 17 | depth = Math.max(depth, maxDepth(child)); 18 | return 1 + depth; 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0700/SolutionApproach0Recursion.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/search-in-a-binary-search-tree/ 3 | * 4 | * Time Complexity: O(H) 5 | * Space Complexity: O(H) 6 | */ 7 | package com.idiotleon.leetcode.lvl1.lc0700; 8 | 9 | import com.idiotleon.util.data_structure.tree.TreeNode; 10 | 11 | public class SolutionApproach0Recursion { 12 | public TreeNode searchBST(TreeNode root, int val) { 13 | return dfs(root, val); 14 | } 15 | 16 | private TreeNode dfs(TreeNode node, int val){ 17 | if(node == null) return null; 18 | if(node.val > val) return dfs(node.left, val); 19 | if(node.val < val) return dfs(node.right, val); 20 | return node; 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0700/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 1 0700 https://leetcode.com/problems/search-in-a-binary-search-tree/ 2 | 3 | 2 0617 https://leetcode.com/problems/merge-two-binary-trees/ 4 | 2 0701 https://leetcode.com/problems/insert-into-a-binary-search-tree/ 5 | 6 | 3 0450 https://leetcode.com/problems/delete-node-in-a-bst/ 7 | 3 0776 https://leetcode.com/problems/split-bst/ 8 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0766/followup/followup1/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | * 4 | * References: 5 | * https://leetcode.com/problems/toeplitz-matrix/discuss/179882/Follow-up-questions 6 | */ 7 | package com.idiotleon.leetcode.lvl1.lc0766.followup.followup1; 8 | 9 | public class Solution { 10 | 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0766/followup/followup2/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | * References: 4 | * https://leetcode.com/problems/toeplitz-matrix/discuss/179882/Follow-up-questions 5 | */ 6 | package com.idiotleon.leetcode.lvl1.lc0766.followup.followup2; 7 | 8 | public class Solution { 9 | 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0905/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### High Low Pointers 7 | 8 | 1 0905 https://leetcode.com/problems/sort-array-by-parity/ 9 | 10 | 2 0283 https://leetcode.com/problems/move-zeroes/ 11 | 12 | 3 0922 https://leetcode.com/problems/sort-array-by-parity-ii/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc0997/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/find-the-town-judge/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(N) 6 | */ 7 | package com.idiotleon.leetcode.lvl1.lc0997; 8 | 9 | public class Solution { 10 | public int findJudge(int N, int[][] trust) { 11 | int[] count = new int[N + 1]; 12 | for(int[] t : trust){ 13 | --count[t[0]]; 14 | ++count[t[1]]; 15 | } 16 | 17 | for(int i = 1; i <= N; i++){ 18 | if(count[i] == N - 1) 19 | return i; 20 | } 21 | 22 | return -1; 23 | } 24 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc1119/SolutionApproach0LinearScan.java: -------------------------------------------------------------------------------- 1 | /** 2 | * @author: Leon 3 | * https://leetcode.com/problems/remove-vowels-from-a-string/ 4 | * 5 | * Time Complexity: O(`LEN_S`) 6 | * Space Complexity: O(`LEN_S`) / O(1) 7 | */ 8 | package com.idiotleon.leetcode.lvl1.lc1119; 9 | 10 | public class SolutionApproach0LinearScan { 11 | 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc1165/SolutionApproach0LinearScan.java: -------------------------------------------------------------------------------- 1 | /** 2 | * @author: Leon 3 | * https://leetcode.com/problems/single-row-keyboard/ 4 | * 5 | * Time Complexity: O(`L`) 6 | * Space Complexity: O(26) ~ O(1) 7 | */ 8 | package com.idiotleon.leetcode.lvl1.lc1165; 9 | 10 | public class SolutionApproach0LinearScan { 11 | 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl1/lc1614/SolutionApproach0Stack.java: -------------------------------------------------------------------------------- 1 | /** 2 | * @author: Leon 3 | * https://leetcode.com/problems/maximum-nesting-depth-of-the-parentheses/ 4 | * 5 | * Time Complexity: O(`LEN_S`) 6 | * Space Complexity: O(1) 7 | */ 8 | package com.idiotleon.leetcode.lvl1.lc1614; 9 | 10 | public class SolutionApproach0Stack { 11 | 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0028/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### String 7 | ## Word Pattern 8 | # KMP Algorithm 9 | 10 | 2 0028 https://leetcode.com/problems/implement-strstr/ 11 | 2 1071 https://leetcode.com/problems/greatest-common-divisor-of-strings/ 12 | 13 | 3 0459 https://leetcode.com/problems/repeated-substring-pattern/ 14 | 3 0686 https://leetcode.com/problems/repeated-string-match/ 15 | 3 1367 https://leetcode.com/problems/linked-list-in-binary-tree/ 16 | 17 | 4 1316 https://leetcode.com/problems/distinct-echo-substrings/ 18 | 19 | 5 0214 https://leetcode.com/problems/shortest-palindrome/ 20 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0053/SolutionApproach0KadanesAlgorithm4.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/maximum-subarray/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(1) 6 | * 7 | * References: 8 | * Kadane's Algorithm 9 | * https://hackernoon.com/kadanes-algorithm-explained-50316f4fd8a6 10 | */ 11 | package com.idiotleon.leetcode.lvl2.lc0053; 12 | 13 | public class SolutionApproach0KadanesAlgorithm4 { 14 | public int maxSubArray(int[] nums) { 15 | int sum = 0, max = Integer.MIN_VALUE; 16 | for (int i = 0; i < nums.length; i++) { 17 | sum = sum < 0 ? nums[i] : (sum + nums[i]); 18 | max = Math.max(max, sum); 19 | } 20 | 21 | return max; 22 | } 23 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0053/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Kadane's Algorithm 7 | 8 | 2 0053 https://leetcode.com/problems/maximum-subarray/ 9 | 10 | 4 1186 https://leetcode.com/problems/maximum-subarray-sum-with-one-deletion/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0100/SolutionApproach0PreorderRecursive1.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/same-tree/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(H) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0100; 8 | 9 | import com.idiotleon.util.data_structure.tree.TreeNode; 10 | 11 | public class SolutionApproach0PreorderRecursive1 { 12 | public boolean isSameTree(TreeNode p, TreeNode q) { 13 | if (p == null && q == null) 14 | return true; 15 | 16 | if (p == null || q == null) 17 | return false; 18 | 19 | if (p.val != q.val) 20 | return false; 21 | 22 | return isSameTree(p.left, q.left) && isSameTree(p.right, q.right); 23 | } 24 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0104/SolutionApproach0PostorderRecursive.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/maximum-depth-of-binary-tree/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(H) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0104; 8 | 9 | import com.idiotleon.util.data_structure.tree.TreeNode; 10 | 11 | public class SolutionApproach0PostorderRecursive { 12 | public int maxDepth(TreeNode root) { 13 | if (root == null) 14 | return 0; 15 | 16 | int leftHeight = maxDepth(root.left); 17 | int rightHeight = maxDepth(root.right); 18 | 19 | return Math.max(leftHeight, rightHeight) + 1; 20 | } 21 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0112/SolutionApproach0PreorderRecursive1.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/path-sum/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(H) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0112; 8 | 9 | import com.idiotleon.util.data_structure.tree.TreeNode; 10 | 11 | public class SolutionApproach0PreorderRecursive1 { 12 | public boolean hasPathSumRecursion(TreeNode root, int sum) { 13 | if (root == null) 14 | return false; 15 | 16 | sum -= root.val; 17 | if (root.left == null && root.right == null) 18 | return sum == 0; 19 | 20 | return hasPathSumRecursion(root.left, sum) || hasPathSumRecursion(root.right, sum); 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0118/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | # Triangle 7 | 8 | 2 0118 https://leetcode.com/problems/pascals-triangle/ 9 | 2 0976 https://leetcode.com/problems/largest-perimeter-triangle/ 10 | 11 | 3 0119 https://leetcode.com/problems/pascals-triangle-ii/ 12 | 3 0611 https://leetcode.com/problems/valid-triangle-number/ 13 | 14 | 4 0120 https://leetcode.com/problems/triangle/ 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0136/SolutionApproach0LinearScan.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/single-number/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0136; 8 | 9 | public class SolutionApproach0LinearScan { 10 | public int singleNumber(int[] nums) { 11 | int single = 0; 12 | 13 | for (int num : nums) { 14 | single ^= num; 15 | } 16 | 17 | return single; 18 | } 19 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0136/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Single Number 7 | 8 | 2 0136 https://leetcode.com/problems/single-number/ 9 | 10 | 3 0137 https://leetcode.com/problems/single-number-ii/ 11 | 3 0260 https://leetcode.com/problems/single-number-iii/ 12 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0157/FakeReader4.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc0157; 2 | 3 | class FakeReader4 { 4 | protected int read4(char[] buf4) { 5 | return 4; 6 | } 7 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0157/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Read N Characters 7 | 8 | 2 0157 https://leetcode.com/problems/read-n-characters-given-read4/ 9 | 10 | 4 0158 https://leetcode.com/problems/read-n-characters-given-read4-ii-call-multiple-times/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0160/SolutionApproach0TwoPointers.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/intersection-of-two-linked-lists/ 3 | * 4 | * Time Complexity: O(LEN_A + LEN_B) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0160; 8 | 9 | import com.idiotleon.util.data_structure.linkedlist.ListNode; 10 | 11 | public class SolutionApproach0TwoPointers { 12 | public ListNode getIntersectionNode(ListNode headA, ListNode headB) { 13 | ListNode curA = headA, curB = headB; 14 | 15 | while (curA != curB) { 16 | curA = (curA == null) ? headB : curA.next; 17 | curB = (curB == null) ? headA : curB.next; 18 | } 19 | 20 | return curA; 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0168/SolutionApproach0DFSRecursive.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/excel-sheet-column-title/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0168; 8 | 9 | public class SolutionApproach0DFSRecursive { 10 | public String convertToTitle(int n) { 11 | return n == 0 ? "" : convertToTitle((n - 1) / 26) + (char) ((n - 1) % 26 + 'A'); 12 | } 13 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0168/SolutionApproach0Iteration.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/excel-sheet-column-title/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0168; 8 | 9 | class SolutionApproach0Iteration { 10 | public String convertToTitle(int n) { 11 | StringBuilder builder = new StringBuilder(); 12 | 13 | while (n != 0) { 14 | char ch = (char) ((n - 1) % 26 + 'A'); 15 | n = (n - 1) / 26; 16 | builder.insert(0, ch); 17 | } 18 | 19 | return builder.toString(); 20 | } 21 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0168/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 2 0168 https://leetcode.com/problems/excel-sheet-column-title/ 4 | 2 0171 https://leetcode.com/problems/excel-sheet-column-number/ 5 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0171/SolutionApproach0LinearScan.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/excel-sheet-column-number/ 3 | * 4 | * Time Complexity: O(L) 5 | * Space Complexity: O(1) / O(L) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0171; 8 | 9 | public class SolutionApproach0LinearScan { 10 | public int titleToNumber(String s) { 11 | // sanity check 12 | if (s == null || s.isEmpty()) 13 | return 0; 14 | 15 | final int L = s.length(); 16 | final char[] CHS = s.toCharArray(); 17 | 18 | int ans = 0; 19 | for (int i = 0; i < L; ++i) { 20 | ans = ans * 26 + (CHS[i] - 'A' + 1); 21 | } 22 | 23 | return ans; 24 | } 25 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0171/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 2 0168 https://leetcode.com/problems/excel-sheet-column-title/ 4 | 2 0171 https://leetcode.com/problems/excel-sheet-column-number/ 5 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0198/SolutionApproach1DFSNaive.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/house-robber/ 3 | * 4 | * References: 5 | * https://leetcode.com/problems/house-robber/discuss/156523/From-good-to-great.-How-to-approach-most-of-DP-problems. 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0198; 8 | 9 | public class SolutionApproach1DFSNaive { 10 | public int rob(int[] nums) { 11 | return rob(nums, nums.length - 1); 12 | } 13 | 14 | private int rob(int[] nums, int i) { 15 | if (i < 0) 16 | return 0; 17 | 18 | return Math.max(rob(nums, i - 2) + nums[i], rob(nums, i - 1)); 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0198/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://leetcode.com/tag/dynamic-programming/ 4 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 5 | 6 | 7 | ### House 8 | ### Robbery / Paint 9 | 10 | 2 0198 https://leetcode.com/problems/house-robber/ 11 | 12 | 3 0213 https://leetcode.com/problems/house-robber-ii/ 13 | 3 0256 https://leetcode.com/problems/paint-house/ 14 | 3 0276 https://leetcode.com/problems/paint-fence/ 15 | 16 | 4 0265 https://leetcode.com/problems/paint-house-ii/ 17 | 4 0337 https://leetcode.com/problems/house-robber-iii/ 18 | 4 1473 https://leetcode.com/problems/paint-house-iii/ 19 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0206/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Reverse a Linked List 7 | 8 | 2 0206 https://leetcode.com/problems/reverse-linked-list/ 9 | 10 | 3 0092 https://leetcode.com/problems/reverse-linked-list-ii/ 11 | 12 | 4 0025 https://leetcode.com/problems/reverse-nodes-in-k-group/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0215/SolutionApproach2SortingArray.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/kth-largest-element-in-an-array/ 3 | * 4 | * Time Complexity: O(N * lg(N)) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0215; 8 | 9 | import java.util.Arrays; 10 | 11 | public class SolutionApproach2SortingArray { 12 | public int findKthLargest(int[] nums, int k) { 13 | // sanity check 14 | if (nums == null || nums.length == 0) 15 | return 0; 16 | 17 | final int N = nums.length; 18 | Arrays.sort(nums); 19 | return nums[N - k]; 20 | } 21 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0231/SolutionApproach0BitManipulation.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/power-of-two/ 3 | * 4 | * Time Complexity: O(1) 5 | * Space Complexity: O(1) 6 | * 7 | * Referenes: 8 | * https://leetcode.com/problems/power-of-two/discuss/63966/4-different-ways-to-solve-Iterative-Recursive-Bit-operation-Math 9 | */ 10 | package com.idiotleon.leetcode.lvl2.lc0231; 11 | 12 | import com.idiotleon.util.Constant; 13 | 14 | @SuppressWarnings(Constant.WARNING.UNUSED) 15 | public class SolutionApproach0BitManipulation { 16 | public boolean isPowerOfTwo(int n) { 17 | // if(n <= 0) return false; 18 | 19 | return (n > 0) && ((n & (n - 1)) == 0); 20 | } 21 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0231/SolutionApproach1BinarySearch.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/power-of-two/ 3 | * 4 | * Time Complexity: O(lg(N)) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0231; 8 | 9 | import com.idiotleon.util.Constant; 10 | 11 | @SuppressWarnings(Constant.WARNING.UNUSED) 12 | public class SolutionApproach1BinarySearch { 13 | public boolean isPowerOfTwo(int n) { 14 | if(n <= 0) return false; 15 | 16 | while(n % 2 == 0){ 17 | n /= 2; 18 | } 19 | 20 | return n == 1; 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0246/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Strobogrammatic Number 7 | 8 | 2 0246 https://leetcode.com/problems/strobogrammatic-number/ 9 | 10 | 3 0247 https://leetcode.com/problems/strobogrammatic-number-ii/ 11 | 12 | 4 0248 https://leetcode.com/problems/strobogrammatic-number-iii/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0263/SolutionApproach0Iteration.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/ugly-number/ 3 | * 4 | * Time Complexity: O(lg(`num`)) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0263; 8 | 9 | public class SolutionApproach0Iteration { 10 | public boolean isUgly(int num) { 11 | // sanity check 12 | if (num <= 0) 13 | return false; 14 | 15 | while (num % 2 == 0) 16 | num /= 2; 17 | while (num % 3 == 0) 18 | num /= 3; 19 | while (num % 5 == 0) 20 | num /= 5; 21 | 22 | return num == 1; 23 | } 24 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0263/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Ugly Numbers 7 | 8 | 2 0263 https://leetcode.com/problems/ugly-number/ 9 | 10 | 3 1201 https://leetcode.com/problems/ugly-number-iii/ 11 | 12 | 4 0264 https://leetcode.com/problems/ugly-number-ii/ 13 | 4 0313 https://leetcode.com/problems/super-ugly-number/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0274/SolutionApproach0Sorting.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/h-index/ 3 | * 4 | * Time Complexity: O(N * lg(N)) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0274; 8 | 9 | import java.util.Arrays; 10 | 11 | public class SolutionApproach0Sorting { 12 | public int hIndex(int[] citations) { 13 | // sanity check 14 | if (citations == null || citations.length == 0) 15 | return 0; 16 | 17 | final int N = citations.length; 18 | Arrays.sort(citations); 19 | 20 | int idx = 0; 21 | while (idx < N && citations[N - 1 - idx] > idx) { 22 | ++idx; 23 | } 24 | 25 | return idx; 26 | } 27 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0274/similar_problemx.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | 2 0274 https://leetcode.com/problems/h-index/ 7 | 8 | 3 0275 https://leetcode.com/problems/h-index-ii/ 9 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0278/FakeVersionControl.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/first-bad-version/ 3 | * 4 | * a helper class 5 | */ 6 | package com.idiotleon.leetcode.lvl2.lc0278; 7 | 8 | public class FakeVersionControl { 9 | public boolean isBadVersion(int version){ 10 | return true; 11 | } 12 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0280/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 2 0280 https://leetcode.com/problems/wiggle-sort/ 4 | 5 | 3 0376 https://leetcode.com/problems/wiggle-subsequence/ 6 | 7 | 5 0324 https://leetcode.com/problems/wiggle-sort-ii/ 8 | 9 | Resources: 10 | https://leetcode.com/problems/wiggle-sort-ii/discuss/77684/summary-of-the-various-solutions-to-wiggle-sort-for-your-reference/81858 -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0283/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### High Low Pointers 7 | 8 | 1 0905 https://leetcode.com/problems/sort-array-by-parity/ 9 | 10 | 2 0283 https://leetcode.com/problems/move-zeroes/ 11 | 12 | 3 0922 https://leetcode.com/problems/sort-array-by-parity-ii/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0371/SolutionApproach0BitManipulation1.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/sum-of-two-integers/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/sum-of-two-integers/discuss/84278/A-summary%3A-how-to-use-bit-manipulation-to-solve-problems-easily-and-efficiently 9 | * https://leetcode.com/problems/sum-of-two-integers/discuss/132479/Simple-explanation-on-how-to-arrive-at-the-solution 10 | */ 11 | package com.idiotleon.leetcode.lvl2.lc0371; 12 | 13 | public class SolutionApproach0BitManipulation1 { 14 | public int getSum(int a, int b) { 15 | return b == 0 ? a : getSum(a ^ b, (a & b) << 1); 16 | } 17 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0374/FakeGuessGame.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/guess-number-higher-or-lower/ 3 | */ 4 | package com.idiotleon.leetcode.lvl2.lc0374; 5 | 6 | public class FakeGuessGame { 7 | public int guess(int n){ 8 | return 0; 9 | } 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0433/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Word Series 7 | 8 | 2 0433 https://leetcode.com/problems/minimum-genetic-mutation/ 9 | 10 | 4 0079 https://leetcode.com/problems/word-search/ 11 | 4 0126 https://leetcode.com/problems/word-ladder-ii/ 12 | 4 0127 https://leetcode.com/problems/word-ladder/ 13 | 4 0139 https://leetcode.com/problems/word-break/ 14 | 15 | 5 0140 https://leetcode.com/problems/word-break-ii/ 16 | 5 0212 https://leetcode.com/problems/word-search-ii/ 17 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0441/SolutionApproach0Math.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/arranging-coins/ 3 | * 4 | * References: 5 | * https://leetcode.com/problems/arranging-coins/discuss/92274/JAVA-Clean-Code-with-Explanations-and-Running-Time-2-Solutions 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0441; 8 | 9 | public class SolutionApproach0Math { 10 | public int arrangeCoins(int n) { 11 | int i = 0; 12 | while(n > 0){ 13 | i += 1; 14 | n -= i; 15 | } 16 | 17 | return n == 0 ? i : i - 1; 18 | } 19 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0501/SolutionApproach0InorderRecursive1.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | * Time Complexity: O(N) 4 | * Space Complexity: O(1) 5 | * 6 | * Referneces: 7 | * https://leetcode.com/problems/find-mode-in-binary-search-tree/discuss/98101/Proper-O(1)-space 8 | */ 9 | package com.idiotleon.leetcode.lvl2.lc0501; 10 | 11 | public class SolutionApproach0InorderRecursive1 { 12 | 13 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0561/SolutionApproach1Sort.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/array-partition-i/ 3 | * 4 | * Time Complexity: O(Nlg(N)) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc0561; 8 | 9 | import java.util.Arrays; 10 | 11 | public class SolutionApproach1Sort { 12 | public int arrayPairSum(int[] nums) { 13 | Arrays.sort(nums); 14 | 15 | int sum = 0; 16 | for(int i = 0; i < nums.length; i += 2){ 17 | sum += nums[i]; 18 | } 19 | 20 | return sum; 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0567/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Rolling Hash 7 | 8 | 2 0567 https://leetcode.com/problems/permutation-in-string/ 9 | 10 | 4 1316 https://leetcode.com/problems/distinct-echo-substrings/ 11 | 12 | 5 0214 https://leetcode.com/problems/shortest-palindrome/ 13 | 5 1044 https://leetcode.com/problems/longest-duplicate-substring/ 14 | 15 | 16 | 17 | ### Sliding Window -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0589/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc0589; 2 | 3 | import java.util.List; 4 | 5 | class Node { 6 | protected int val; 7 | protected List children; 8 | 9 | protected Node(int val){ 10 | this.val = val; 11 | } 12 | 13 | protected Node(int val, List children){ 14 | this.val = val; 15 | this.children = children; 16 | } 17 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0589/SolutionApproach0PreorderRecursive.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc0589; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class SolutionApproach0PreorderRecursive { 7 | public List preorder(Node root) { 8 | List ans = new ArrayList(); 9 | preorder(root, ans); 10 | return ans; 11 | } 12 | 13 | private void preorder(Node node, List res){ 14 | if(node == null) return; 15 | 16 | res.add(node.val); 17 | for(Node child : node.children) 18 | preorder(child, res); 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0606/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 2 0606 https://leetcode.com/problems/construct-string-from-binary-tree/ 2 | 3 | 3 0536 https://leetcode.com/problems/construct-binary-tree-from-string/ 4 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0617/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 1 0700 https://leetcode.com/problems/search-in-a-binary-search-tree/ 2 | 3 | 2 0617 https://leetcode.com/problems/merge-two-binary-trees/ 4 | 2 0701 https://leetcode.com/problems/insert-into-a-binary-search-tree/ 5 | 6 | 3 0450 https://leetcode.com/problems/delete-node-in-a-bst/ 7 | 3 0776 https://leetcode.com/problems/split-bst/ 8 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0690/FakeEmployee.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc0690; 2 | 3 | import java.util.List; 4 | 5 | class FakeEmployee { 6 | protected int id; 7 | protected int importance; 8 | protected List subordinates; 9 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0695/SolutionApproach0UnionFind.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc0695; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * LC0695 8 | *

9 | * Time Complexity: O(`NR` * `NC`) 10 | * Time Complexity: O(`NR` * `NC`) 11 | *

12 | * Reference: 13 | * LC Discussion. 14 | */ 15 | @SuppressWarnings(Constant.WARNING.UNUSED) 16 | public class SolutionApproach0UnionFind { 17 | 18 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0701/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 1 0700 https://leetcode.com/problems/search-in-a-binary-search-tree/ 2 | 3 | 2 0617 https://leetcode.com/problems/merge-two-binary-trees/ 4 | 2 0701 https://leetcode.com/problems/insert-into-a-binary-search-tree/ 5 | 6 | 3 0450 https://leetcode.com/problems/delete-node-in-a-bst/ 7 | 3 0776 https://leetcode.com/problems/split-bst/ 8 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0767/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Single Threaded 7 | ## CPU 8 | 9 | 4 0621 https://leetcode.com/problems/task-scheduler/ 10 | 4 0636 https://leetcode.com/problems/exclusive-time-of-functions/ 11 | 12 | 13 | 14 | ### k Distance Apart 15 | ### No Adjacency 16 | 17 | 2 0767 https://leetcode.com/problems/reorganize-string/ 18 | 19 | 4 0358 https://leetcode.com/problems/rearrange-string-k-distance-apart/ 20 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0791/followups/followup1/Solution.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc0791.followups.followup1; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * LC0791 8 | *

9 | * follow up 1: 10 | * if the custom order `S` is too large/long, how to solve it efficiently? 11 | *

12 | * Reference: 13 | * LC Discussion 14 | */ 15 | @SuppressWarnings(Constant.WARNING.UNUSED) 16 | public class Solution { 17 | 18 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0791/followups/followup2/Solution.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc0791.followups.followup2; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * LC0791 8 | *

9 | * follow up 2: 10 | * if the string `T` is too large/long, how to solve it efficiently 11 | *

12 | * Reference: 13 | * LC Discussion 14 | */ 15 | @SuppressWarnings(Constant.WARNING.UNUSED) 16 | public class Solution { 17 | 18 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0791/followups/followup3/Solution.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc0791.followups.followup3; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * LC0791 8 | *

9 | * follow up 2: 10 | * if repetitions are allowed in `S` such that relative ordering in `S` and final answer remain the same 11 | *

12 | * Reference: 13 | * LC Discussion 14 | */ 15 | @SuppressWarnings(Constant.WARNING.UNUSED) 16 | public class Solution { 17 | 18 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0832/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Array Manipulation 7 | 8 | 2 0832 https://leetcode.com/problems/flipping-an-image/ 9 | 10 | 3 0048 https://leetcode.com/problems/rotate-image/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0973/Solution1SortingArray.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc0973; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | import java.util.Arrays; 6 | 7 | /** 8 | * @author: Leon 9 | * lc0972 10 | *

11 | * Time Complexity: O(N * lgN) 12 | * Space Complexity: O(1) 13 | */ 14 | @SuppressWarnings({Constant.WARNING.UNUSED}) 15 | public class Solution1SortingArray { 16 | public int[][] kClosest(final int[][] points, final int K) { 17 | Arrays.sort(points, (p1, p2) -> (p1[0] * p1[0] + p1[1] * p1[1]) - (p2[0] * p2[0] + p2[1] * p2[1])); 18 | return Arrays.copyOfRange(points, 0, K); 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0973/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | Reference: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Top K 7 | 8 | 2 0215 https://leetcode.com/problems/kth-largest-element-in-an-array/ 9 | 2 0347 https://leetcode.com/problems/top-k-frequent-elements/ 10 | 2 0692 https://leetcode.com/problems/top-k-frequent-words/ 11 | 2 0973 https://leetcode.com/problems/k-closest-points-to-origin/ 12 | 13 | 3 0378 https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc0976/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | # Triangle 7 | 8 | 2 0118 https://leetcode.com/problems/pascals-triangle/ 9 | 2 0976 https://leetcode.com/problems/largest-perimeter-triangle/ 10 | 11 | 3 0119 https://leetcode.com/problems/pascals-triangle-ii/ 12 | 3 0611 https://leetcode.com/problems/valid-triangle-number/ 13 | 14 | 4 0120 https://leetcode.com/problems/triangle/ 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1021/SolutionApproach0Stack.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc1021; 2 | 3 | public class SolutionApproach0Stack { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1071/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### String 7 | ## Word Pattern 8 | # KMP Algorithm 9 | 10 | 2 0028 https://leetcode.com/problems/implement-strstr/ 11 | 2 1071 https://leetcode.com/problems/greatest-common-divisor-of-strings/ 12 | 13 | 3 0459 https://leetcode.com/problems/repeated-substring-pattern/ 14 | 3 0686 https://leetcode.com/problems/repeated-string-match/ 15 | 3 1367 https://leetcode.com/problems/linked-list-in-binary-tree/ 16 | 17 | 4 1316 https://leetcode.com/problems/distinct-echo-substrings/ 18 | 19 | 5 0214 https://leetcode.com/problems/shortest-palindrome/ 20 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1167/SolutionApproach0Greedy.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/minimum-cost-to-connect-sticks/ 3 | * 4 | * Time Complexity: O(`N` * lg(`N`)) 5 | * Space Complexity: O(`N`) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/minimum-cost-to-connect-sticks/discuss/365849/JavaPython-3-Greedy-%2B-PriorityQueue-w-analysis. 9 | * https://leetcode.com/problems/minimum-cost-to-connect-sticks/discuss/365865/Python-Greedy-Solution/661580 10 | */ 11 | package com.idiotleon.leetcode.lvl2.lc1167; 12 | 13 | public class SolutionApproach0Greedy { 14 | 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1287/SolutionApproach1SlidingWindow.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/element-appearing-more-than-25-in-sorted-array/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc1287; 8 | 9 | public class SolutionApproach1SlidingWindow { 10 | public int findSpecialInteger(int[] arr) { 11 | final int N = arr.length, T = N / 4; 12 | for (int i = 0; i < N - T; ++i) { 13 | if (arr[i] == arr[i + T]) 14 | return arr[i]; 15 | } 16 | 17 | return -1; 18 | } 19 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1305/followup/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/all-elements-in-two-binary-search-trees/ 3 | * 4 | * how about k BSTs? 5 | * 6 | * References: 7 | * https://leetcode.com/problems/all-elements-in-two-binary-search-trees/discuss/464073/C%2B%2B-One-Pass-Traversal 8 | */ 9 | package com.idiotleon.leetcode.lvl2.lc1305.followup; 10 | 11 | public class Solution { 12 | 13 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1305/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Divide and Conquer 7 | 8 | 2 1305 https://leetcode.com/problems/all-elements-in-two-binary-search-trees/ 9 | 10 | 3 0173 https://leetcode.com/problems/binary-search-tree-iterator/ 11 | 12 | 4 0023 https://leetcode.com/problems/merge-k-sorted-lists/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1344/SolutionAppraoch0Math.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/angle-between-hands-of-a-clock/ 3 | * 4 | * References: 5 | * https://leetcode.com/problems/angle-between-hands-of-a-clock/discuss/502738/JavaPythonC%2B%2B-Simple-Math-on-Clock-angles 6 | */ 7 | package com.idiotleon.leetcode.lvl2.lc1344; 8 | 9 | public class SolutionAppraoch0Math { 10 | public double angleClock(int hour, int minutes) { 11 | double min = minutes * 6; 12 | double hr = hour * 30 + (double)minutes / 2; 13 | double angle = Math.abs(hr - min); 14 | return Math.min(angle, 360 - angle); 15 | } 16 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1365/SolutionApproach0BucketSort.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/ 3 | * 4 | * Time Complexity: O(`N`) + O(`RANGE`) 5 | * Space Complexity: O(`RANGE`) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/discuss/575760/Java-simple-to-complex-explained-0-ms-faster-than-100-less-space-than-100-5-lines-of-code 9 | */ 10 | package com.idiotleon.leetcode.lvl2.lc1365; 11 | 12 | public class SolutionApproach0BucketSort { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1375/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 2 1375 https://leetcode.com/problems/bulb-switcher-iii/ 2 | 3 | 3 0763 https://leetcode.com/problems/partition-labels/description/ 4 | 5 | 4 0769 https://leetcode.com/problems/max-chunks-to-make-sorted/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1379/followup/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/ 3 | * 4 | * if repeated values on the tree are allowed 5 | */ 6 | package com.idiotleon.leetcode.lvl2.lc1379.followup; 7 | 8 | public class Solution { 9 | 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1490/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc1490; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | class Node { 7 | protected int val; 8 | protected List children; 9 | 10 | protected Node() { 11 | children = new ArrayList(); 12 | } 13 | 14 | protected Node(int _val) { 15 | val = _val; 16 | children = new ArrayList(); 17 | } 18 | 19 | protected Node(int _val, ArrayList _children) { 20 | val = _val; 21 | children = _children; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1618/FakeFontInfo.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc1618; 2 | 3 | class FakeFontInfo { 4 | // Return the width of char ch when fontSize is used. 5 | public int getWidth(int fontSize, char ch) { 6 | return 1; 7 | } 8 | 9 | // Return Height of any char when fontSize is used. 10 | public int getHeight(int fontSize){ 11 | return 1; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl2/lc1666/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc1666; 2 | 3 | class Node { 4 | public int val; 5 | public Node left; 6 | public Node right; 7 | public Node parent; 8 | }; 9 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0048/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Matrix Manipulation 7 | 8 | 2 0832 https://leetcode.com/problems/flipping-an-image/ 9 | 10 | 3 0048 https://leetcode.com/problems/rotate-image/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0055/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Jump Game 7 | 8 | 3 0055 https://leetcode.com/problems/jump-game/ 9 | 3 1306 https://leetcode.com/problems/jump-game-iii/ 10 | 11 | 4 0045 https://leetcode.com/problems/jump-game-ii/ 12 | 4 1340 https://leetcode.com/problems/jump-game-v/ 13 | 4 1345 https://leetcode.com/problems/jump-game-iv/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0056/followup/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * if there are two input arrays 3 | * 4 | * if there are k input arrays 5 | */ 6 | package com.idiotleon.leetcode.lvl3.lc0056.followup; 7 | 8 | public class Solution { 9 | 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0060/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Math 7 | 8 | 3 0060 https://leetcode.com/problems/permutation-sequence/ 9 | 3 0670 https://leetcode.com/problems/maximum-swap/ 10 | 3 1053 https://leetcode.com/problems/previous-permutation-with-one-swap/ 11 | 12 | 4 0031 https://leetcode.com/problems/next-permutation/ 13 | 4 0556 https://leetcode.com/problems/next-greater-element-iii/ 14 | 15 | 16 | previous permutation -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0064/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Path Sum 7 | 8 | 2 0112 https://leetcode.com/problems/path-sum/ 9 | 10 | 3 0064 https://leetcode.com/problems/minimum-path-sum/ 11 | 3 0113 https://leetcode.com/problems/path-sum-ii/ 12 | 3 0437 https://leetcode.com/problems/path-sum-iii/ 13 | 3 0666 https://leetcode.com/problems/path-sum-iv/ 14 | 3 0931 https://leetcode.com/problems/minimum-falling-path-sum/ 15 | 16 | 4 0124 https://leetcode.com/problems/binary-tree-maximum-path-sum/ 17 | 4 1289 https://leetcode.com/problems/minimum-falling-path-sum-ii/ 18 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0080/SolutionApproach0LinearScan.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl3.lc0080; 8 | 9 | public class SolutionApproach0LinearScan { 10 | public int removeDuplicates(int[] nums) { 11 | // sanity check 12 | if (nums == null || nums.length == 0) 13 | return 0; 14 | 15 | int idx = 0; 16 | for (int num : nums) { 17 | if (idx < 2 || num > nums[idx - 2]) { 18 | nums[idx++] = num; 19 | } 20 | } 21 | 22 | return idx; 23 | } 24 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0091/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Decode Ways 7 | 8 | 3 0091 https://leetcode.com/problems/decode-ways/ 9 | 10 | 4 0639 https://leetcode.com/problems/decode-ways-ii/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0092/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Reverse a Linked List 7 | 8 | 2 0206 https://leetcode.com/problems/reverse-linked-list/ 9 | 10 | 3 0092 https://leetcode.com/problems/reverse-linked-list-ii/ 11 | 12 | 4 0025 https://leetcode.com/problems/reverse-nodes-in-k-group/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0113/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Path Sum 7 | 8 | 2 0112 https://leetcode.com/problems/path-sum/ 9 | 10 | 3 0064 https://leetcode.com/problems/minimum-path-sum/ 11 | 3 0113 https://leetcode.com/problems/path-sum-ii/ 12 | 3 0437 https://leetcode.com/problems/path-sum-iii/ 13 | 3 0666 https://leetcode.com/problems/path-sum-iv/ 14 | 3 0931 https://leetcode.com/problems/minimum-falling-path-sum/ 15 | 16 | 4 0124 https://leetcode.com/problems/binary-tree-maximum-path-sum/ 17 | 4 1289 https://leetcode.com/problems/minimum-falling-path-sum-ii/ 18 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0114/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Flatten 7 | 8 | 3 0114 https://leetcode.com/problems/flatten-binary-tree-to-linked-list/ 9 | 3 0339 https://leetcode.com/problems/nested-list-weight-sum/ 10 | 3 0341 https://leetcode.com/problems/flatten-nested-list-iterator/ 11 | 3 0430 https://leetcode.com/problems/flatten-a-multilevel-doubly-linked-list/ 12 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0116/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0116; 2 | 3 | class Node { 4 | protected int val; 5 | protected Node left; 6 | protected Node right; 7 | protected Node next; 8 | 9 | protected Node(){} 10 | 11 | protected Node(int val){ 12 | this.val = val; 13 | } 14 | 15 | protected Node(int val, Node left, Node right, Node next){ 16 | this.val = val; 17 | this.left = left; 18 | this.right = right; 19 | this.next = next; 20 | } 21 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0116/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 3 0116 https://leetcode.com/problems/populating-next-right-pointers-in-each-node/ 4 | 5 | 4 0117 https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/ 6 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0117/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0117; 2 | 3 | class Node { 4 | protected int val; 5 | protected Node left; 6 | protected Node right; 7 | protected Node next; 8 | 9 | protected Node(int val) { 10 | this.val = val; 11 | this.left = this.right = this.next = null; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0121/SolutionApproach0DP0Dimen.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/best-time-to-buy-and-sell-stock/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl3.lc0121; 8 | 9 | public class SolutionApproach0DP0Dimen { 10 | public int maxProfit(int[] prices) { 11 | int minPrice = Integer.MAX_VALUE; 12 | int maxProfit = 0; 13 | 14 | for (int price : prices) { 15 | if (price < minPrice) 16 | minPrice = price; 17 | 18 | int profit = price - minPrice; 19 | if (profit > maxProfit) 20 | maxProfit = profit; 21 | } 22 | 23 | return maxProfit; 24 | } 25 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0121/SolutionApproach0DP0Dimen1.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/best-time-to-buy-and-sell-stock/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl3.lc0121; 8 | 9 | public class SolutionApproach0DP0Dimen1 { 10 | public int maxProfit(int[] prices) { 11 | int minPrice = Integer.MAX_VALUE; 12 | int maxProfit = 0; 13 | 14 | for (int price : prices) { 15 | maxProfit = Math.max(maxProfit, price - minPrice); 16 | 17 | minPrice = Math.min(minPrice, price); 18 | } 19 | 20 | return maxProfit; 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0121/followup/SolutionApproach0DP0Dimen1.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/best-time-to-buy-and-sell-stock/ 3 | * 4 | * how about sell short? 5 | * 6 | * Time Complexity: O(N) 7 | * Space Complexity: O(1) 8 | */ 9 | package com.idiotleon.leetcode.lvl3.lc0121.followup; 10 | 11 | public class SolutionApproach0DP0Dimen1 { 12 | public int maxProfit(int[] prices) { 13 | int maxPrice = Integer.MAX_VALUE; 14 | int maxProfit = 0; 15 | 16 | for (int price : prices) { 17 | maxPrice = Math.max(maxPrice, price); 18 | maxProfit = Math.max(maxProfit, maxPrice - price); 19 | } 20 | 21 | return maxProfit; 22 | } 23 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0130/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Islands 7 | 8 | 2 0695 https://leetcode.com/problems/max-area-of-island/ 9 | 10 | 3 0130 https://leetcode.com/problems/surrounded-regions/ 11 | 3 0200 https://leetcode.com/problems/number-of-islands/ 12 | 13 | 4 0317 https://leetcode.com/problems/shortest-distance-from-all-buildings/ 14 | 4 0839 https://leetcode.com/problems/similar-string-groups/ 15 | 4 0947 https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/ 16 | 17 | 5 0827 https://leetcode.com/problems/making-a-large-island/ 18 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0133/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0133; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | class Node { 7 | protected int val; 8 | protected List neighbors; 9 | 10 | protected Node() { 11 | val = 0; 12 | neighbors = new ArrayList(); 13 | } 14 | 15 | protected Node(int _val) { 16 | val = _val; 17 | neighbors = new ArrayList(); 18 | } 19 | 20 | protected Node(int _val, ArrayList _neighbors) { 21 | val = _val; 22 | neighbors = _neighbors; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0133/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Deep Clone 7 | 8 | 3 0133 https://leetcode.com/problems/clone-graph/ 9 | 10 | 4 0138 https://leetcode.com/problems/copy-list-with-random-pointer/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0137/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Single Number 7 | 8 | 2 0136 https://leetcode.com/problems/single-number/ 9 | 10 | 3 0137 https://leetcode.com/problems/single-number-ii/ 11 | 3 0260 https://leetcode.com/problems/single-number-iii/ 12 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0144/followups/followup0/Solution.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0144.followups.followup0; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * LC0144 7 | * to find the preorder predecessor of the binary tree 8 | */ 9 | @SuppressWarnings(Constant.WARNING.UNUSED) 10 | public class Solution { 11 | 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0144/followups/followup1/Solution.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0144.followups.followup1; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * LC0144 8 | * to find the successor predecessor of the binary tree 9 | */ 10 | @SuppressWarnings(Constant.WARNING.UNUSED) 11 | public class Solution { 12 | 13 | } 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0153/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Rotated Array 7 | 8 | 1 0189 https://leetcode.com/problems/rotate-array/ 9 | 10 | 3 0153 https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/ 11 | 12 | 4 0081 https://leetcode.com/problems/search-in-rotated-sorted-array-ii/ 13 | 4 0154 https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0162/followup/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/find-peak-element/ 3 | * 4 | * if the input is a 2 dimensional matrix, 5 | * instead of 1 dimensional array 6 | */ 7 | package com.idiotleon.leetcode.lvl3.lc0162.followup; 8 | 9 | public class Solution { 10 | 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0186/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Reverse the Words 7 | 8 | 1 0344 https://leetcode.com/problems/reverse-string/ 9 | 1 0345 https://leetcode.com/problems/reverse-vowels-of-a-string/ 10 | 1 0557 https://leetcode.com/problems/reverse-words-in-a-string-iii/ 11 | 12 | 2 1190 https://leetcode.com/problems/reverse-substrings-between-each-pair-of-parentheses/ 13 | 14 | 3 0151 https://leetcode.com/problems/reverse-words-in-a-string/ 15 | 3 0186 https://leetcode.com/problems/reverse-words-in-a-string-ii/ 16 | 3 0541 https://leetcode.com/problems/reverse-string-ii/ 17 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0210/followup/SolutionApproach0TopologicalSortBFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * to print out ALL valid sequences in topological order 3 | * 4 | * https://leetcode.com/problems/course-schedule-ii/ 5 | */ 6 | package com.idiotleon.leetcode.lvl3.lc0210.followup; 7 | 8 | // import java.util.List; 9 | 10 | public class SolutionApproach0TopologicalSortBFS { 11 | // public List findAllOrders(int numCourses, int[][] prerequisites){ 12 | 13 | // } 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0213/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://leetcode.com/tag/dynamic-programming/ 4 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 5 | 6 | 7 | ### House 8 | ### Robbery / Paint 9 | 10 | 2 0198 https://leetcode.com/problems/house-robber/ 11 | 12 | 3 0213 https://leetcode.com/problems/house-robber-ii/ 13 | 3 0256 https://leetcode.com/problems/paint-house/ 14 | 3 0276 https://leetcode.com/problems/paint-fence/ 15 | 16 | 4 0265 https://leetcode.com/problems/paint-house-ii/ 17 | 4 0337 https://leetcode.com/problems/house-robber-iii/ 18 | 4 1473 https://leetcode.com/problems/paint-house-iii/ 19 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0235/followup/followups.txt: -------------------------------------------------------------------------------- 1 | If either `p` or `q` is not on the tree, to return the node that is on the tree. 2 | 3 | If `p` and `q` are the same node (to return itself). 4 | 5 | to find lowest common ancestors of many nodes instead of two. 6 | 7 | 8 | https://www.youtube.com/watch?v=sD1IoalFomA -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0236/followups/followups.txt: -------------------------------------------------------------------------------- 1 | If either `p` or `q` is not on the tree, to return the node that is on the tree. 2 | 3 | If `p` and `q` are the same node (to return itself). 4 | 5 | to find lowest common ancestors of many nodes instead of two. 6 | 7 | 8 | https://www.youtube.com/watch?v=sD1IoalFomA -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0247/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Strobogrammatic Number 7 | 8 | 2 0246 https://leetcode.com/problems/strobogrammatic-number/ 9 | 10 | 3 0247 https://leetcode.com/problems/strobogrammatic-number-ii/ 11 | 12 | 4 0248 https://leetcode.com/problems/strobogrammatic-number-iii/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0256/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://leetcode.com/tag/dynamic-programming/ 4 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 5 | 6 | 7 | ### House 8 | ### Robbery / Paint 9 | 10 | 2 0198 https://leetcode.com/problems/house-robber/ 11 | 12 | 3 0213 https://leetcode.com/problems/house-robber-ii/ 13 | 3 0256 https://leetcode.com/problems/paint-house/ 14 | 3 0276 https://leetcode.com/problems/paint-fence/ 15 | 16 | 4 0265 https://leetcode.com/problems/paint-house-ii/ 17 | 4 0337 https://leetcode.com/problems/house-robber-iii/ 18 | 4 1473 https://leetcode.com/problems/paint-house-iii/ 19 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0260/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Single Number 7 | 8 | 2 0136 https://leetcode.com/problems/single-number/ 9 | 10 | 3 0137 https://leetcode.com/problems/single-number-ii/ 11 | 3 0260 https://leetcode.com/problems/single-number-iii/ 12 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0275/similar_problemx.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | 2 0274 https://leetcode.com/problems/h-index/ 7 | 8 | 3 0275 https://leetcode.com/problems/h-index-ii/ 9 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0277/FakeAPI.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0277; 2 | 3 | class FakeAPI { 4 | protected static int[][] graph = new int[10][10]; 5 | 6 | protected static boolean knows(int a, int b){ 7 | return graph[a][b] == 1; 8 | } 9 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0285/followups/followup2/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * if `p` is not guranteed to be on the tree 3 | */ 4 | package com.idiotleon.leetcode.lvl3.lc0285.followups.followup2; 5 | 6 | public class Solution { 7 | 8 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0285/followups/followup3/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * if there are nodes containing duplicates values on the tree 3 | */ 4 | package com.idiotleon.leetcode.lvl3.lc0285.followups.followup3; 5 | 6 | public class Solution { 7 | 8 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0289/followups/followup0/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/game-of-life/ 3 | * 4 | * Could you solve it in-place? 5 | * Remember that the board needs to be updated at the same time: 6 | * You cannot update some cells first and then use their updated values to update other cells. 7 | */ 8 | package com.idiotleon.leetcode.lvl3.lc0289.followups.followup0; 9 | 10 | public class Solution { 11 | 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0289/followups/followup1/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/game-of-life/ 3 | * 4 | * In this question, we represent the board using a 2D array. 5 | * In principle, the board is infinite, which would cause problems when the active area encroaches the border of the array. 6 | * How would you address these problems? 7 | */ 8 | package com.idiotleon.leetcode.lvl3.lc0289.followups.followup1; 9 | 10 | public class Solution { 11 | 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0319/SolutionAppraoch0Math.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/bulb-switcher/ 3 | * 4 | * Time Complexity: O(1) 5 | * Space Complexity: O(1) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/bulb-switcher/discuss/77112/Share-my-o(1)-solution-with-explanation 9 | * https://leetcode.com/problems/bulb-switcher/discuss/77132/The-simplest-and-most-efficient-solution-well-explained 10 | */ 11 | package com.idiotleon.leetcode.lvl3.lc0319; 12 | 13 | public class SolutionAppraoch0Math { 14 | public int bulbSwitch(int n) { 15 | return (int) Math.sqrt(n); 16 | } 17 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0322/SolutionApproach0DP2Dimen.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/coin-change/ 3 | * 4 | * Time Complexity: 5 | * Space Complexity: 6 | * 7 | * References: 8 | * https://www.youtube.com/watch?v=uUETHdijzkA 9 | * http://zxi.mytechroad.com/blog/dynamic-programming/leetcode-322-coin-change/ 10 | */ 11 | package com.idiotleon.leetcode.lvl3.lc0322; 12 | 13 | public class SolutionApproach0DP2Dimen { 14 | 15 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0338/SolutionApproach0DP1Dimen.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/counting-bits/ 3 | * 4 | * Time Complexity: O(`num`) 5 | * Space Complexity: O(`num`) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/counting-bits/discuss/657040/Java-O(n)-solution-3-lines-DP-with-explanation 9 | */ 10 | package com.idiotleon.leetcode.lvl3.lc0338; 11 | 12 | public class SolutionApproach0DP1Dimen { 13 | public int[] countBits(int num) { 14 | int[] ans = new int[num + 1]; 15 | 16 | for (int i = 1; i <= num; ++i) { 17 | ans[i] = (i % 2 == 1) ? ans[i - 1] + 1 : ans[i / 2]; 18 | } 19 | 20 | return ans; 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0340/followup/FakeCharAPI.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0340.followup; 2 | 3 | class FakeCharAPI { 4 | public char generateAChar(){ 5 | return getRandomCharacter('\u0000', '\uFFFF'); 6 | } 7 | 8 | private char getRandomCharacter(char start, char end){ 9 | return (char)(start + Math.random() * (end - start + 1)); 10 | } 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0376/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Wiggle 7 | 8 | 2 0280 https://leetcode.com/problems/wiggle-sort/ 9 | 10 | 3 0376 https://leetcode.com/problems/wiggle-subsequence/ 11 | 12 | 5 0324 https://leetcode.com/problems/wiggle-sort-ii/ 13 | 14 | Resources: 15 | https://leetcode.com/problems/wiggle-sort-ii/discuss/77684/summary-of-the-various-solutions-to-wiggle-sort-for-your-reference/81858 -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0377/followup/Solution.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0377.followup; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * LC0377 8 | *

9 | * follow up 10 | *

11 | * Reference: 12 | * LC Discussion 13 | */ 14 | @SuppressWarnings(Constant.WARNING.UNUSED) 15 | public class Solution { 16 | 17 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0416/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 3 0416 https://leetcode.com/problems/partition-equal-subset-sum/ 4 | 5 | 4 0473 https://leetcode.com/problems/matchsticks-to-square/ 6 | 4 0698 https://leetcode.com/problems/partition-to-k-equal-sum-subsets/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0430/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0430; 2 | 3 | class Node { 4 | protected int val; 5 | protected Node prev; 6 | protected Node next; 7 | protected Node child; 8 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0430/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Flatten 7 | 8 | 3 0114 https://leetcode.com/problems/flatten-binary-tree-to-linked-list/ 9 | 3 0339 https://leetcode.com/problems/nested-list-weight-sum/ 10 | 3 0341 https://leetcode.com/problems/flatten-nested-list-iterator/ 11 | 3 0430 https://leetcode.com/problems/flatten-a-multilevel-doubly-linked-list/ 12 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0437/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Path Sum 7 | 8 | 2 0112 https://leetcode.com/problems/path-sum/ 9 | 10 | 3 0064 https://leetcode.com/problems/minimum-path-sum/ 11 | 3 0113 https://leetcode.com/problems/path-sum-ii/ 12 | 3 0437 https://leetcode.com/problems/path-sum-iii/ 13 | 3 0666 https://leetcode.com/problems/path-sum-iv/ 14 | 3 0931 https://leetcode.com/problems/minimum-falling-path-sum/ 15 | 16 | 4 0124 https://leetcode.com/problems/binary-tree-maximum-path-sum/ 17 | 4 1289 https://leetcode.com/problems/minimum-falling-path-sum-ii/ 18 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0444/lc0459/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### String 7 | ## Word Pattern 8 | # KMP Algorithm 9 | 10 | 2 0028 https://leetcode.com/problems/implement-strstr/ 11 | 2 1071 https://leetcode.com/problems/greatest-common-divisor-of-strings/ 12 | 13 | 3 0459 https://leetcode.com/problems/repeated-substring-pattern/ 14 | 3 0686 https://leetcode.com/problems/repeated-string-match/ 15 | 3 1367 https://leetcode.com/problems/linked-list-in-binary-tree/ 16 | 17 | 4 1316 https://leetcode.com/problems/distinct-echo-substrings/ 18 | 19 | 5 0214 https://leetcode.com/problems/shortest-palindrome/ 20 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0450/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Constructing a Tree 7 | 8 | 1 0700 https://leetcode.com/problems/search-in-a-binary-search-tree/ 9 | 10 | 2 0617 https://leetcode.com/problems/merge-two-binary-trees/ 11 | 2 0701 https://leetcode.com/problems/insert-into-a-binary-search-tree/ 12 | 13 | 3 0450 https://leetcode.com/problems/delete-node-in-a-bst/ 14 | 3 0776 https://leetcode.com/problems/split-bst/ 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0470/FakeRand7.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0470; 2 | 3 | import java.util.Random; 4 | 5 | class FakeRand7 { 6 | protected int rand7(){ 7 | return new Random().nextInt(7); 8 | } 9 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0490/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Maze 7 | 8 | 3 0490 https://leetcode.com/problems/the-maze/ 9 | 10 | 4 0505 https://leetcode.com/problems/the-maze-ii/ 11 | 12 | 5 0499 https://leetcode.com/problems/the-maze-iii/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0494/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | ### Dynamic Programming 4 | # Knapsack 5 | 6 | 3 0494 https://leetcode.com/problems/target-sum/ 7 | 8 | 4 0474 https://leetcode.com/problems/ones-and-zeroes/ 9 | 4 0879 https://leetcode.com/problems/profitable-schemes/ 10 | 4 0956 https://leetcode.com/problems/tallest-billboard/ 11 | 4 1049 https://leetcode.com/problems/last-stone-weight-ii/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0510/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0510; 2 | 3 | class Node { 4 | protected int val; 5 | protected Node left; 6 | protected Node right; 7 | protected Node parent; 8 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0510/followup/followup0/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0510.followup.followup0; 2 | 3 | class Node { 4 | protected int val; 5 | protected Node left; 6 | protected Node right; 7 | protected Node parent; 8 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0510/followup/followup0/problem_description.txt: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Could you solve it without looking up any of the node's values? 5 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0536/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 2 0606 https://leetcode.com/problems/construct-string-from-binary-tree/ 2 | 3 | 3 0536 https://leetcode.com/problems/construct-binary-tree-from-string/ 4 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0547/SolutionApproach0DFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/friend-circles/ 3 | * 4 | * Time Complexity: O(`NR` * `NC`) 5 | * Space Complexity: O(`NR` * `NC`) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/friend-circles/discuss/101431/Stupid-question:-How-is-this-question-different-from-Number-of-Islands/332347 9 | * https://leetcode.com/problems/friend-circles/discuss/101338/Neat-DFS-java-solution/105148 10 | * https://leetcode.com/problems/friend-circles/discuss/101338/Neat-DFS-java-solution 11 | */ 12 | package com.idiotleon.leetcode.lvl3.lc0547; 13 | 14 | public class SolutionApproach0DFS { 15 | 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0628/SolutionApproachGreedy.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/maximum-product-of-three-numbers/ 3 | * 4 | * Time Complexity: O(Nlg(N)) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl3.lc0628; 8 | 9 | import java.util.Arrays; 10 | 11 | public class SolutionApproachGreedy { 12 | public int maximumProduct(int[] nums) { 13 | final int N = nums.length; 14 | Arrays.sort(nums); 15 | 16 | int sum = nums[N - 1] * nums[N - 2] * nums[N - 3]; 17 | if(nums[1] >= 0){ 18 | return sum; 19 | }else{ 20 | return Math.max(sum, nums[0] * nums[1] * nums[N - 1]); 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0659/SolutionApproach0Greedy.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/split-array-into-consecutive-subsequences/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(1) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/split-array-into-consecutive-subsequences/discuss/106495/Java-O(n)-time-and-O(1)-space-solution-greedily-extending-shorter-subsequence/309080 9 | * https://leetcode.com/problems/split-array-into-consecutive-subsequences/discuss/106495/Java-O(n)-time-and-O(1)-space-solution-greedily-extending-shorter-subsequence 10 | */ 11 | package com.idiotleon.leetcode.lvl3.lc0659; 12 | 13 | public class SolutionApproach0Greedy { 14 | 15 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0666/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Path Sum 7 | 8 | 2 0112 https://leetcode.com/problems/path-sum/ 9 | 10 | 3 0064 https://leetcode.com/problems/minimum-path-sum/ 11 | 3 0113 https://leetcode.com/problems/path-sum-ii/ 12 | 3 0437 https://leetcode.com/problems/path-sum-iii/ 13 | 3 0666 https://leetcode.com/problems/path-sum-iv/ 14 | 3 0931 https://leetcode.com/problems/minimum-falling-path-sum/ 15 | 16 | 4 0124 https://leetcode.com/problems/binary-tree-maximum-path-sum/ 17 | 4 1289 https://leetcode.com/problems/minimum-falling-path-sum-ii/ 18 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0670/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Math 7 | 8 | 3 0060 https://leetcode.com/problems/permutation-sequence/ 9 | 3 0670 https://leetcode.com/problems/maximum-swap/ 10 | 3 1053 https://leetcode.com/problems/previous-permutation-with-one-swap/ 11 | 12 | 4 0031 https://leetcode.com/problems/next-permutation/ 13 | 4 0556 https://leetcode.com/problems/next-greater-element-iii/ 14 | 15 | 16 | previous permutation -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0684/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Redundant Connection 7 | 8 | 3 0684 https://leetcode.com/problems/redundant-connection/ 9 | 10 | 5 0685 https://leetcode.com/problems/redundant-connection-ii/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0686/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### String 7 | ## Word Pattern 8 | # KMP Algorithm 9 | 10 | 2 0028 https://leetcode.com/problems/implement-strstr/ 11 | 2 1071 https://leetcode.com/problems/greatest-common-divisor-of-strings/ 12 | 13 | 3 0459 https://leetcode.com/problems/repeated-substring-pattern/ 14 | 3 0686 https://leetcode.com/problems/repeated-string-match/ 15 | 3 1367 https://leetcode.com/problems/linked-list-in-binary-tree/ 16 | 17 | 4 1316 https://leetcode.com/problems/distinct-echo-substrings/ 18 | 19 | 5 0214 https://leetcode.com/problems/shortest-palindrome/ 20 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0702/FakeArrayReader.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/search-in-a-sorted-array-of-unknown-size/ 3 | */ 4 | package com.idiotleon.leetcode.lvl3.lc0702; 5 | 6 | public class FakeArrayReader { 7 | public int get(int pos){ 8 | return -1; 9 | } 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0708/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc0708; 2 | 3 | class Node { 4 | protected int val; 5 | protected Node next; 6 | 7 | protected Node(){} 8 | 9 | protected Node(int val){ 10 | this.val = val; 11 | } 12 | 13 | protected Node(int val, Node next){ 14 | this.val = val; 15 | this.next = next; 16 | } 17 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0732/SolutionApproach0ArrayOfBSTs.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/design-hashset/ 3 | * 4 | * 5 | * 6 | * References: 7 | * https://leetcode.com/problems/design-hashset/discuss/170092/can-you-guys-think-before-doing/244716 8 | */ 9 | package com.idiotleon.leetcode.lvl3.lc0732; 10 | 11 | public class SolutionApproach0ArrayOfBSTs { 12 | 13 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0737/followup/SolutionApproach0UnionFind.java: -------------------------------------------------------------------------------- 1 | /** 2 | * preprocessing for multiple queries 3 | * 4 | * Union by rank/size 5 | * Path compression 6 | * 7 | * References: 8 | * https://leetcode.com/problems/sentence-similarity-ii/discuss/109764/Real-interview-follow-up%3A-preprocessing-for-multiple-queries 9 | */ 10 | package com.idiotleon.leetcode.lvl3.lc0737.followup; 11 | 12 | public class SolutionApproach0UnionFind { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0737/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 3 1061 https://leetcode.com/problems/lexicographically-smallest-equivalent-string/ 2 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0750/SolutionApproach0DP.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/number-of-corner-rectangles/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/number-of-corner-rectangles/discuss/148531/Very-fast-Java-DP-solution 9 | */ 10 | package com.idiotleon.leetcode.lvl3.lc0750; 11 | 12 | public class SolutionApproach0DP { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0750/followup/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/number-of-corner-rectangles/ 3 | * 4 | * If the corner rectangles can be formed by any values 5 | */ 6 | package com.idiotleon.leetcode.lvl3.lc0750.followup; 7 | 8 | public class Solution { 9 | 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0763/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Greedy 7 | 8 | 2 1375 https://leetcode.com/problems/bulb-switcher-iii/ 9 | 10 | 3 0763 https://leetcode.com/problems/partition-labels/description/ 11 | 12 | 4 0769 https://leetcode.com/problems/max-chunks-to-make-sorted/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0776/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 1 0700 https://leetcode.com/problems/search-in-a-binary-search-tree/ 2 | 3 | 2 0617 https://leetcode.com/problems/merge-two-binary-trees/ 4 | 2 0701 https://leetcode.com/problems/insert-into-a-binary-search-tree/ 5 | 6 | 3 0450 https://leetcode.com/problems/delete-node-in-a-bst/ 7 | 3 0776 https://leetcode.com/problems/split-bst/ 8 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0785/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Bipartition 7 | 8 | 3 0785 https://leetcode.com/problems/is-graph-bipartite/ 9 | 3 0886 https://leetcode.com/problems/possible-bipartition/ 10 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0886/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Bipartition 7 | 8 | 3 0785 https://leetcode.com/problems/is-graph-bipartite/ 9 | 3 0886 https://leetcode.com/problems/possible-bipartition/ 10 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0904/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Longest Subarray 7 | 8 | 3 0904 https://leetcode.com/problems/fruit-into-baskets/ 9 | 10 | 4 0159 https://leetcode.com/problems/longest-substring-with-at-most-two-distinct-characters/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0922/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### High Low Pointers 7 | 8 | 1 0905 https://leetcode.com/problems/sort-array-by-parity/ 9 | 10 | 2 0283 https://leetcode.com/problems/move-zeroes/ 11 | 12 | 3 0922 https://leetcode.com/problems/sort-array-by-parity-ii/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0966/SolutionApproach0Trie.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/vowel-spellchecker/ 3 | * 4 | * References: 5 | * https://leetcode.com/problems/vowel-spellchecker/discuss/240156/Java-TrieTree-beats-100 6 | */ 7 | package com.idiotleon.leetcode.lvl3.lc0966; 8 | 9 | public class SolutionApproach0Trie { 10 | 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0969/SolutionApproach0Stack.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/pancake-sorting/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(N) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/pancake-sorting/discuss/494417/Dew-It-or-True-O(n)-or-Explained-with-Diagrams 9 | */ 10 | package com.idiotleon.leetcode.lvl3.lc0969; 11 | 12 | public class SolutionApproach0Stack { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0987/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 4 | 3 0987 https://leetcode.com/problems/vertical-order-traversal-of-a-binary-tree/ 5 | 6 | 4 0314 https://leetcode.com/problems/binary-tree-vertical-order-traversal/ 7 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc0990/SolutionApproach0DFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/satisfiability-of-equality-equations/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/satisfiability-of-equality-equations/discuss/271948/Java-Union-Find(100)-and-DFS(98) 9 | */ 10 | package com.idiotleon.leetcode.lvl3.lc0990; 11 | 12 | public class SolutionApproach0DFS { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1020/SolutionAppraoch1UnionFind.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/number-of-enclaves/ 3 | */ 4 | package com.idiotleon.leetcode.lvl3.lc1020; 5 | 6 | public class SolutionAppraoch1UnionFind { 7 | 8 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1023/SolutionApproach2Regex.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/camelcase-matching/ 3 | */ 4 | package com.idiotleon.leetcode.lvl3.lc1023; 5 | 6 | import java.util.Arrays; 7 | import java.util.List; 8 | import java.util.stream.Collectors; 9 | 10 | public class SolutionApproach2Regex { 11 | public List camelMatch(String[] queries, String pattern) { 12 | return Arrays.stream(queries).map(q -> q.matches("[a-z]*" + String.join("[a-z]*", pattern.split("")) + "[a-z]*")).collect(Collectors.toList()); 13 | } 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1031/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Prefix Sums 7 | 8 | 3 1031 https://leetcode.com/problems/maximum-sum-of-two-non-overlapping-subarrays/ 9 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1033/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 3 1033 https://leetcode.com/problems/moving-stones-until-consecutive/ 4 | 5 | 4 1040 https://leetcode.com/problems/moving-stones-until-consecutive-ii/ 6 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1053/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Math 7 | 8 | 3 0060 https://leetcode.com/problems/permutation-sequence/ 9 | 3 0670 https://leetcode.com/problems/maximum-swap/ 10 | 3 1053 https://leetcode.com/problems/previous-permutation-with-one-swap/ 11 | 12 | 4 0031 https://leetcode.com/problems/next-permutation/ 13 | 4 0556 https://leetcode.com/problems/next-greater-element-iii/ 14 | 15 | 16 | previous permutation -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1054/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 3 0621 https://leetcode.com/problems/task-scheduler/ 2 | 3 | 4 0358 https://leetcode.com/problems/rearrange-string-k-distance-apart/ 4 | 5 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1055/followups/followup1/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/shortest-way-to-form-string/ 3 | * 4 | * Can this be implemented with O(1) space? 5 | * 6 | * References: 7 | * https://leetcode.com/problems/shortest-way-to-form-string/discuss/330938/Accept-is-not-enough-to-get-a-hire.-Interviewee-4-follow-up 8 | */ 9 | package com.idiotleon.leetcode.lvl3.lc1055.followups.followup1; 10 | 11 | public class Solution { 12 | 13 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1055/followups/followup2/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/shortest-way-to-form-string/ 3 | * 4 | * 5 | * References: 6 | * https://leetcode.com/problems/shortest-way-to-form-string/discuss/330938/Accept-is-not-enough-to-get-a-hire.-Interviewee-4-follow-up 7 | */ 8 | package com.idiotleon.leetcode.lvl3.lc1055.followups.followup2; 9 | 10 | public class Solution { 11 | 12 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1055/followups/followup3/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/shortest-way-to-form-string/ 3 | * 4 | * 5 | * References: 6 | * https://leetcode.com/problems/shortest-way-to-form-string/discuss/330938/Accept-is-not-enough-to-get-a-hire.-Interviewee-4-follow-up 7 | */ 8 | package com.idiotleon.leetcode.lvl3.lc1055.followups.followup3; 9 | 10 | public class Solution { 11 | 12 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1055/followups/followup4/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/shortest-way-to-form-string/ 3 | * 4 | * 5 | * References: 6 | * https://leetcode.com/problems/shortest-way-to-form-string/discuss/330938/Accept-is-not-enough-to-get-a-hire.-Interviewee-4-follow-up 7 | */ 8 | package com.idiotleon.leetcode.lvl3.lc1055.followups.followup4; 9 | 10 | public class Solution { 11 | 12 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1061/SolutionApproach1BFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/lexicographically-smallest-equivalent-string/ 3 | * 4 | * References: 5 | * https://leetcode.com/problems/lexicographically-smallest-equivalent-string/discuss/412777/python-bfsdfsunion-find-complexity-analysis 6 | */ 7 | package com.idiotleon.leetcode.lvl3.lc1061; 8 | 9 | public class SolutionApproach1BFS { 10 | 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1061/SolutionApproach1DFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/lexicographically-smallest-equivalent-string/ 3 | * 4 | * References: 5 | * https://leetcode.com/problems/lexicographically-smallest-equivalent-string/discuss/412777/python-bfsdfsunion-find-complexity-analysis 6 | */ 7 | package com.idiotleon.leetcode.lvl3.lc1061; 8 | 9 | public class SolutionApproach1DFS { 10 | 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1061/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 3 0737 https://leetcode.com/problems/sentence-similarity-ii/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1109/SolutionApproach0SegmentTree.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/corporate-flight-bookings/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/corporate-flight-bookings/discuss/328866/Python-Segment-Tree-with-explanation-(not-optimal-solution) 9 | */ 10 | package com.idiotleon.leetcode.lvl3.lc1109; 11 | 12 | public class SolutionApproach0SegmentTree { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1139/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 3 1139 https://leetcode.com/problems/largest-1-bordered-square/ 2 | 3 | 4 0221 https://leetcode.com/problems/maximal-square/ 4 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1201/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Ugly Numbers 7 | 8 | 2 0263 https://leetcode.com/problems/ugly-number/ 9 | 10 | 3 1201 https://leetcode.com/problems/ugly-number-iii/ 11 | 12 | 4 0264 https://leetcode.com/problems/ugly-number-ii/ 13 | 4 0313 https://leetcode.com/problems/super-ugly-number/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1236/FakeHtmlParser.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc1236; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class FakeHtmlParser { 7 | public List getUrls(String url){ 8 | return new ArrayList(); 9 | } 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1245/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Diameter 7 | 8 | 3 0543 https://leetcode.com/problems/diameter-of-binary-tree/ 9 | 3 1245 https://leetcode.com/problems/tree-diameter/ 10 | 3 1522 https://leetcode.com/problems/diameter-of-n-ary-tree/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1249/followup/SolutionApproach0Backtrack.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/ 3 | * 4 | * could you please return all possible valid strings with minimum removals? 5 | */ 6 | package com.idiotleon.leetcode.lvl3.lc1249.followup; 7 | 8 | public class SolutionApproach0Backtrack { 9 | 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1272/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/remove-interval/ 3 | * 4 | * if the input list/array is NOT sorted, 5 | * without sorting it, 6 | * how to solve the problem? 7 | * 8 | * 9 | * References: 10 | * https://leetcode.com/problems/remove-interval/discuss/611264/Java-Clean-Code-(Sorted-%2B-Unsorted-array) 11 | */ 12 | package com.idiotleon.leetcode.lvl3.lc1272; 13 | 14 | public class Solution { 15 | 16 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1272/followup/followup1/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/remove-interval/ 3 | * 4 | * if "toBeRemoved" consists of more than one time slots, how to solve it? 5 | */ 6 | package com.idiotleon.leetcode.lvl3.lc1272.followup.followup1; 7 | 8 | public class Solution { 9 | 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1275/followup/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | * 4 | * References: 5 | * https://leetcode.com/problems/find-winner-on-a-tic-tac-toe-game/discuss/490101/Java-100-with-comments-and-Interview-tip 6 | */ 7 | package com.idiotleon.leetcode.lvl3.lc1275.followup; 8 | 9 | public class Solution { 10 | 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1306/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Jump Game 7 | 8 | 3 0055 https://leetcode.com/problems/jump-game/ 9 | 3 1306 https://leetcode.com/problems/jump-game-iii/ 10 | 11 | 4 0045 https://leetcode.com/problems/jump-game-ii/ 12 | 4 1340 https://leetcode.com/problems/jump-game-v/ 13 | 4 1345 https://leetcode.com/problems/jump-game-iv/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1353/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | 7 | ### Segment Tree 8 | 9 | 10 | 11 | ### Segment Tree 12 | ## Resources: 13 | https://leetcode.com/problems/my-calendar-ii/discuss/109528/nlogd-Java-solution-using-segment-tree-with-lazy-propagation-(for-the-general-case-of-K-booking) 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1367/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### String 7 | ## Word Pattern 8 | # KMP Algorithm 9 | 10 | 2 0028 https://leetcode.com/problems/implement-strstr/ 11 | 2 1071 https://leetcode.com/problems/greatest-common-divisor-of-strings/ 12 | 13 | 3 0459 https://leetcode.com/problems/repeated-substring-pattern/ 14 | 3 0686 https://leetcode.com/problems/repeated-string-match/ 15 | 3 1367 https://leetcode.com/problems/linked-list-in-binary-tree/ 16 | 17 | 4 1316 https://leetcode.com/problems/distinct-echo-substrings/ 18 | 19 | 5 0214 https://leetcode.com/problems/shortest-palindrome/ 20 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1382/SolutionApproach0DSWAlgorithm.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/balance-a-binary-search-tree/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(1) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/balance-a-binary-search-tree/discuss/541785/C%2B%2BJava-with-picture-DSW-O(n)orO(1) 9 | */ 10 | package com.idiotleon.leetcode.lvl3.lc1382; 11 | 12 | public class SolutionApproach0DSWAlgorithm { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1391/SolutionApproach1UnionFind.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/check-if-there-is-a-valid-path-in 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/check-if-there-is-a-valid-path-in-a-grid/discuss/547229/Python-Union-Find 9 | */ 10 | package com.idiotleon.leetcode.lvl3.lc1391; 11 | 12 | public class SolutionApproach1UnionFind { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1415/SolutionApproach0BFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/the-k-th-lexicographical-string-of-all-happy-strings-of-length-n/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/the-k-th-lexicographical-string-of-all-happy-strings-of-length-n/discuss/585569/Easiest-solution-using-bfs-C%2B%2B 9 | */ 10 | package com.idiotleon.leetcode.lvl3.lc1415; 11 | 12 | public class SolutionApproach0BFS { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1485/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc1485; 2 | 3 | class Node { 4 | protected int val; 5 | protected Node left; 6 | protected Node right; 7 | protected Node random; 8 | 9 | protected Node(int val){ 10 | this.val = val; 11 | this.left = this.right = this.random = null; 12 | } 13 | 14 | protected Node(int val, Node left, Node right, Node random){ 15 | this.val = val; 16 | this.left = left; 17 | this.right = right; 18 | this.random = random; 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1485/NodeCopy.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc1485; 2 | 3 | class NodeCopy { 4 | protected int val; 5 | protected NodeCopy left; 6 | protected NodeCopy right; 7 | protected NodeCopy random; 8 | 9 | protected NodeCopy(int val){ 10 | this.val = val; 11 | this.left = this.right = this.random = null; 12 | } 13 | 14 | protected NodeCopy(int val, NodeCopy left, NodeCopy right, NodeCopy random){ 15 | this.val = val; 16 | this.left = left; 17 | this.right = right; 18 | this.random = random; 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1498/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 2 0001 https://leetcode.com/problems/two-sum/ 4 | 5 | 3 1498 https://leetcode.com/problems/number-of-subsequences-that-satisfy-the-given-sum-condition/ 6 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1522/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Diameter 7 | 8 | 3 0543 https://leetcode.com/problems/diameter-of-binary-tree/ 9 | 3 1245 https://leetcode.com/problems/tree-diameter/ 10 | 3 1522 https://leetcode.com/problems/diameter-of-n-ary-tree/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1612/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc1612; 2 | 3 | class Node { 4 | protected char val; 5 | protected Node left; 6 | protected Node right; 7 | 8 | protected Node() { 9 | this.val = ' '; 10 | } 11 | 12 | protected Node(char val) { 13 | this.val = val; 14 | } 15 | 16 | protected Node(char val, Node left, Node right) { 17 | this.val = val; 18 | this.left = left; 19 | this.right = right; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl3/lc1660/SolutionApproach0BFS.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl3.lc1660; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * LC1660 8 | *

9 | * Time Complexity: O() 10 | * Space Complexity: O() 11 | *

12 | * Reference: 13 | * LCDiscussion 14 | * LCDiscussion 15 | */ 16 | @SuppressWarnings(Constant.WARNING.UNUSED) 17 | public class SolutionApproach0BFS { 18 | 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/all_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://docs.google.com/spreadsheets/d/1VMMHp5Qd_RmCoRKaNiE5wRs0dftXHzUTrlgQVZVleBg/edit#gid=838109710 4 | 5 | 6 | ### Level 4 7 | 8 | 4 0132 https://leetcode.com/problems/palindrome-partitioning-ii/ 9 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0023/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Binary Search Tree 7 | 8 | 2 1305 https://leetcode.com/problems/all-elements-in-two-binary-search-trees/ 9 | 10 | 3 0173 https://leetcode.com/problems/binary-search-tree-iterator/ 11 | 12 | 4 0023 https://leetcode.com/problems/merge-k-sorted-lists/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0025/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Reverse a Linked List 7 | 8 | 2 0206 https://leetcode.com/problems/reverse-linked-list/ 9 | 10 | 3 0092 https://leetcode.com/problems/reverse-linked-list-ii/ 11 | 12 | 4 0025 https://leetcode.com/problems/reverse-nodes-in-k-group/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0031/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://docs.google.com/spreadsheets/d/1VMMHp5Qd_RmCoRKaNiE5wRs0dftXHzUTrlgQVZVleBg/edit#gid=2064608444 4 | 5 | 6 | ### Math 7 | 8 | 3 0060 https://leetcode.com/problems/permutation-sequence/ 9 | 3 0670 https://leetcode.com/problems/maximum-swap/ 10 | 3 1053 https://leetcode.com/problems/previous-permutation-with-one-swap/ 11 | 12 | 4 0031 https://leetcode.com/problems/next-permutation/ 13 | 4 0556 https://leetcode.com/problems/next-greater-element-iii/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0045/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Jump Game 7 | 8 | 3 0055 https://leetcode.com/problems/jump-game/ 9 | 3 1306 https://leetcode.com/problems/jump-game-iii/ 10 | 11 | 4 0045 https://leetcode.com/problems/jump-game-ii/ 12 | 4 1340 https://leetcode.com/problems/jump-game-v/ 13 | 4 1345 https://leetcode.com/problems/jump-game-iv/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0051/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### N-queens 7 | 8 | 4 0051 https://leetcode.com/problems/n-queens/ 9 | 4 0052 https://leetcode.com/problems/n-queens-ii/ 10 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0072/followups/followup0/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/edit-distance/ 3 | * could you please return: 4 | * 1. the actual edit: whether to insert, delete, or replace 5 | * 2. the start index of such an edit 6 | * 3. what is part/content before and after the edit? 7 | * 8 | * the return types are flexible 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc0072.followups.followup0; 11 | 12 | public class Solution { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0076/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Minimum Window 7 | 8 | 4 0076 https://leetcode.com/problems/minimum-window-substring/ 9 | 4 0727 https://leetcode.com/problems/minimum-window-subsequence/ 10 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0079/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Word Series 7 | 8 | 2 0433 https://leetcode.com/problems/minimum-genetic-mutation/ 9 | 10 | 4 0079 https://leetcode.com/problems/word-search/ 11 | 4 0126 https://leetcode.com/problems/word-ladder-ii/ 12 | 4 0127 https://leetcode.com/problems/word-ladder/ 13 | 4 0139 https://leetcode.com/problems/word-break/ 14 | 15 | 5 0140 https://leetcode.com/problems/word-break-ii/ 16 | 5 0212 https://leetcode.com/problems/word-search-ii/ 17 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0081/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Rotated Array 7 | 8 | 1 0189 https://leetcode.com/problems/rotate-array/ 9 | 10 | 3 0153 https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/ 11 | 12 | 4 0081 https://leetcode.com/problems/search-in-rotated-sorted-array-ii/ 13 | 4 0154 https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0084/followup/followup0/problem_description.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://leetcode.com/problems/largest-rectangle-in-histogram/ 4 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 5 | 6 | 7 | ### Problem Description 8 | 9 | to get the largest rectangle, with one cerntain column included 10 | 11 | e.g.: 12 | to get the largest rectangle, with x = 3 (heights[3]) included 13 | 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0117/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0117; 2 | 3 | class Node { 4 | protected int val; 5 | protected Node left; 6 | protected Node right; 7 | protected Node next; 8 | 9 | protected Node(){} 10 | 11 | protected Node(int val){ 12 | this.val = val; 13 | } 14 | 15 | protected Node(int val, Node left, Node right, Node next){ 16 | this.val = val; 17 | this.left = left; 18 | this.right = right; 19 | this.next = next; 20 | } 21 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0117/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 3 0116 https://leetcode.com/problems/populating-next-right-pointers-in-each-node/ 4 | 5 | 4 0117 https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/ 6 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0120/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | # Triangle 7 | 8 | 2 0118 https://leetcode.com/problems/pascals-triangle/ 9 | 2 0976 https://leetcode.com/problems/largest-perimeter-triangle/ 10 | 11 | 3 0119 https://leetcode.com/problems/pascals-triangle-ii/ 12 | 3 0611 https://leetcode.com/problems/valid-triangle-number/ 13 | 14 | 4 0120 https://leetcode.com/problems/triangle/ 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0124/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Path Sum 7 | 8 | 2 0112 https://leetcode.com/problems/path-sum/ 9 | 10 | 3 0064 https://leetcode.com/problems/minimum-path-sum/ 11 | 3 0113 https://leetcode.com/problems/path-sum-ii/ 12 | 3 0437 https://leetcode.com/problems/path-sum-iii/ 13 | 3 0666 https://leetcode.com/problems/path-sum-iv/ 14 | 3 0931 https://leetcode.com/problems/minimum-falling-path-sum/ 15 | 16 | 4 0124 https://leetcode.com/problems/binary-tree-maximum-path-sum/ 17 | 4 1289 https://leetcode.com/problems/minimum-falling-path-sum-ii/ 18 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0126/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Word Series 7 | 8 | 2 0433 https://leetcode.com/problems/minimum-genetic-mutation/ 9 | 10 | 4 0079 https://leetcode.com/problems/word-search/ 11 | 4 0126 https://leetcode.com/problems/word-ladder-ii/ 12 | 4 0127 https://leetcode.com/problems/word-ladder/ 13 | 4 0139 https://leetcode.com/problems/word-break/ 14 | 15 | 5 0140 https://leetcode.com/problems/word-break-ii/ 16 | 5 0212 https://leetcode.com/problems/word-search-ii/ 17 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0127/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Word Series 7 | 8 | 2 0433 https://leetcode.com/problems/minimum-genetic-mutation/ 9 | 10 | 4 0079 https://leetcode.com/problems/word-search/ 11 | 4 0126 https://leetcode.com/problems/word-ladder-ii/ 12 | 4 0127 https://leetcode.com/problems/word-ladder/ 13 | 4 0139 https://leetcode.com/problems/word-break/ 14 | 15 | 5 0140 https://leetcode.com/problems/word-break-ii/ 16 | 5 0212 https://leetcode.com/problems/word-search-ii/ 17 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0138/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0138; 2 | 3 | class Node { 4 | protected int val; 5 | protected Node random; 6 | protected Node next; 7 | 8 | protected Node(int val) { 9 | this.val = val; 10 | this.random = null; 11 | this.next = null; 12 | } 13 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0138/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Deep Clone 7 | 8 | 3 0133 https://leetcode.com/problems/clone-graph/ 9 | 10 | 4 0138 https://leetcode.com/problems/copy-list-with-random-pointer/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0154/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Rotated Array 7 | 8 | 1 0189 https://leetcode.com/problems/rotate-array/ 9 | 10 | 3 0153 https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/ 11 | 12 | 4 0081 https://leetcode.com/problems/search-in-rotated-sorted-array-ii/ 13 | 4 0154 https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0158/FakeReader4.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0158; 2 | 3 | class FakeReader4 { 4 | protected int read4(char[] buf4) { 5 | return 4; 6 | } 7 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0159/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Longest Subarray 7 | ### Two Distinct 8 | 9 | 3 0904 https://leetcode.com/problems/fruit-into-baskets/ 10 | 11 | 4 0159 https://leetcode.com/problems/longest-substring-with-at-most-two-distinct-characters/ 12 | 13 | 14 | 15 | ### Sliding Window -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0161/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Edit Distance 7 | 8 | 4 0072 https://leetcode.com/problems/edit-distance/ 9 | 4 0161 https://leetcode.com/problems/one-edit-distance/ 10 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0162/SolutionApproachIterativeBinarySearch.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/find-peak-element/ 3 | */ 4 | package com.idiotleon.leetcode.lvl4.lc0162; 5 | 6 | public class SolutionApproachIterativeBinarySearch { 7 | public int findPeakElement(int[] nums) { 8 | int left = 0, right = nums.length - 1; 9 | 10 | while(left < right){ 11 | int mid = left + (right - left) / 2; 12 | 13 | if(nums[mid] > nums[mid + 1]) right = mid; 14 | else left = mid + 1; 15 | } 16 | 17 | return left; 18 | } 19 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0162/SolutionApproachLinearScan.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/find-peak-element/ 3 | */ 4 | package com.idiotleon.leetcode.lvl4.lc0162; 5 | 6 | public class SolutionApproachLinearScan { 7 | public int findPeakElement(int[] nums) { 8 | for(int i = 0; i < nums.length - 1; i++){ 9 | if(nums[i] > nums[i + 1]){ 10 | return i; 11 | } 12 | } 13 | 14 | return nums.length - 1; 15 | } 16 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0162/SolutionApproachRecursiveBinarySearch.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/find-peak-element/ 3 | */ 4 | package com.idiotleon.leetcode.lvl4.lc0162; 5 | 6 | class SolutionApproachRecursiveBinarySearch { 7 | public int findPeakElement(int[] nums) { 8 | return search(nums, 0, nums.length - 1); 9 | } 10 | 11 | private int search(int[] nums, int left, int right){ 12 | if(left == right) return left; 13 | int mid = left + (right - left) / 2; 14 | if(nums[mid] > nums[mid + 1]) 15 | return search(nums, left, mid); 16 | 17 | return search(nums, mid + 1, right); 18 | } 19 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0201/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/bitwise-and-of-numbers-range/ 3 | */ 4 | package com.idiotleon.leetcode.lvl4.lc0201; 5 | 6 | class Solution { 7 | public int rangeBitwiseAnd(int m, int n) { 8 | int i = 0; 9 | for(; m != n; ++i){ 10 | m >>= 1; 11 | n >>= 1; 12 | } 13 | 14 | return n << i; 15 | } 16 | 17 | public int rangeBitwiseAnd2(int m, int n) { 18 | while(m < n){ 19 | n = n & (n - 1); 20 | } 21 | 22 | return n; 23 | } 24 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0218/SolutionApproach0BinaryIndexedTree.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0218; 2 | 3 | public class SolutionApproach0BinaryIndexedTree { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0221/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 3 1139 https://leetcode.com/problems/largest-1-bordered-square/ 2 | 3 | 4 0221 https://leetcode.com/problems/maximal-square/ 4 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0239/SolutionApproach1BST.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/sliding-window-maximum/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * http://zxi.mytechroad.com/blog/heap/leetcode-239-sliding-window-maximum/ 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc0239; 11 | 12 | public class SolutionApproach1BST { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0240/SolutionApproachOnePass.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/search-a-2d-matrix-ii/ 3 | */ 4 | package com.idiotleon.leetcode.lvl4.lc0240; 5 | 6 | public class SolutionApproachOnePass { 7 | public boolean searchMatrix(int[][] matrix, int target) { 8 | // sanity check 9 | if(matrix == null || matrix.length == 0) return false; 10 | 11 | int row = matrix.length - 1, col = 0; 12 | while(row >= 0 && col < matrix[0].length){ 13 | if(matrix[row][col] > target) row--; 14 | else if(matrix[row][col] < target) col++; 15 | else return true; 16 | } 17 | 18 | return false; 19 | } 20 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0248/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Strobogrammatic Number 7 | 8 | 2 0246 https://leetcode.com/problems/strobogrammatic-number/ 9 | 10 | 3 0247 https://leetcode.com/problems/strobogrammatic-number-ii/ 11 | 12 | 4 0248 https://leetcode.com/problems/strobogrammatic-number-iii/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0264/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Ugly Numbers 7 | 8 | 2 0263 https://leetcode.com/problems/ugly-number/ 9 | 10 | 3 1201 https://leetcode.com/problems/ugly-number-iii/ 11 | 12 | 4 0264 https://leetcode.com/problems/ugly-number-ii/ 13 | 4 0313 https://leetcode.com/problems/super-ugly-number/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0295/SolutionApproach0BalancedBST.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/find-median-from-data-stream/ 3 | * 4 | * 5 | */ 6 | package com.idiotleon.leetcode.lvl4.lc0295; 7 | 8 | public class SolutionApproach0BalancedBST { 9 | 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0295/followups/FollowUp1.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/find-median-from-data-stream/ 3 | * Followup #1 - If all integer numbers from the stream are between 0 and 100, how would you optimize it 4 | * 5 | * References: 6 | * https://leetcode.com/problems/find-median-from-data-stream/discuss/343662/JAVA-HEAP-SOLUTION-%2B-2-FOLLOW-UPS 7 | */ 8 | package com.idiotleon.leetcode.lvl4.lc0295.followups; 9 | 10 | public class FollowUp1 { 11 | 12 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0295/followups/FollowUp2.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/find-median-from-data-stream/ 3 | * Followup #2 - If 99% of all integer numbers from the stream are between 0 and 100, how would you optimize it? 4 | * 5 | * References: 6 | * https://leetcode.com/problems/find-median-from-data-stream/discuss/343662/JAVA-HEAP-SOLUTION-%2B-2-FOLLOW-UPS 7 | * https://leetcode.com/problems/find-median-from-data-stream/discuss/275207/Solutions-to-follow-ups 8 | * 9 | * Similar Problems: 10 | * https://leetcode.com/problems/statistics-from-a-large-sample/description/ 11 | */ 12 | package com.idiotleon.leetcode.lvl4.lc0295.followups; 13 | 14 | public class FollowUp2 { 15 | 16 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0295/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Median 7 | 8 | 4 0239 https://leetcode.com/problems/sliding-window-maximum/ 9 | 4 0295 https://leetcode.com/problems/find-median-from-data-stream/ 10 | 11 | 5 0004 https://leetcode.com/problems/median-of-two-sorted-arrays/ 12 | 5 0480 https://leetcode.com/problems/sliding-window-median/ 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0313/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Ugly Numbers 7 | 8 | 2 0263 https://leetcode.com/problems/ugly-number/ 9 | 10 | 3 1201 https://leetcode.com/problems/ugly-number-iii/ 11 | 12 | 4 0264 https://leetcode.com/problems/ugly-number-ii/ 13 | 4 0313 https://leetcode.com/problems/super-ugly-number/ 14 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0314/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 4 | 3 0987 https://leetcode.com/problems/vertical-order-traversal-of-a-binary-tree/ 5 | 6 | 4 0314 https://leetcode.com/problems/binary-tree-vertical-order-traversal/ 7 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0317/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Islands 7 | 8 | 2 0695 https://leetcode.com/problems/max-area-of-island/ 9 | 10 | 3 0130 https://leetcode.com/problems/surrounded-regions/ 11 | 3 0200 https://leetcode.com/problems/number-of-islands/ 12 | 13 | 4 0317 https://leetcode.com/problems/shortest-distance-from-all-buildings/ 14 | 4 0839 https://leetcode.com/problems/similar-string-groups/ 15 | 4 0947 https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/ 16 | 17 | 5 0827 https://leetcode.com/problems/making-a-large-island/ 18 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0358/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Single Threaded 7 | ## CPU 8 | 9 | 4 0621 https://leetcode.com/problems/task-scheduler/ 10 | 4 0636 https://leetcode.com/problems/exclusive-time-of-functions/ 11 | 12 | 13 | 14 | ### k Distance Apart 15 | ### No Adjacency 16 | 17 | 2 0767 https://leetcode.com/problems/reorganize-string/ 18 | 19 | 4 0358 https://leetcode.com/problems/rearrange-string-k-distance-apart/ 20 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0395/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### String 7 | ### Longest vs Shortest 8 | ### Substring 9 | 10 | 3 0424 https://leetcode.com/problems/longest-repeating-character-replacement/ 11 | 12 | 4 0076 https://leetcode.com/problems/minimum-window-substring/ 13 | 4 0340 https://leetcode.com/problems/longest-substring-with-at-most-k-distinct-characters/ 14 | 4 0395 https://leetcode.com/problems/longest-substring-with-at-least-k-repeating-characters/ 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0399/SolutionApproach0BFS.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0399; 2 | 3 | import com.idiotleon.util.Constant; 4 | 5 | /** 6 | * @author: Leon 7 | * LC0309 8 | *

9 | * Time Complexity: O() 10 | * Space Complexity: O() 11 | */ 12 | @SuppressWarnings(Constant.WARNING.UNUSED) 13 | public class SolutionApproach0BFS { 14 | 15 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0399/SolutionApproach1FloydWarshall.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0399; 2 | 3 | /** 4 | * @author: Leon 5 | * LC0399 6 | *

7 | * Time Complexity: O() 8 | * Space Complexity: O() 9 | *

10 | * Reference: 11 | * LC Discussion 12 | * LC Discussion 13 | */ 14 | public class SolutionApproach1FloydWarshall { 15 | 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0410/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://leetcode.com/problems/split-array-largest-sum/ 4 | https://www.youtube.com/watch?v=FLbqgyJ-70I&t=142s 5 | 6 | 7 | 8 | ### Dynamic Programming 9 | 10 | 4 0410 https://leetcode.com/problems/split-array-largest-sum/ 11 | 4 0813 https://leetcode.com/problems/largest-sum-of-averages/ 12 | 4 1278 https://leetcode.com/problems/palindrome-partitioning-iii/ 13 | 4 1335 https://leetcode.com/problems/minimum-difficulty-of-a-job-schedule/ 14 | 15 | 16 | 17 | ### Trial and Error - Binary Search 18 | 19 | 4 1011 https://leetcode.com/problems/capacity-to-ship-packages-within-d-days/ 20 | 4 1231 https://leetcode.com/problems/divide-chocolate/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0474/SolutionApproach0DFSMemo.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/ones-and-zeroes/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/ones-and-zeroes/discuss/95845/Easy-to-understand-Recursive-Solutions-in-Java-with-Explanation 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc0474; 11 | 12 | public class SolutionApproach0DFSMemo { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0474/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | ### Dynamic Programming 4 | # Knapsack 5 | 6 | 3 0494 https://leetcode.com/problems/target-sum/ 7 | 8 | 4 0474 https://leetcode.com/problems/ones-and-zeroes/ 9 | 4 0879 https://leetcode.com/problems/profitable-schemes/ 10 | 4 0956 https://leetcode.com/problems/tallest-billboard/ 11 | 4 1049 https://leetcode.com/problems/last-stone-weight-ii/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0489/FakeRobot.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0489; 2 | 3 | public class FakeRobot { 4 | public boolean move(){ 5 | return true; 6 | } 7 | 8 | public void turnLeft(){ 9 | 10 | } 11 | 12 | public void turnRight(){ 13 | 14 | } 15 | 16 | public void clean(){ 17 | 18 | } 19 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0505/SolutionApproach1DjikstrasAlgorithm.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/the-maze-ii/ 3 | * 4 | * Time Complexity: O((NR * NC) ^ 2) 5 | * Space Complexity: O(NR * NotCompliantMBeanException) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/the-maze-ii/ 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc0505; 11 | 12 | public class SolutionApproach1DjikstrasAlgorithm { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0538/SolutionApproach0ReversedInorderTraversal2.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc0538; 11 | 12 | import com.idiotleon.util.data_structure.tree.TreeNode; 13 | 14 | public class SolutionApproach0ReversedInorderTraversal2 { 15 | private int prev = 0; 16 | public TreeNode convertBST(TreeNode root) { 17 | if(root.right != null) convertBST(root.right); 18 | prev = root.val = prev + root.val; 19 | if(root.left != null) convertBST(root.left); 20 | return root; 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0538/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 4 0538 https://leetcode.com/problems/convert-bst-to-greater-tree/ 2 | 4 1038 https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/ 3 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0540/SolutionApproach0BinarySearch.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/single-element-in-a-sorted-array/ 3 | * 4 | * Time Complexity: O(lg(N)) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl4.lc0540; 8 | 9 | public class SolutionApproach0BinarySearch { 10 | public int singleNonDuplicate(int[] nums) { 11 | int left = 0, right = nums.length - 1; 12 | 13 | while(left < right){ 14 | int mid = left + (right - left) / 2; 15 | if(nums[mid] == nums[mid ^ 1]){ 16 | left = mid + 1; 17 | }else{ 18 | right = mid; 19 | } 20 | } 21 | 22 | return nums[left]; 23 | } 24 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0540/SolutionApproach2OnePass.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/single-element-in-a-sorted-array/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl4.lc0540; 8 | 9 | public class SolutionApproach2OnePass { 10 | public int singleNonDuplicate(int[] nums) { 11 | int ans = nums[0]; 12 | for(int i = 1; i < nums.length; i++){ 13 | ans ^= nums[i]; 14 | } 15 | return ans; 16 | } 17 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0540/SolutionApproach2OnePass2.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/single-element-in-a-sorted-array/ 3 | * 4 | * Time Complexity: O(N) 5 | * Space Complexity: O(1) 6 | */ 7 | package com.idiotleon.leetcode.lvl4.lc0540; 8 | 9 | public class SolutionApproach2OnePass2 { 10 | public int singleNonDuplicate(int[] nums) { 11 | int ans = 0; 12 | 13 | for(int i = 0; i < nums.length; i++){ 14 | if(i % 2 == 0){ 15 | ans += nums[i]; 16 | }else{ 17 | ans -= nums[i]; 18 | } 19 | } 20 | 21 | return Math.abs(ans); 22 | } 23 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0556/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Math 7 | 8 | 3 0060 https://leetcode.com/problems/permutation-sequence/ 9 | 3 0670 https://leetcode.com/problems/maximum-swap/ 10 | 3 1053 https://leetcode.com/problems/previous-permutation-with-one-swap/ 11 | 12 | 4 0031 https://leetcode.com/problems/next-permutation/ 13 | 4 0556 https://leetcode.com/problems/next-greater-element-iii/ 14 | 15 | 16 | previous permutation -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0616/SolutionApproach1MergeIntervals.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/add-bold-tag-in-string/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/add-bold-tag-in-string/discuss/104263/Java-solution-Same-as-Merge-Interval. 9 | * https://leetcode.com/problems/add-bold-tag-in-string/discuss/104248/Java-Solution-boolean-array/225028 10 | */ 11 | package com.idiotleon.leetcode.lvl4.lc0616; 12 | 13 | public class SolutionApproach1MergeIntervals { 14 | 15 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0621/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Single Threaded 7 | ## CPU 8 | 9 | 4 0621 https://leetcode.com/problems/task-scheduler/ 10 | 4 0636 https://leetcode.com/problems/exclusive-time-of-functions/ 11 | 12 | 13 | 14 | ### k Distance Apart 15 | ### No Adjacency 16 | 17 | 2 0767 https://leetcode.com/problems/reorganize-string/ 18 | 19 | 4 0358 https://leetcode.com/problems/rearrange-string-k-distance-apart/ 20 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0636/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### CPU - Single Threaded 7 | 8 | 4 0621 https://leetcode.com/problems/task-scheduler/ 9 | 4 0636 https://leetcode.com/problems/exclusive-time-of-functions/ 10 | 11 | 12 | 13 | ### k Distance Apart 14 | ### No Adjacency 15 | 16 | 2 0767 https://leetcode.com/problems/reorganize-string/ 17 | 18 | 4 0358 https://leetcode.com/problems/rearrange-string-k-distance-apart/ 19 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0639/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Decode Ways 7 | 8 | 3 0091 https://leetcode.com/problems/decode-ways/ 9 | 10 | 4 0639 https://leetcode.com/problems/decode-ways-ii/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0673/SolutionApproach0DPWithBinarySearch.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/number-of-longest-increasing-subsequence/ 3 | * 4 | * 5 | * 6 | * References: 7 | * https://leetcode.com/problems/number-of-longest-increasing-subsequence/discuss/107295/9ms-C%2B%2B-Explanation%3A-DP-%2B-Binary-search-%2B-prefix-sums-O(NlogN)-time-O(N)-space 8 | */ 9 | package com.idiotleon.leetcode.lvl4.lc0673; 10 | 11 | public class SolutionApproach0DPWithBinarySearch { 12 | 13 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0689/followup/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/maximum-sum-of-3-non-overlapping-subarrays/ 3 | * 4 | * to get the maximum of k non-overlapping subarrays 5 | */ 6 | package com.idiotleon.leetcode.lvl4.lc0689.followup; 7 | 8 | public class Solution { 9 | 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0698/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 3 0416 https://leetcode.com/problems/partition-equal-subset-sum/ 4 | 5 | 4 0473 https://leetcode.com/problems/matchsticks-to-square/ 6 | 4 0698 https://leetcode.com/problems/partition-to-k-equal-sum-subsets/ 7 | 8 | Resources: 9 | https://www.geeksforgeeks.org/partition-set-k-subsets-equal-sum/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0726/SolutionApproach0TreeMap.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/number-of-atoms/ 3 | * 4 | * 5 | * References: 6 | * https://leetcode.com/problems/number-of-atoms/discuss/109345/Java-Solution-using-Stack-and-Map 7 | */ 8 | package com.idiotleon.leetcode.lvl4.lc0726; 9 | 10 | public class SolutionApproach0TreeMap { 11 | 12 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0742/SolutionApproach1DFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/closest-leaf-in-a-binary-tree/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/closest-leaf-in-a-binary-tree/discuss/113893/Java-DFS-(25ms)-solution-with-detailed-explanation 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc0742; 11 | 12 | public class SolutionApproach1DFS { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0759/Interval.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0759; 2 | 3 | class Interval { 4 | protected int start; 5 | protected int end; 6 | 7 | protected Interval(int start, int end){ 8 | this.start = start; 9 | this.end = end; 10 | } 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0813/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://leetcode.com/problems/split-array-largest-sum/ 4 | https://www.youtube.com/watch?v=FLbqgyJ-70I&t=142s 5 | 6 | 4 0410 https://leetcode.com/problems/split-array-largest-sum/ 7 | 4 0813 https://leetcode.com/problems/largest-sum-of-averages/ 8 | 4 1278 https://leetcode.com/problems/palindrome-partitioning-iii/ 9 | 4 1335 https://leetcode.com/problems/minimum-difficulty-of-a-job-schedule/ 10 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0839/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Islands 7 | 8 | 2 0695 https://leetcode.com/problems/max-area-of-island/ 9 | 10 | 3 0130 https://leetcode.com/problems/surrounded-regions/ 11 | 3 0200 https://leetcode.com/problems/number-of-islands/ 12 | 13 | 4 0317 https://leetcode.com/problems/shortest-distance-from-all-buildings/ 14 | 4 0839 https://leetcode.com/problems/similar-string-groups/ 15 | 4 0947 https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/ 16 | 17 | 5 0827 https://leetcode.com/problems/making-a-large-island/ 18 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0863/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Turning Trees into Undirected Graphs 7 | 8 | 3 1530 https://leetcode.com/problems/number-of-good-leaf-nodes-pairs/ 9 | 10 | 4 0742 https://leetcode.com/problems/closest-leaf-in-a-binary-tree/ 11 | 4 0863 https://leetcode.com/problems/all-nodes-distance-k-in-binary-tree/ 12 | 13 | 14 | ### K Distance 15 | 16 | 4 0863 https://leetcode.com/problems/all-nodes-distance-k-in-binary-tree/ 17 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0879/SolutionApproach0Knapsack2Dimen1.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/profitable-schemes/ 3 | * 4 | * Time Complexity: O(K * P * G) 5 | * Space Complexity: O(P * G) 6 | * 7 | * 8 | * if dp[i][*] is only dependent on dp[i][*] 9 | * Dimension/Space reduction with a temporary array: 10 | * 1. temp = copy of dp[i - 1] 11 | * 2. to update temp 12 | * 3. dp[i] = temp 13 | * 14 | * References: 15 | * http://zxi.mytechroad.com/blog/dynamic-programming/leetcode-879-profitable-schemes/ 16 | */ 17 | package com.idiotleon.leetcode.lvl4.lc0879; 18 | 19 | public class SolutionApproach0Knapsack2Dimen1 { 20 | 21 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0879/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | ### Dynamic Programming 4 | # Knapsack 5 | 6 | 3 0494 https://leetcode.com/problems/target-sum/ 7 | 8 | 4 0474 https://leetcode.com/problems/ones-and-zeroes/ 9 | 4 0879 https://leetcode.com/problems/profitable-schemes/ 10 | 4 0956 https://leetcode.com/problems/tallest-billboard/ 11 | 4 1049 https://leetcode.com/problems/last-stone-weight-ii/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0924/SolutionApproach0BFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/minimize-malware-spread/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | */ 7 | package com.idiotleon.leetcode.lvl4.lc0924; 8 | 9 | public class SolutionApproach0BFS { 10 | 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0924/SolutionApproach0DFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/minimize-malware-spread/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | */ 7 | package com.idiotleon.leetcode.lvl4.lc0924; 8 | 9 | public class SolutionApproach0DFS { 10 | 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0947/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Islands 7 | 8 | 2 0695 https://leetcode.com/problems/max-area-of-island/ 9 | 10 | 3 0130 https://leetcode.com/problems/surrounded-regions/ 11 | 3 0200 https://leetcode.com/problems/number-of-islands/ 12 | 13 | 4 0317 https://leetcode.com/problems/shortest-distance-from-all-buildings/ 14 | 4 0839 https://leetcode.com/problems/similar-string-groups/ 15 | 4 0947 https://leetcode.com/problems/most-stones-removed-with-same-row-or-column/ 16 | 17 | 5 0827 https://leetcode.com/problems/making-a-large-island/ 18 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc0956/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | ### Dynamic Programming 4 | # Knapsack 5 | 6 | 3 0494 https://leetcode.com/problems/target-sum/ 7 | 8 | 4 0474 https://leetcode.com/problems/ones-and-zeroes/ 9 | 4 0879 https://leetcode.com/problems/profitable-schemes/ 10 | 4 0956 https://leetcode.com/problems/tallest-billboard/ 11 | 4 1049 https://leetcode.com/problems/last-stone-weight-ii/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1038/SolutionApproach0ReversedInorderTraversal2.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc1038; 11 | 12 | import com.idiotleon.util.data_structure.tree.TreeNode; 13 | 14 | public class SolutionApproach0ReversedInorderTraversal2 { 15 | private int prev = 0; 16 | public TreeNode bstToGst(TreeNode root) { 17 | if(root.right != null) bstToGst(root.right); 18 | prev = root.val = prev + root.val; 19 | if(root.left != null) bstToGst(root.left); 20 | return root; 21 | } 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1038/similar_problems.txt: -------------------------------------------------------------------------------- 1 | 4 0538 https://leetcode.com/problems/convert-bst-to-greater-tree/ 2 | 4 1038 https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/ 3 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1040/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 3 1033 https://leetcode.com/problems/moving-stones-until-consecutive/ 4 | 5 | 4 1040 https://leetcode.com/problems/moving-stones-until-consecutive-ii/ 6 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1049/followup/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/last-stone-weight-ii/ 3 | * 4 | * what is the BIGGEST possible weight of this stone? 5 | * 6 | * 7 | */ 8 | package com.idiotleon.leetcode.lvl4.lc1049.followup; 9 | 10 | public class Solution { 11 | 12 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1049/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | ### Dynamic Programming 4 | # Knapsack 5 | 6 | 3 0494 https://leetcode.com/problems/target-sum/ 7 | 8 | 4 0474 https://leetcode.com/problems/ones-and-zeroes/ 9 | 4 0879 https://leetcode.com/problems/profitable-schemes/ 10 | 4 0956 https://leetcode.com/problems/tallest-billboard/ 11 | 4 1049 https://leetcode.com/problems/last-stone-weight-ii/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1062/SolutionApproach0KMPAlgorithm.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/longest-repeating-substring/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/longest-repeating-substring/discuss/619339/C%2B%2B-KMP-Solution. 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc1062; 11 | 12 | public class SolutionApproach0KMPAlgorithm { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1062/SolutionApproach0UkkonensAlgorithm.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/longest-repeating-substring/ 3 | * 4 | * References: 5 | * https://leetcode.com/problems/longest-repeating-substring/discuss/332506/Java-2-O(n3)-greater-2-O(n2-logn)-greater-2*O-(n2)-greater-O-(n-logn)-greater-O(n) 6 | */ 7 | package com.idiotleon.leetcode.lvl4.lc1062; 8 | 9 | public class SolutionApproach0UkkonensAlgorithm { 10 | 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1093/SolutionApproach0Math1.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/statistics-from-a-large-sample/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/statistics-from-a-large-sample/discuss/323097/Java-1-Pass-two-pointer-solution 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc1093; 11 | 12 | public class SolutionApproach0Math1 { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1102/SolutionApproach0BinarySearchWithDFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/path-with-maximum-minimum-value/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/path-with-maximum-minimum-value/discuss/416227/Python-Dijkstra-Binary-Search-+-DFS-Union-Find-complexity-analysis/492501 9 | * https://leetcode.com/problems/path-with-maximum-minimum-value/discuss/416227/Python-Dijkstra-Binary-Search-%2B-DFS-Union-Find-complexity-analysis 10 | */ 11 | package com.idiotleon.leetcode.lvl4.lc1102; 12 | 13 | public class SolutionApproach0BinarySearchWithDFS { 14 | 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1234/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Sliding Window 7 | 8 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1250/SolutionApproach0Math.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/check-if-it-is-a-good-array/ 3 | * 4 | * Time Complexity: O(`N`) 5 | * Space Complexity: O(`N`) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/check-if-it-is-a-good-array/discuss/419368/JavaC%2B%2BPython-Chinese-Remainder-Theorem 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc1250; 11 | 12 | public class SolutionApproach0Math { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1258/SolutionApproach0DFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/synonymous-sentences/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/synonymous-sentences/discuss/436757/Java-or-DFS 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc1258; 11 | 12 | public class SolutionApproach0DFS { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1258/SolutionApproach0UnionFind.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/synonymous-sentences/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/synonymous-sentences/discuss/430562/Java-Disjoint-Union-Set-%2B-Permutation-with-Video 9 | * https://leetcode.com/problems/synonymous-sentences/discuss/828731/Java-UnionFind-Solution 10 | */ 11 | package com.idiotleon.leetcode.lvl4.lc1258; 12 | 13 | public class SolutionApproach0UnionFind { 14 | 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1278/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://leetcode.com/problems/split-array-largest-sum/ 4 | https://www.youtube.com/watch?v=FLbqgyJ-70I&t=142s 5 | 6 | 4 0410 https://leetcode.com/problems/split-array-largest-sum/ 7 | 4 0813 https://leetcode.com/problems/largest-sum-of-averages/ 8 | 4 1278 https://leetcode.com/problems/palindrome-partitioning-iii/ 9 | 4 1335 https://leetcode.com/problems/minimum-difficulty-of-a-job-schedule/ 10 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1297/SolutionApproach0RollingHash.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/maximum-number-of-occurrences-of-a-substring/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/maximum-number-of-occurrences-of-a-substring/discuss/457577/C%2B%2B-Greedy-approach-%2B-Sliding-window-O(n). 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc1297; 11 | 12 | public class SolutionApproach0RollingHash { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1300/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://leetcode.com/tag/stack/ 4 | https://medium.com/algorithms-and-leetcode/monotonic-queue-explained-with-leetcode-problems-7db7c530c1d6 5 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 6 | 7 | 8 | ### Binary Search 9 | # Trial and Error 10 | 11 | 4 1300 https://leetcode.com/problems/sum-of-mutated-array-closest-to-target/ 12 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1316/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### String 7 | ## Word Pattern 8 | # KMP Algorithm 9 | 10 | 2 0028 https://leetcode.com/problems/implement-strstr/ 11 | 2 1071 https://leetcode.com/problems/greatest-common-divisor-of-strings/ 12 | 13 | 3 0459 https://leetcode.com/problems/repeated-substring-pattern/ 14 | 3 0686 https://leetcode.com/problems/repeated-string-match/ 15 | 3 1367 https://leetcode.com/problems/linked-list-in-binary-tree/ 16 | 17 | 4 1316 https://leetcode.com/problems/distinct-echo-substrings/ 18 | 19 | 5 0214 https://leetcode.com/problems/shortest-palindrome/ 20 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1340/SolutionApproach0DPWithSegmentTree.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/jump-game-v/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/jump-game-v/discuss/497004/C%2B%2B-Segment-Tree 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc1340; 11 | 12 | public class SolutionApproach0DPWithSegmentTree { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1361/SolutionApproach0UnionFind.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/validate-binary-tree-nodes/ 3 | * 4 | * Time Complexity: O(n) 5 | * Space Complexity: O(n) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/validate-binary-tree-nodes/discuss/517596/Count-Parents-and-Union-Find 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc1361; 11 | 12 | public class SolutionApproach0UnionFind { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1368/SolutionApproach1DP2Dimen.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/minimum-cost-to-make-at-least-one-valid-path-in-a-grid/ 3 | * 4 | * References: 5 | * https://leetcode.com/problems/minimum-cost-to-make-at-least-one-valid-path-in-a-grid/discuss/524845/C%2B%2B96ms-Forward-and-Backward-DP-Bounded-by-O((m%2Bn)mn) 6 | */ 7 | package com.idiotleon.leetcode.lvl4.lc1368; 8 | 9 | public class SolutionApproach1DP2Dimen { 10 | 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1510/SolutionApproach0DFSMemo.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/stone-game-iv/ 3 | * 4 | * Time Complexity: ?O(`n`) 5 | * Space Complexity: ?O(`n`) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/stone-game-iv/discuss/730490/Java-or-Heavily-Commented-or-Subproblems-Visualised 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc1510; 11 | 12 | public class SolutionApproach0DFSMemo { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1510/SolutionApproach0Knapsack.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/stone-game-iv/ 3 | * 4 | * Time Complexity: O(`n` ^ 1.5) 5 | * Space Complexity: O(`n`) 6 | * 7 | * References: 8 | * https://leetcode.com/problems/stone-game-iv/discuss/730582/JavaC%2B%2BPython-DP 9 | */ 10 | package com.idiotleon.leetcode.lvl4.lc1510; 11 | 12 | public class SolutionApproach0Knapsack { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl4/lc1516/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc1516; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | class Node { 7 | protected int val; 8 | protected List children; 9 | 10 | protected Node() { 11 | this.children = new ArrayList<>(); 12 | } 13 | 14 | protected Node(int val) { 15 | this.val = val; 16 | this.children = new ArrayList(); 17 | } 18 | 19 | protected Node(int val, ArrayList children) { 20 | this.val = val; 21 | this.children = children; 22 | } 23 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0140/SolutionDP.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl5.lc0140; 2 | 3 | import static com.idiotleon.util.Constant.WARNING.UNUSED; 4 | 5 | /** 6 | * https://leetcode.com/problems/word-break-ii/ 7 | *

8 | * https://leetcode.com/problems/word-break-ii/discuss/44243/Java-DP%2BDFS-Memoization%2BDFS-and-DP-Pruning-Solutions-with-Analysis 9 | */ 10 | @SuppressWarnings(UNUSED) 11 | public class SolutionDP { 12 | 13 | } 14 | 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0140/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Word Series 7 | 8 | 2 0433 https://leetcode.com/problems/minimum-genetic-mutation/ 9 | 10 | 4 0079 https://leetcode.com/problems/word-search/ 11 | 4 0126 https://leetcode.com/problems/word-ladder-ii/ 12 | 4 0127 https://leetcode.com/problems/word-ladder/ 13 | 4 0139 https://leetcode.com/problems/word-break/ 14 | 15 | 5 0140 https://leetcode.com/problems/word-break-ii/ 16 | 5 0212 https://leetcode.com/problems/word-search-ii/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0212/SolutionApproach1Backtrack.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | * 4 | * References: 5 | * https://zxi.mytechroad.com/blog/searching/leetcode-212-word-search-ii/ 6 | */ 7 | package com.idiotleon.leetcode.lvl5.lc0212; 8 | 9 | public class SolutionApproach1Backtrack { 10 | 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0273/followups/followup0/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/integer-to-english-words/submissions/ 3 | * https://leetcode.com/problems/integer-to-english-words/discuss/216295/Follow-up-on-this-question 4 | * 5 | * 6 | */ 7 | package com.idiotleon.leetcode.lvl5.lc0273.followups.followup0; 8 | 9 | public class Solution { 10 | 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0324/SolutionApproach1Sorting.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/wiggle-sort-ii/ 3 | * 4 | * Time Complexity: O(N * lg(N)) 5 | * Space Complexity: O(N) 6 | */ 7 | package com.idiotleon.leetcode.lvl5.lc0324; 8 | 9 | import java.util.Arrays; 10 | 11 | public class SolutionApproach1Sorting { 12 | public void wiggleSort(int[] nums) { 13 | final int N = nums.length; 14 | int mid = (N + 1) >> 1; 15 | int[] cloned = nums.clone(); 16 | Arrays.sort(cloned); 17 | 18 | for (int i = mid - 1, j = 0; i >= 0; --i, j += 2) 19 | nums[j] = cloned[i]; 20 | 21 | for (int i = N - 1, j = 1; i >= mid; --i, j += 2) 22 | nums[j] = cloned[i]; 23 | } 24 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0324/followup/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/wiggle-sort-ii/ 3 | * 4 | * Can you do it in O(n) time and/or in-place with O(1) extra space? 5 | * 6 | * References: 7 | * https://leetcode.com/problems/wiggle-sort-ii/discuss/77684/summary-of-the-various-solutions-to-wiggle-sort-for-your-reference/81858 8 | */ 9 | package com.idiotleon.leetcode.lvl5.lc0324.followup; 10 | 11 | public class Solution { 12 | 13 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0324/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 2 0280 https://leetcode.com/problems/wiggle-sort/ 4 | 5 | 3 0376 https://leetcode.com/problems/wiggle-subsequence/ 6 | 7 | 5 0324 https://leetcode.com/problems/wiggle-sort-ii/ 8 | 9 | Resources: 10 | https://leetcode.com/problems/wiggle-sort-ii/discuss/77684/summary-of-the-various-solutions-to-wiggle-sort-for-your-reference/81858 -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0465/SolutionApproach0BFS.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/optimal-account-balancing/ 3 | * 4 | * 5 | * References: 6 | * https://leetcode.com/problems/optimal-account-balancing/discuss/173299/Python-BFS-beats-100-(Updated) 7 | */ 8 | package com.idiotleon.leetcode.lvl5.lc0465; 9 | 10 | public class SolutionApproach0BFS { 11 | 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0465/SolutionApproach0DP2Dimen.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/optimal-account-balancing/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/optimal-account-balancing/discuss/219187/Short-O(N-*-2N)-DP-solution-with-detailed-explanation-and-complexity-analysis 9 | */ 10 | package com.idiotleon.leetcode.lvl5.lc0465; 11 | 12 | public class SolutionApproach0DP2Dimen { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0588/SolutionApproach0Trie.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl5.lc0588; 2 | 3 | public class SolutionApproach0Trie { 4 | 5 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0685/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Redundant Connection 7 | 8 | 3 0684 https://leetcode.com/problems/redundant-connection/ 9 | 10 | 5 0685 https://leetcode.com/problems/redundant-connection-ii/ 11 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0715/SolutionApproach0SegmentTree.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/range-module/ 3 | * 4 | * Time Complexities: 5 | * `addRange()`: O() 6 | * `queryRange()`: O() 7 | * `removeRange()`: O() 8 | * 9 | * Space Complexity: O() 10 | * 11 | * References: 12 | * https://leetcode.com/problems/range-module/discuss/108922/Binary-search-tree-with-interval-as-element-simple-recursion. 13 | * https://leetcode.com/problems/range-module/discuss/108925/Java-Segment-Tree 14 | */ 15 | package com.idiotleon.leetcode.lvl5.lc0715; 16 | 17 | public class SolutionApproach0SegmentTree { 18 | 19 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0818/SolutionApproach0DPBottomUp.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/race-car/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/race-car/discuss/124326/Summary-of-the-BFS-and-DP-solutions-with-intuitive-explanation 9 | */ 10 | package com.idiotleon.leetcode.lvl5.lc0818; 11 | 12 | public class SolutionApproach0DPBottomUp { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0818/SolutionApproach0DPTopDown.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/race-car/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/race-car/discuss/124326/Summary-of-the-BFS-and-DP-solutions-with-intuitive-explanation 9 | */ 10 | package com.idiotleon.leetcode.lvl5.lc0818; 11 | 12 | public class SolutionApproach0DPTopDown { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0843/FakeMaster.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl5.lc0843; 2 | 3 | import java.util.Random; 4 | 5 | public class FakeMaster { 6 | public int guess(String str){ 7 | return new Random().nextInt(7); 8 | } 9 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc0850/SolutionApproach0SegmentTree.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/rectangle-area-ii/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/rectangle-area-ii/discuss/399260/Easily-understood-Segmentation-Tree-solution-based-on-official-solution 9 | * https://leetcode.com/problems/rectangle-area-ii/solution/ 10 | */ 11 | package com.idiotleon.leetcode.lvl5.lc0850; 12 | 13 | public class SolutionApproach0SegmentTree { 14 | 15 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/lvl5/lc1349/SolutionApproach0DFSMemo.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/maximum-students-taking-exam/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/maximum-students-taking-exam/discuss/503491/JAVA-Top-Down-DP-Solution 9 | */ 10 | package com.idiotleon.leetcode.lvl5.lc1349; 11 | 12 | public class SolutionApproach0DFSMemo { 13 | 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/multithread/lc1242/FakeHtmlParser.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.multithread.lc1242; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class FakeHtmlParser { 7 | public List getUrls(String url){ 8 | return new ArrayList(); 9 | } 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl2/lc0622/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Circular 7 | 8 | 2 0622 https://leetcode.com/problems/design-circular-queue/ 9 | 2 0641 https://leetcode.com/problems/design-circular-deque/ 10 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl2/lc0641/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Circular 7 | 8 | 2 0622 https://leetcode.com/problems/design-circular-queue/ 9 | 2 0641 https://leetcode.com/problems/design-circular-deque/ 10 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl3/lc0173/followup/Solution.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/binary-search-tree-iterator/ 3 | * 4 | * if there are k BSTs 5 | * 6 | * References: 7 | * https://leetcode.com/problems/all-elements-in-two-binary-search-trees/discuss/464073/C%2B%2B-One-Pass-Traversal 8 | */ 9 | package com.idiotleon.leetcode.ood.lvl3.lc0173.followup; 10 | 11 | public class Solution { 12 | 13 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl3/lc0173/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Binary Search Tree 7 | 8 | 2 1305 https://leetcode.com/problems/all-elements-in-two-binary-search-trees/ 9 | 10 | 3 0173 https://leetcode.com/problems/binary-search-tree-iterator/ 11 | 12 | 4 0023 https://leetcode.com/problems/merge-k-sorted-lists/ 13 | 14 | 15 | 16 | ### Stack 17 | 18 | 3 0173 https://leetcode.com/problems/binary-search-tree-iterator/ 19 | 3 0339 https://leetcode.com/problems/nested-list-weight-sum/ 20 | 3 0341 https://leetcode.com/problems/flatten-nested-list-iterator/ 21 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl3/lc0379/SolutionApproach0SegmentTree.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/design-phone-directory/ 3 | * 4 | * Time Complexity: O() 5 | * Space Complexity: O() 6 | * 7 | * References: 8 | * https://leetcode.com/problems/design-phone-directory/discuss/166524/Strict-O(1)-Java 9 | */ 10 | package com.idiotleon.leetcode.ood.lvl3.lc0379; 11 | 12 | public class SolutionApproach0SegmentTree { 13 | 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl3/lc0379/followups/followup0/SolutionApproach0Trie.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | */ 4 | package com.idiotleon.leetcode.ood.lvl3.lc0379.followups.followup0; 5 | 6 | public class SolutionApproach0Trie { 7 | 8 | } 9 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl3/lc0380/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 4 | 3 0380 https://leetcode.com/problems/insert-delete-getrandom-o1/ 5 | 6 | 5 0381 https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl3/lc1286/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | ### Backtrack 7 | 8 | 2 0078 https://leetcode.com/problems/subsets/ 9 | 2 0090 https://leetcode.com/problems/subsets-ii/ 10 | 11 | 3 0039 https://leetcode.com/problems/combination-sum/ 12 | 3 0040 https://leetcode.com/problems/combination-sum-ii/ 13 | 3 0046 https://leetcode.com/problems/permutations/ 14 | 3 0047 https://leetcode.com/problems/permutations-ii/ 15 | 3 0131 https://leetcode.com/problems/palindrome-partitioning/ 16 | 17 | 18 | 19 | # OOD 20 | 21 | 3 1286 https://leetcode.com/problems/iterator-for-combination/ 22 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl4/lc0307/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | References: 3 | https://github.com/huanminwu/LeetCode/blob/master/LeetCode.xlsx 4 | 5 | 6 | 7 | ### Segmented Tree 8 | 9 | 4 0307 https://leetcode.com/problems/range-sum-query-mutable/ 10 | 11 | 12 | 13 | ### Binary Indexed Tree 14 | 15 | 4 0307 https://leetcode.com/problems/range-sum-query-mutable/ 16 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl4/lc0431/Node.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.ood.lvl4.lc0431; 2 | 3 | import java.util.List; 4 | 5 | class Node { 6 | protected int val; 7 | protected List children; 8 | 9 | protected Node() { 10 | } 11 | 12 | protected Node(int val) { 13 | this.val = val; 14 | } 15 | 16 | protected Node(int val, List children) { 17 | this.val = val; 18 | this.children = children; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/leetcode/ood/lvl5/lc0381/similar_problems.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | 4 | 3 0380 https://leetcode.com/problems/insert-delete-getrandom-o1/ 5 | 6 | 5 0381 https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/bit_manipulation/NextPowerOf2.java: -------------------------------------------------------------------------------- 1 | /** 2 | * References: 3 | * https://github.com/mission-peace/interview/blob/master/src/com/interview/bits/NextPowerOf2.java 4 | */ 5 | package com.idiotleon.summary.bit_manipulation; 6 | 7 | public class NextPowerOf2 { 8 | public int nextPowerOf2(int num){ 9 | if(num == 0) return 1; 10 | if(num > 0 && (num & (num - 1)) == 0) return num; 11 | while((num & (num - 1)) > 0){ 12 | num = num & (num - 1); 13 | } 14 | 15 | return num << 1; 16 | } 17 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/dynamic_programming/LongestCommonSubsequence.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.summary.dynamic_programming; 2 | 3 | public class LongestCommonSubsequence { 4 | 5 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/dynamic_programming/LongestIncreasingSubsequence.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.summary.dynamic_programming; 2 | 3 | public class LongestIncreasingSubsequence { 4 | 5 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/graph/minimum_spanning_tree/KruskalsAlgorithm.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | * 4 | */ 5 | package com.idiotleon.summary.graph.minimum_spanning_tree; 6 | 7 | public class KruskalsAlgorithm { 8 | 9 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/graph/minimum_spanning_tree/PrimsAlgorithm.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.summary.graph.minimum_spanning_tree; 2 | 3 | public class PrimsAlgorithm { 4 | 5 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/recursion/Combination.java: -------------------------------------------------------------------------------- 1 | /** 2 | * pseudo code: 3 | * combination(depth, start) 4 | * if depth == N: return func() 5 | * for i in range(start, N): 6 | * combination(depth + 1, i + 1) 7 | * 8 | * 9 | * Time Complexity: 10 | * T(N) = T(N - 1) + T(N - 2) + ... + T(1) = T(2 ^ N) 11 | * 12 | * Space Complexity: 13 | * O(N) 14 | * 15 | * References: 16 | * https://www.youtube.com/watch?v=OQi4n8EKRD8 17 | */ 18 | package com.idiotleon.summary.recursion; 19 | 20 | public class Combination { 21 | 22 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/recursion/Permutation.java: -------------------------------------------------------------------------------- 1 | /** 2 | * pseudo code: 3 | * permutation(depth, used): 4 | * if depth == N: return func() 5 | * for i in range(0, N): 6 | * if i in used: continue 7 | * used.add(i) 8 | * permutation(depth + 1, used) 9 | * used.remove(i) 10 | * 11 | * Time Complexity: 12 | * T(N) = N * T(N - 1) = N * (N - 1) * (N - 2) * ... * 1 = O(N!) 13 | * 14 | * Space Complexity: 15 | * O(N) 16 | * 17 | * References: 18 | * https://www.youtube.com/watch?v=OQi4n8EKRD8 19 | */ 20 | package com.idiotleon.summary.recursion; 21 | 22 | public class Permutation { 23 | 24 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/resources.txt: -------------------------------------------------------------------------------- 1 | @author: Leon 2 | 3 | ### Resources: 4 | Input Size vs Time Complexity: 5 | https://www.youtube.com/watch?v=eG99FDBeuJo 6 | 7 | Amortized Analysis: 8 | https://zxi.mytechroad.com/blog/sp/amortized-analysis/ -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/search/binary_search/BinarySearchRecursively.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.summary.search.binary_search; 2 | 3 | public class BinarySearchRecursively { 4 | public int binarySearch(int[] nums, int left, int right, int target){ 5 | if(left <= right){ 6 | int mid = left + (right - left) / 2; 7 | 8 | if(target == nums[mid]) return mid; 9 | 10 | if(target < nums[mid]) 11 | return binarySearch(nums, left, mid - 1, target); 12 | 13 | return binarySearch(nums, mid + 1, right, target); 14 | } 15 | 16 | return -1; 17 | } 18 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/sort/bubble_sort/BubbleSort.java: -------------------------------------------------------------------------------- 1 | /** 2 | * References: 3 | * https://leetcode.com/problems/sort-an-array/discuss/492042/7-Sorting-Algorithms-(quick-sort-top-downbottom-up-merge-sort-heap-sort-etc.) 4 | */ 5 | package com.idiotleon.summary.sort.bubble_sort; 6 | 7 | public class BubbleSort { 8 | 9 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/sort/heap_sort/HeapSort.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | * References: 4 | * https://leetcode.com/problems/sort-an-array/discuss/492042/7-Sorting-Algorithms-(quick-sort-top-downbottom-up-merge-sort-heap-sort-etc.) 5 | */ 6 | package com.idiotleon.summary.sort.heap_sort; 7 | 8 | public class HeapSort { 9 | 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/sort/insertion_sort/InsertionSort.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | * References: 4 | * https://leetcode.com/problems/sort-an-array/discuss/492042/7-Sorting-Algorithms-(quick-sort-top-downbottom-up-merge-sort-heap-sort-etc.) 5 | */ 6 | package com.idiotleon.summary.sort.insertion_sort; 7 | 8 | public class InsertionSort { 9 | 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/sort/selection_sort/SelectionSort.java: -------------------------------------------------------------------------------- 1 | /** 2 | * 3 | * References: 4 | * https://leetcode.com/problems/sort-an-array/discuss/492042/7-Sorting-Algorithms-(quick-sort-top-downbottom-up-merge-sort-heap-sort-etc.) 5 | */ 6 | package com.idiotleon.summary.sort.selection_sort; 7 | 8 | public class SelectionSort { 9 | 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/summary/union_find/UnionFindLightWeight.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Time Complexity: 3 | * Space Complexity: O(N) 4 | * 5 | * Problems: 6 | * https://leetcode.com/problems/redundant-connection/ 7 | */ 8 | package com.idiotleon.summary.union_find; 9 | 10 | public class UnionFindLightWeight { 11 | public int find(int[] parents, int vertex){ 12 | if(parents[vertex] != vertex){ 13 | // path compression 14 | parents[vertex] = find(parents, parents[vertex]); 15 | } 16 | 17 | return parents[vertex]; 18 | } 19 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/util/Constant.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.util; 2 | 3 | public class Constant { 4 | public static class WARNING { 5 | public static final String UNUSED = "unused"; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/util/data_structure/graph/Vertex.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.util.data_structure.graph; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class Vertex{ 7 | public int val; 8 | public List neighbors; 9 | 10 | public Vertex(){ 11 | val = 0; 12 | neighbors = new ArrayList(); 13 | } 14 | 15 | public Vertex(int val){ 16 | this.val = val; 17 | neighbors = new ArrayList(); 18 | } 19 | 20 | public Vertex(int val, ArrayList neighbors){ 21 | this.val = val; 22 | this.neighbors = neighbors; 23 | } 24 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/util/data_structure/linkedlist/ListNode.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.util.data_structure.linkedlist; 2 | 3 | public class ListNode { 4 | public int val; 5 | public ListNode next; 6 | 7 | public ListNode(int val){ 8 | this.val = val; 9 | } 10 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/util/data_structure/tree/NaryTreeNode.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.util.data_structure.tree; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class NaryTreeNode { 7 | public int val; 8 | public List children; 9 | 10 | public NaryTreeNode(int val){ 11 | this.val = val; 12 | this.children = new ArrayList(); 13 | } 14 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/util/data_structure/tree/TreeNode.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.util.data_structure.tree; 2 | 3 | public class TreeNode{ 4 | public int val; 5 | public TreeNode left; 6 | public TreeNode right; 7 | 8 | public TreeNode(int val){ 9 | this.val = val; 10 | } 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/util/data_structure/tree/TreeNodeWithParentPointer.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.util.data_structure.tree; 2 | 3 | public class TreeNodeWithParentPointer { 4 | public int val; 5 | public TreeNodeWithParentPointer left, right, parent; 6 | 7 | public TreeNodeWithParentPointer(int val){ 8 | this.val = val; 9 | this.left = this.right = this.parent = null; 10 | } 11 | } -------------------------------------------------------------------------------- /src/main/java/com/idiotleon/util/data_structure/trie/TrieNode.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.util.data_structure.trie; 2 | 3 | public class TrieNode { 4 | private final int N = 26; 5 | 6 | public char val; 7 | public boolean isWord; 8 | public TrieNode[] children = new TrieNode[N]; 9 | public TrieNode(char c){ 10 | TrieNode trieNode = new TrieNode(c); 11 | trieNode.val = c; 12 | } 13 | } -------------------------------------------------------------------------------- /src/test/java/com/idiotleon/leetcode/explore/challenge30days/first_unique_number/testcase01.txt: -------------------------------------------------------------------------------- 1 | ["FirstUnique","showFirstUnique","add","showFirstUnique","add","showFirstUnique","add","showFirstUnique"] 2 | [[[2,3,5]],[],[5],[],[2],[],[3],[]] -------------------------------------------------------------------------------- /src/test/java/com/idiotleon/leetcode/explore/challenge30days/first_unique_number/testcase02.txt: -------------------------------------------------------------------------------- 1 | ["FirstUnique","showFirstUnique","add","add","add","add","add","showFirstUnique"] 2 | [[[7,7,7,7,7,7]],[],[7],[3],[3],[7],[17],[]] -------------------------------------------------------------------------------- /src/test/java/com/idiotleon/leetcode/explore/challenge30days/first_unique_number/testcase03.txt: -------------------------------------------------------------------------------- 1 | ["FirstUnique","showFirstUnique","add","showFirstUnique"] 2 | [[[809]],[],[809],[]] -------------------------------------------------------------------------------- /src/test/java/com/idiotleon/leetcode/lvl2/lc0209/SolutionTestsApproachSlidingWindow.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl2.lc0209; 2 | 3 | import org.junit.jupiter.api.Test; 4 | 5 | import org.junit.jupiter.api.DisplayName; 6 | import static org.junit.jupiter.api.Assertions.assertEquals; 7 | 8 | import com.idiotleon.util.Constants; 9 | 10 | class SolutionTestsApproachSlidingWindow { 11 | private final SolutionApproach0SlidingWindow solution = new SolutionApproach0SlidingWindow(); 12 | 13 | @Test 14 | @DisplayName("209. Minimum Size Subarray Sum") 15 | void test() { 16 | assertEquals(2, solution.minSubArrayLen(7, Constants.Array.RANDOM)); 17 | } 18 | } -------------------------------------------------------------------------------- /src/test/java/com/idiotleon/leetcode/lvl4/lc0042/followup/TestSolutionApproach0Stack.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0042.followup; 2 | 3 | import static org.junit.jupiter.api.Assertions.assertEquals; 4 | 5 | import org.junit.jupiter.api.Test; 6 | 7 | public class TestSolutionApproach0Stack { 8 | private SolutionApproach0MonoStack solution = new SolutionApproach0MonoStack(); 9 | 10 | @Test 11 | void test1(){ 12 | final int [] HEIGHTS = {0,1,0,2,1,0,1,3,2,1,2,1}; 13 | assertEquals(1, solution.trap(HEIGHTS)); 14 | } 15 | } -------------------------------------------------------------------------------- /src/test/java/com/idiotleon/leetcode/lvl4/lc0042/followup/TestSolutionApproach1DP.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0042.followup; 2 | 3 | import static org.junit.jupiter.api.Assertions.assertEquals; 4 | 5 | import org.junit.jupiter.api.Test; 6 | 7 | public class TestSolutionApproach1DP { 8 | private SolutionApproach1DP solution = new SolutionApproach1DP(); 9 | 10 | @Test 11 | void test1(){ 12 | final int [] heights = {0,1,0,2,1,0,1,3,2,1,2,1}; 13 | assertEquals(1, solution.trap(heights)); 14 | } 15 | } -------------------------------------------------------------------------------- /src/test/java/com/idiotleon/leetcode/lvl4/lc0042/followup/TestSolutionApproach1TwoPtrs.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.leetcode.lvl4.lc0042.followup; 2 | 3 | import static org.junit.jupiter.api.Assertions.assertEquals; 4 | 5 | import org.junit.jupiter.api.Test; 6 | 7 | public class TestSolutionApproach1TwoPtrs { 8 | private SolutionApproach1TwoPointers solution = new SolutionApproach1TwoPointers(); 9 | 10 | @Test 11 | void test1(){ 12 | final int [] HEIGHTS = {0,1,0,2,1,0,1,3,2,1,2,1}; 13 | assertEquals(1, solution.trap(HEIGHTS)); 14 | } 15 | } -------------------------------------------------------------------------------- /src/test/java/com/idiotleon/leetcode/lvl4/lc0745/TestSolutionApproach0Trie.java: -------------------------------------------------------------------------------- 1 | /** 2 | * https://leetcode.com/problems/prefix-and-suffix-search/ 3 | */ 4 | package com.idiotleon.leetcode.lvl4.lc0745; 5 | 6 | import static org.junit.jupiter.api.Assertions.assertEquals; 7 | 8 | import org.junit.jupiter.api.Disabled; 9 | import org.junit.jupiter.api.Test; 10 | 11 | public class TestSolutionApproach0Trie { 12 | private UnfinishedSolutionApproach0Trie solution; 13 | 14 | @Test 15 | @Disabled 16 | public void test(){ 17 | String[] input = new String[]{"apple"}; 18 | solution = new UnfinishedSolutionApproach0Trie(input); 19 | 20 | assertEquals(0, solution.f("a", "e")); 21 | assertEquals(-1, solution.f("b", "")); 22 | } 23 | } -------------------------------------------------------------------------------- /src/test/java/com/idiotleon/util/data_structure/tree/Constants.java: -------------------------------------------------------------------------------- 1 | package com.idiotleon.util.data_structure.tree; 2 | 3 | public class Constants { 4 | public static Integer[] nums1 = {1, 2, 3, null, null, 4, 5}; 5 | public static int[] nums1Inorder = {2, 1, 4, 3, 5}; 6 | 7 | public static Integer[] nums2 = {1, 2, 3, 4, 5}; 8 | public static int[] nums2Inorder = {4, 2, 5, 1, 3}; 9 | } --------------------------------------------------------------------------------