Update

Author: ex01tus

src/array/MovingAverageFromDataStream.java

@@ -0,0 +1,56 @@
+package array;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+/**
+ * Description: https://leetcode.com/problems/moving-average-from-data-stream
+ * Difficulty: Easy
+ * Time complexity: O(1)
+ * Space complexity: O(m)
+ */
+public class MovingAverageFromDataStream {
+
+    private static class MovingAverageViaDeque {
+
+        private final Deque<Integer> window;
+        private final int maxWindowSize;
+        private int windowSum;
+
+        public MovingAverageViaDeque(int size) {
+            this.window = new LinkedList<>();
+            this.maxWindowSize = size;
+        }
+
+        public double next(int val) {
+            windowSum += val;
+            window.offerLast(val);
+            if (window.size() > maxWindowSize) {
+                windowSum -= window.pollFirst();
+            }
+
+            return (double) windowSum / window.size();
+        }
+    }
+
+    private static class MovingAverageViaRingBuffer {
+
+        private final int[] window;
+        private int current;
+        private int windowSum;
+        private int count;
+
+        public MovingAverageViaRingBuffer(int size) {
+            this.window = new int[size];
+        }
+
+        public double next(int val) {
+            count++;
+            windowSum = windowSum - window[current] + val;
+            window[current] = val;
+            current = (current + 1) % window.length;
+
+            return (double) windowSum / Math.min(count, window.length);
+        }
+    }
+}

src/array/NumberOfEquivalentDominoPairs.java

@@ -0,0 +1,31 @@
+package array;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/number-of-equivalent-domino-pairs
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class NumberOfEquivalentDominoPairs {
+
+    public int numEquivDominoPairs(int[][] dominoes) {
+        Map<Integer, Integer> freqMap = new HashMap<>();
+        int pairs = 0;
+
+        for (int[] domino : dominoes) {
+            // hash
+            int value = Math.min(domino[0], domino[1]) * 10 + Math.max(domino[0], domino[1]);
+
+            // form a pair with each previously seen equivalent
+            pairs += freqMap.getOrDefault(value, 0);
+
+            // increment frequency counter
+            freqMap.merge(value, 1, Integer::sum);
+        }
+
+        return pairs;
+    }
+}

src/binary_search/FirstBadVersion.java

@@ -25,6 +25,7 @@ public int firstBadVersion(int n) {
         return left;
     }
 
+    // API call
     private boolean isBadVersion(int n) {
         return true;
     }

src/dynamic_programming/LongestPalindromicSubsequence.java

@@ -0,0 +1,32 @@
+package dynamic_programming;
+
+/**
+ * Description: https://leetcode.com/problems/longest-palindromic-subsequence
+ * Difficulty: Medium
+ * Time complexity: O(n^2)
+ * Space complexity: O(n^2)
+ */
+public class LongestPalindromicSubsequence {
+
+    public int longestPalindromeSubseq(String s) {
+        int[][] dp = new int[s.length()][s.length()];
+
+        for (int right = 0; right < s.length(); right++) {
+            for (int left = right; left >= 0; left--) {
+                if (left == right) {
+                    dp[left][right] = 1;
+                    continue;
+                }
+
+                if (s.charAt(left) == s.charAt(right)) {
+                    int length = right - left + 1;
+                    dp[left][right] = length <= 3 ? length : dp[left + 1][right - 1] + 2;
+                } else {
+                    dp[left][right] = Math.max(dp[left + 1][right], dp[left][right - 1]);
+                }
+            }
+        }
+
+        return dp[0][s.length() - 1];
+    }
+}

src/graph/FindTheCelebrity.java

