Update

Author: ex01tus

src/binary_search/FindMinimumInRotatedSortedArray.java

@@ -0,0 +1,27 @@
+package binary_search;
+
+/**
+ * Description: https://leetcode.com/problems/find-minimum-in-rotated-sorted-array
+ * Difficulty: Medium
+ * Time complexity: O(log n)
+ * Space complexity: O(1)
+ */
+public class FindMinimumInRotatedSortedArray {
+
+    public int findMin(int[] nums) {
+        int left = 0;
+        int right = nums.length - 1;
+
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+
+            if (nums[mid] > nums[right]) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+
+        return nums[left];
+    }
+}

src/binary_search/SearchInRotatedSortedArray.java

@@ -23,7 +23,7 @@ private int findPivot(int[] nums) {
         while (left < right) {
             int mid = (left + right) / 2;
 
-            if (nums[mid] >= nums[0]) {
+            if (nums[mid] > nums[right]) {
                 left = mid + 1;
             } else {
                 right = mid;

src/graph/PacificAtlanticWaterFlow.java

@@ -0,0 +1,130 @@
+package graph;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/pacific-atlantic-water-flow
+ * Difficulty: Medium
+ */
+public class PacificAtlanticWaterFlow {
+
+    private int[][] directions;
+
+    /**
+     * Time complexity: O(m * n)
+     * Space complexity: O(m * n)
+     */
+    public List<List<Integer>> pacificAtlanticOptimalApproach(int[][] heights) {
+        directions = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+        int[][] pacific = new int[heights.length][heights[0].length];
+        int[][] atlantic = new int[heights.length][heights[0].length];
+
+        // start flow from left and right borders
+        for (int i = 0; i < heights.length; i++) {
+            dfs(heights, pacific, new int[]{i, 0});
+            dfs(heights, atlantic, new int[]{i, heights.length - 1});
+        }
+
+        // start flow from top and bottom borders
+        for (int i = 0; i < heights[0].length; i++) {
+            dfs(heights, pacific, new int[]{0, i});
+            dfs(heights, atlantic, new int[]{heights[0].length - 1, i});
+        }
+
+        // if cell was visited by both flows -> add to the result
+        List<List<Integer>> result = new ArrayList<>();
+        for (int i = 0; i < heights.length; i++) {
+            for (int j = 0; j < heights[0].length; j++) {
+                if (pacific[i][j] != 0 && atlantic[i][j] != 0) {
+                    result.add(List.of(i, j));
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private void dfs(int[][] heights, int[][] visited, int[] start) {
+        Deque<int[]> stack = new LinkedList<>();
+        stack.push(start);
+
+        while (!stack.isEmpty()) {
+            int[] current = stack.poll();
+
+            if (visited[current[0]][current[1]] == 0) {
+                stack.push(current);
+                visited[current[0]][current[1]] = 1;
+
+                for (int[] dir : directions) {
+                    int x = current[0] + dir[0];
+                    int y = current[1] + dir[1];
+
+                    if (x >= 0 && y >= 0 && x < heights.length && y < heights[0].length
+                            && visited[x][y] == 0
+                            // we're going backwards -> next height should be greater or equal than current
+                            && heights[x][y] >= heights[current[0]][current[1]]) {
+                        stack.push(new int[]{x, y});
+                    }
+                }
+            } else if (visited[current[0]][current[1]] == 1) {
+                visited[current[0]][current[1]] = 2;
+            }
+        }
+    }
+
+    /**
+     * Time complexity: O(m^2 * n^2)
+     * Space complexity: O(m * n)
+     */
+    public List<List<Integer>> pacificAtlanticNaiveApproach(int[][] heights) {
+        directions = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+
+        List<List<Integer>> result = new ArrayList<>();
+        for (int i = 0; i < heights.length; i++) {
+            for (int j = 0; j < heights[0].length; j++) {
+                if (canFlowBothWays(heights, new int[]{i, j})) {
+                    result.add(List.of(i, j));
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private boolean canFlowBothWays(int[][] heights, int[] start) {
+        int[][] visited = new int[heights.length][heights[0].length];
+        boolean hasPacificPath = false;
+        boolean hasAtlanticPath = false;
+
+        Deque<int[]> stack = new LinkedList<>();
+        stack.push(start);
+
+        while (!stack.isEmpty()) {
+            int[] current = stack.poll();
+
+            if (visited[current[0]][current[1]] == 0) {
+                visited[current[0]][current[1]] = 1;
+                stack.push(current);
+
+                for (int[] dir : directions) {
+                    int x = current[0] + dir[0];
+                    int y = current[1] + dir[1];
+
+                    if (x < 0 || y < 0) {
+                        hasPacificPath = true;
+                    } else if (x >= heights.length || y >= heights[0].length) {
+                        hasAtlanticPath = true;
+                    } else if (visited[x][y] == 0 && heights[x][y] <= heights[current[0]][current[1]]) {
+                        stack.push(new int[]{x, y});
+                    }
+
+                    if (hasPacificPath && hasAtlanticPath) return true;
+                }
+            } else if (visited[current[0]][current[1]] == 1) {
+                visited[current[0]][current[1]] = 2;
+            }
+        }
+
+        return false;
+    }
+}

src/hash_table/InsertDeleteGetRandom.java

@@ -0,0 +1,57 @@
+package hash_table;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/insert-delete-getrandom-o1
+ * Difficulty: Medium
+ * Time complexity: O(1)
+ * Space complexity: O(n)
+ */
+public class InsertDeleteGetRandom {
+
+    private static class RandomizedSet {
+
+        private final List<Integer> values;
+        private final Map<Integer, Integer> indicesMap;
+        private final Random random;
+
+        public RandomizedSet() {
+            values = new ArrayList<>();
+            indicesMap = new HashMap<>();
+            random = new Random();
+        }
+
+        public boolean insert(int val) {
+            if (indicesMap.containsKey(val)) return false;
+
+            values.add(val);
+            indicesMap.put(val, values.size() - 1);
+
+            return true;
+        }
+
+        public boolean remove(int val) {
+            if (!indicesMap.containsKey(val)) return false;
+
+            int idx = indicesMap.get(val);
+            int lastIdx = values.size() - 1;
+
+            if (idx != lastIdx) { // overwrite element to be removed with the last one
+                int lastVal = values.get(lastIdx);
+                values.set(idx, lastVal);
+                indicesMap.put(lastVal, idx);
+            }
+
+            values.remove(lastIdx); // remove the last element
+            indicesMap.remove(val);
+
+            return true;
+        }
+
+        public int getRandom() {
+            int randomIdx = random.nextInt(values.size());
+            return values.get(randomIdx);
+        }
+    }
+}

src/hash_table/InsertDeleteGetRandomDuplicatesAllowed.java

@@ -0,0 +1,62 @@
+package hash_table;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed
+ * Difficulty: Hard
+ * Time complexity: O(1)
+ * Space complexity: O(n)
+ */
+public class InsertDeleteGetRandomDuplicatesAllowed {
+
+    private static class RandomizedCollection {
+
+        private final List<Integer> values;
+        private final Map<Integer, Set<Integer>> indicesMap;
+        private final Random random;
+
+        public RandomizedCollection() {
+            values = new ArrayList<>();
+            indicesMap = new HashMap<>();
+            random = new Random();
+        }
+
+        public boolean insert(int val) {
+            values.add(val);
+            Set<Integer> indices = indicesMap.computeIfAbsent(val, __ -> new HashSet<>());
+            indices.add(values.size() - 1);
+
+            return indices.size() == 1;
+        }
+
+        public boolean remove(int val) {
+            Set<Integer> indices = indicesMap.getOrDefault(val, Set.of());
+            if (indices.isEmpty()) return false;
+
+            int idx = indices.iterator().next();
+            indices.remove(idx);
+
+            int lastIdx = values.size() - 1;
+
+            if (idx != lastIdx) { // overwrite element to be removed with the last one
+                int lastVal = values.get(lastIdx);
+                values.set(idx, lastVal);
+
+                Set<Integer> lastValIndices = indicesMap.get(lastVal);
+                lastValIndices.remove(lastIdx);
+                lastValIndices.add(idx);
+            }
+
+            values.remove(lastIdx); // remove the last element
+            if (indices.isEmpty()) indicesMap.remove(val);
+
+            return true;
+        }
+
+        public int getRandom() {
+            int randomIdx = random.nextInt(values.size());
+            return values.get(randomIdx);
+        }
+    }
+}

src/heap/ReorganizeString.java

@@ -0,0 +1,63 @@
+package heap;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/reorganize-string
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class ReorganizeString {
+
+    public String reorganizeString(String s) {
+        Map<Character, Integer> frequencyMap = buildFrequencyMap(s);
+        Queue<Map.Entry<Character, Integer>> maxHeap = new PriorityQueue<>(
+                (e1, e2) -> Integer.compare(e2.getValue(), e1.getValue()));
+        maxHeap.addAll(frequencyMap.entrySet());
+
+        StringBuilder possibleRearrangement = new StringBuilder();
+        while (maxHeap.size() > 1) {
+            Map.Entry<Character, Integer> first = maxHeap.poll();
+            Map.Entry<Character, Integer> second = maxHeap.poll();
+
+            possibleRearrangement
+                    .append(first.getKey())
+                    .append(second.getKey());
+
+            int firstLeft = first.getValue();
+            if (firstLeft > 1) {
+                first.setValue(firstLeft - 1);
+                maxHeap.offer(first);
+            }
+
+            int secondLeft = second.getValue();
+            if (secondLeft > 1) {
+                second.setValue(secondLeft);
+                maxHeap.offer(second);
+            }
+        }
+
+        if (!maxHeap.isEmpty()) {
+            if (maxHeap.peek().getValue() > 1) {
+                return "";
+            } else {
+                possibleRearrangement.append(maxHeap.poll().getKey());
+            }
+        }
+
+        return possibleRearrangement.toString();
+    }
+
+    private Map<Character, Integer> buildFrequencyMap(String s) {
+        Map<Character, Integer> frequencyMap = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            frequencyMap.merge(c, 1, Integer::sum);
+        }
+
+        return frequencyMap;
+    }
+}