Update

Author: ex01tus

src/array/ContainerWithMostWater.java

@@ -0,0 +1,29 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/container-with-most-water
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class ContainerWithMostWater {
+
+    public int maxArea(int[] height) {
+        int left = 0;
+        int right = height.length - 1;
+
+        int max = 0;
+        while (left < right) {
+            int space = Math.min(height[left], height[right]) * (right - left);
+            max = Math.max(space, max);
+
+            if (height[left] > height[right]) {
+                right--;
+            } else {
+                left++;
+            }
+        }
+
+        return max;
+    }
+}

src/array/LongestConsecutiveSequence.java

@@ -0,0 +1,36 @@
+package array;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Description: https://leetcode.com/problems/longest-consecutive-sequence
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class LongestConsecutiveSequence {
+
+    public int longestConsecutive(int[] nums) {
+        Set<Integer> numsSet = new HashSet<>(nums.length);
+        for (int num : nums) {
+            numsSet.add(num);
+        }
+
+        int max = 0;
+        for (int num : nums) {
+            if (numsSet.contains(num - 1)) continue; // num is not the start of a sequence
+
+            int count = 1;
+            int next = num + 1;
+            while (numsSet.contains(next)) {
+                count++;
+                next++;
+            }
+
+            max = Math.max(count, max);
+        }
+
+        return max;
+    }
+}

src/array/SubarraySumEqualsK.java

@@ -0,0 +1,32 @@
+package array;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/subarray-sum-equals-k
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class SubarraySumEqualsK {
+
+    public int subarraySum(int[] nums, int targetSum) {
+        Map<Long, Integer> prefixSumFrequencyMap = new HashMap<>();
+
+        int count = 0;
+        long currentSum = 0;
+        for (int num : nums) {
+            currentSum += num;
+
+            int currentSubarray = currentSum == targetSum ? 1 : 0;
+            int previousSubarrays = prefixSumFrequencyMap.getOrDefault(currentSum - targetSum, 0);
+
+            count += currentSubarray + previousSubarrays;
+
+            prefixSumFrequencyMap.merge(currentSum, 1, Integer::sum);
+        }
+
+        return count;
+    }
+}

src/array/TreeSum.java renamed to src/array/ThreeSum.java

@@ -8,7 +8,7 @@
  * Time complexity: O(n^2)
  * Space complexity: O(n)
  */
-public class TreeSum {
+public class ThreeSum {
 
     public List<List<Integer>> threeSumViaTwoPointers(int[] nums) {
         Set<List<Integer>> result = new HashSet<>();

src/array/TwoSum2.java

@@ -0,0 +1,29 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/two-sum-ii-input-array-is-sorted
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class TwoSum2 {
+
+    public int[] twoSum(int[] numbers, int target) {
+        int left = 0;
+        int right = numbers.length - 1;
+
+        while (left < right) {
+            int sum = numbers[left] + numbers[right];
+
+            if (sum > target) {
+                right--;
+            } else if (sum < target) {
+                left++;
+            } else {
+                return new int[] {left + 1, right + 1};
+            }
+        }
+
+        throw new RuntimeException();
+    }
+}

src/binary_search/Search2DMatrix.java

@@ -0,0 +1,53 @@
+package binary_search;
+
+/**
+ * Description: https://leetcode.com/problems/search-a-2d-matrix
+ * Difficulty: Medium
+ * Time complexity: O(log n + log m)
+ * Space complexity: O(1)
+ */
+public class Search2DMatrix {
+
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int row = findRowNumber(matrix, target);
+        return containsTarget(matrix[row], target);
+    }
+
+    private int findRowNumber(int[][] matrix, int target) {
+        int left = 0;
+        int right = matrix.length - 1;
+
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+
+            if (target > matrix[mid][matrix[0].length - 1]){
+                left = mid + 1;
+            } else if (target < matrix[mid][0]) {
+                right = mid - 1;
+            } else {
+                return mid;
+            }
+        }
+
+        return left;
+    }
+
+    private boolean containsTarget(int[] row, int target) {
+        int left = 0;
+        int right = row.length - 1;
+
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+
+            if (target > row[mid]) {
+                left = mid + 1;
+            } else if (target < row[mid]) {
+                right = mid - 1;
+            } else {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/binary_tree/PathSum.java

@@ -0,0 +1,27 @@
+package binary_tree;
+
+/**
+ * Description: https://leetcode.com/problems/path-sum
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(h)
+ */
+public class PathSum {
+
+    public boolean hasPathSum(TreeNode root, int remains) {
+        if (root == null) return false;
+
+        remains -= root.val;
+        if (root.left == null && root.right == null) {
+            return remains == 0;
+        }
+
+        return hasPathSum(root.right, remains) || hasPathSum(root.left, remains);
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}

src/binary_tree/PathSum2.java

@@ -0,0 +1,44 @@
+package binary_tree;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Description: https://leetcode.com/problems/path-sum-ii
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class PathSum2 {
+
+    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
+        List<List<Integer>> paths = new ArrayList<>();
+        pathSum(root, new ArrayList<>(), targetSum, paths);
+        return paths;
+    }
+
+    private void pathSum(
+            TreeNode root,
+            List<Integer> currentPath,
+            int remains,
+            List<List<Integer>> paths) {
+        if (root == null) return;
+
+        currentPath.add(root.val);
+
+        if (root.left == null && root.right == null && remains == root.val) {
+            paths.add(new ArrayList<>(currentPath));
+        } else {
+            pathSum(root.left, currentPath, remains - root.val, paths);
+            pathSum(root.right, currentPath, remains - root.val, paths);
+        }
+
+        currentPath.remove(currentPath.size() - 1);
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}

src/binary_tree/PathSum3.java

@@ -0,0 +1,69 @@
+package binary_tree;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/path-sum-iii
+ * Difficulty: Medium
+ */
+public class PathSum3 {
+
+    public int pathSumViaMemoization(TreeNode root, int targetSum) {
+        return pathSum(root, 0L, targetSum, new HashMap<>());
+    }
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    private int pathSum(
+            TreeNode root,
+            long currentSum,
+            int targetSum,
+            Map<Long, Integer> prefixSumFrequencies) {
+        if (root == null) return 0;
+
+        currentSum += root.val;
+
+        int currentPath = currentSum == targetSum ? 1 : 0;
+        int previousPaths = prefixSumFrequencies.getOrDefault(currentSum - targetSum, 0);
+
+        prefixSumFrequencies.merge(currentSum, 1, Integer::sum);
+
+        int result = currentPath
+                + previousPaths
+                + pathSum(root.left, currentSum, targetSum, prefixSumFrequencies)
+                + pathSum(root.right, currentSum, targetSum, prefixSumFrequencies);
+
+        prefixSumFrequencies.merge(currentSum, -1, Integer::sum);
+
+        return result;
+    }
+
+    /**
+     * Time complexity: O(n^2)
+     * Space complexity: O(h)
+     */
+    public int pathSum(TreeNode root, int remains) {
+        if (root == null) return 0;
+
+        return pathSumStartingWith(root, remains)
+                + pathSum(root.left, remains)
+                + pathSum(root.right, remains);
+    }
+
+    private int pathSumStartingWith(TreeNode root, int remains) {
+        if (root == null) return 0;
+
+        return (remains == root.val ? 1 : 0)
+                + pathSumStartingWith(root.left, remains - root.val)
+                + pathSumStartingWith(root.right, remains - root.val);
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}