@@ -0,0 +1,54 @@
+package graph;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/find-the-celebrity
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1) or O(n) with cache
+ */
+public class FindTheCelebrity {
+
+    private final Map<Relation, Boolean> cache = new HashMap<>();
+
+    public int findCelebrity(int n) {
+        int candidate = 0;
+        for (int man = 1; man < n; man++) {
+            if (cachedKnows(candidate, man)) {
+                candidate = man;
+            }
+        }
+
+        if (isCelebrity(candidate, n)) {
+            return candidate;
+        }
+
+        return -1;
+    }
+
+    private boolean isCelebrity(int candidate, int n) {
+        for (int man = 0; man < n; man++) {
+            if (man == candidate) continue;
+            if (cachedKnows(candidate, man) || !cachedKnows(man, candidate)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    // use if API calls are expensive
+    private boolean cachedKnows(int a, int b) {
+        return cache.computeIfAbsent(new Relation(a, b), __ -> knows(a, b));
+    }
+
+    private record Relation(int a, int b) {
+    }
+
+    // API call
+    private boolean knows(int a, int b) {
+        return true;
+    }
+}

src/graph/FindTheTownJudge.java

@@ -0,0 +1,28 @@
+package graph;
+
+/**
+ * Description: https://leetcode.com/problems/find-the-town-judge
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class FindTheTownJudge {
+
+    public int findJudge(int n, int[][] trust) {
+        int[] trusts = new int[n + 1];
+        int[] trustedBy = new int[n + 1];
+
+        for (int[] relation : trust) {
+            trusts[relation[0]]++;
+            trustedBy[relation[1]]++;
+        }
+
+        for (int man = 1; man <= n; man++) {
+            if (trusts[man] == 0 && trustedBy[man] == n - 1) {
+                return man;
+            }
+        }
+
+        return -1;
+    }
+}

src/graph/FlowerPlantingWithNoAdjacent.java

@@ -0,0 +1,76 @@
+package graph;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/flower-planting-with-no-adjacent
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class FlowerPlantingWithNoAdjacent {
+
+    public int[] gardenNoAdj(int n, int[][] paths) {
+        Map<Integer, List<Integer>> adjList = buildAdjList(paths);
+
+        int[] colors = new int[n];
+        for (int garden = 0; garden < n; garden++) {
+            if (colors[garden] == 0) {
+                bfs(adjList, colors, garden);
+            }
+        }
+
+        return colors;
+    }
+
+    private void bfs(Map<Integer, List<Integer>> adjList, int[] colors, int start) {
+        Queue<Integer> planned = new LinkedList<>();
+        planned.offer(start);
+        colors[start] = 1;
+
+        while (!planned.isEmpty()) {
+            int current = planned.poll();
+
+            for (int neighbor : adjList.getOrDefault(current, List.of())) {
+                if (colors[neighbor] == 0) {
+                    // colors are 1-indexed: (colors[current] - 1 + 1) % 4 + 1 = colors[current] % 4 + 1
+                    colors[neighbor] = colors[current] % 4 + 1;
+                    planned.offer(neighbor);
+                } else if (colors[neighbor] == colors[current]) {
+                    colors[neighbor] = colors[current] % 4 + 1;
+                }
+            }
+        }
+    }
+
+    public int[] gardenNoAdjViaGreedyAlgo(int n, int[][] paths) {
+        Map<Integer, List<Integer>> adjList = buildAdjList(paths);
+
+        int[] colors = new int[n];
+        for (int garden = 0; garden < n; garden++) {
+            Set<Integer> usedColors = new HashSet<>();
+            for (int neighbor : adjList.getOrDefault(garden, List.of())) {
+                usedColors.add(colors[neighbor]);
+            }
+
+            for (int color = 1; color <= 4; color++) {
+                if (!usedColors.contains(color)) {
+                    colors[garden] = color;
+                    break;
+                }
+            }
+        }
+
+        return colors;
+    }
+
+    private Map<Integer, List<Integer>> buildAdjList(int[][] paths) {
+        Map<Integer, List<Integer>> adjList = new HashMap<>();
+        for (int[] path : paths) {
+            adjList.computeIfAbsent(path[0] - 1, __ -> new ArrayList<>()).add(path[1] - 1);
+            adjList.computeIfAbsent(path[1] - 1, __ -> new ArrayList<>()).add(path[0] - 1);
+        }
+
+        return adjList;
+    }
+}

src/graph/IsGraphBipartite.java

@@ -0,0 +1,53 @@
+package graph;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/is-graph-bipartite
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class IsGraphBipartite {
+
+    private static final int RED = 0;
+    private static final int BLUE = 1;
+    private static final int UNDEFINED = -1;
+
+    public boolean isBipartite(int[][] graph) {
+        int[] colors = new int[graph.length];
+        Arrays.fill(colors, UNDEFINED);
+
+        for (int i = 0; i < graph.length; i++) {
+            if (colors[i] == UNDEFINED && !isBipartite(i, graph, colors)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+    private boolean isBipartite(int start, int[][] graph, int[] colors) {
+        Queue<Integer> planned = new LinkedList<>();
+        planned.offer(start);
+        colors[start] = RED;
+
+        while (!planned.isEmpty()) {
+            int current = planned.poll();
+
+            for (int neighbor : graph[current]) {
+                if (colors[neighbor] == UNDEFINED) {
+                    // color nodes red-blue-red-blue-...
+                    colors[neighbor] = (colors[current] + 1) % 2;
+                    planned.offer(neighbor);
+                } else if (colors[neighbor] == colors[current]) {
+                    // if colors of neighbors match – graph is not bipartile
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}

src/graph/MaximalNetworkRank.java

@@ -0,0 +1,31 @@
+package graph;
+
+/**
+ * Description: https://leetcode.com/problems/maximal-network-rank
+ * Difficulty: Medium
+ * Time complexity: O(n^2)
+ * Space complexity: O(n^2)
+ */
+public class MaximalNetworkRank {
+
+    public int maximalNetworkRank(int n, int[][] roads) {
+        int[] ranks = new int[n];
+        int[][] adjMatrix = new int[n][n];
+        for (int[] road : roads) {
+            ranks[road[0]]++;
+            ranks[road[1]]++;
+            adjMatrix[road[0]][road[1]] = 1;
+            adjMatrix[road[1]][road[0]] = 1;
+        }
+
+        int maxRank = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                // road between 'i' and 'j' is only counted once -> subtract 1 if connection exists
+                maxRank = Math.max(maxRank, ranks[i] + ranks[j] - adjMatrix[i][j]);
+            }
+        }
+
+        return maxRank;
+    }
+}