Update

Author: ex01tus

src/array/LongestSubarrayOfOnesAfterDeletingOneElement.java

@@ -0,0 +1,53 @@
+package array;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/longest-subarray-of-1s-after-deleting-one-element
+ * Difficulty: Medium
+ */
+public class LongestSubarrayOfOnesAfterDeletingOneElement {
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
+    public int longestSubarray(int[] nums) {
+        int left = 0;
+        int right = 0;
+        int removalsLeft = 1;
+
+        while (right < nums.length) {
+            if (nums[right] == 0) removalsLeft--;
+            if (removalsLeft < 0) {
+                if (nums[left] == 0) removalsLeft++;
+                left++;
+            }
+
+            right++;
+        }
+
+        return right - left - 1;
+    }
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(k)
+     */
+    public int longestSubarrayForDataStream(int[] nums) {
+        int left = 0;
+        int longest = 0;
+        Queue<Integer> zeroes = new LinkedList<>();
+        for (int right = 0; right < nums.length; right++) {
+            if (nums[right] == 0) zeroes.offer(right);
+            if (zeroes.size() > 1) {
+                left = zeroes.poll() + 1;
+            }
+
+            longest = Math.max(longest, right - left);
+        }
+
+        return longest;
+    }
+}

src/array/MaxNumberOfKSumPairs.java

@@ -0,0 +1,34 @@
+package array;
+
+import java.util.Arrays;
+
+/**
+ * Description: https://leetcode.com/problems/max-number-of-k-sum-pairs
+ * Difficulty: Medium
+ * Time complexity: O(nlog n)
+ * Space complexity: O(log n)
+ */
+public class MaxNumberOfKSumPairs {
+
+    public int maxOperations(int[] nums, int k) {
+        Arrays.sort(nums);
+
+        int left = 0;
+        int right = nums.length - 1;
+        int pairs = 0;
+        while (left < right) {
+            int sum = nums[left] + nums[right];
+            if (sum > k) {
+                right--;
+            } else if (sum < k) {
+                left++;
+            } else {
+                pairs++;
+                left++;
+                right--;
+            }
+        }
+
+        return pairs;
+    }
+}

src/design/NumberOfRecentCalls.java

@@ -0,0 +1,31 @@
+package design;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/number-of-recent-calls
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class NumberOfRecentCalls {
+
+    private static class RecentCounterViaQueue {
+
+        private final Queue<Integer> hits;
+
+        public RecentCounterViaQueue() {
+            this.hits = new LinkedList<>();
+        }
+
+        public int ping(int timestamp) {
+            hits.offer(timestamp);
+            while (!hits.isEmpty() && timestamp - hits.peek() > 3000) {
+                hits.poll();
+            }
+
+            return hits.size();
+        }
+    }
+}

src/design/SnapshotArray.java

@@ -0,0 +1,41 @@
+package design;
+
+import java.util.TreeMap;
+
+/**
+ * Description: https://leetcode.com/problems/snapshot-array
+ * Difficulty: Medium
+ * Time complexity: O(log n) for get(), O(1) for set() and snap()
+ * Space complexity: O(n)
+ */
+public class SnapshotArray {
+
+    private static class SnapshotArrayViaTreeMap {
+
+        private final TreeMap<Integer, Integer>[] versionedValues;
+        private int currentVersion;
+
+        public SnapshotArrayViaTreeMap(int length) {
+            this.versionedValues = new TreeMap[length];
+            for (int i = 0; i < length; i++) {
+                TreeMap<Integer, Integer> map = new TreeMap<>();
+                map.put(0 ,0);
+                versionedValues[i] = map;
+            }
+        }
+
+        public void set(int index, int val) {
+            versionedValues[index].put(currentVersion, val);
+        }
+
+        public int snap() {
+            return currentVersion++;
+        }
+
+        public int get(int index, int snapshotId) {
+            // find first less than or equal version
+            return versionedValues[index].floorEntry(snapshotId).getValue();
+        }
+    }
+}
+

src/graph/ReconstructItinerary.java

@@ -0,0 +1,66 @@
+package graph;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/reconstruct-itinerary
+ * Difficulty: Hard
+ * Time complexity: O(V ^ E)
+ * Space complexity: O(V + E)
+ */
+public class ReconstructItinerary {
+
+    private static final String START = "JFK";
+
+    public List<String> findItinerary(List<List<String>> tickets) {
+        Map<String, List<Ticket>> adjList = buildAdjList(tickets);
+
+        List<String> itinerary = new ArrayList<>();
+        itinerary.add(START);
+        int[] usedTickets = new int[tickets.size()];
+
+        return findItinerary(START, adjList, usedTickets, itinerary);
+    }
+
+    private List<String> findItinerary(
+            String current,
+            Map<String, List<Ticket>> adjList,
+            int[] usedTickets,
+            List<String> currentItinerary) {
+        if (currentItinerary.size() == usedTickets.length + 1) {
+            return currentItinerary;
+        }
+
+        for (Ticket next : adjList.getOrDefault(current, List.of())) {
+            if (usedTickets[next.index] == 0) {
+                usedTickets[next.index] = 1;
+                currentItinerary.add(next.destination);
+
+                List<String> itinerary = findItinerary(next.destination, adjList, usedTickets, currentItinerary);
+                if (!itinerary.isEmpty()) return itinerary;
+
+                usedTickets[next.index] = 0;
+                currentItinerary.remove(currentItinerary.size() - 1);
+            }
+        }
+
+        return List.of();
+    }
+
+    private Map<String, List<Ticket>> buildAdjList(List<List<String>> tickets) {
+        Map<String, List<Ticket>> adjList = new HashMap<>();
+        for (int i = 0; i < tickets.size(); i++) {
+            List<String> ticket = tickets.get(i);
+            adjList.computeIfAbsent(ticket.get(0), __ -> new ArrayList<>()).add(new Ticket(ticket.get(1), i));
+        }
+
+        for (List<Ticket> t : adjList.values()) {
+            t.sort(Comparator.comparing(a -> a.destination));
+        }
+
+        return adjList;
+    }
+
+    private record Ticket(String destination, int index) {
+    }
+}

src/graph/SnakesAndLadders.java

@@ -0,0 +1,61 @@
+package graph;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/snakes-and-ladders
+ * Difficulty: Medium
+ * Time complexity: O(n * n)
+ * Space complexity: O(n * n)
+ */
+public class SnakesAndLadders {
+
+    public int snakesAndLadders(int[][] board) {
+        int[] labels = initLabels(board);
+        return findShortestPath(board, labels);
+    }
+
+    private int findShortestPath(int[][] board, int[] labels) {
+        Queue<Integer> planned = new LinkedList<>();
+        planned.offer(1);
+        int[] visited = new int[board.length * board.length + 1];
+        visited[1] = 1;
+
+        int path = 0;
+        while (!planned.isEmpty()) {
+            int levelSize = planned.size();
+            path++;
+
+            for (int i = 0; i < levelSize; i++) {
+                int current = planned.poll();
+                for (int next = current + 1; next <= Math.min(current + 6, board.length * board.length); next++) {
+                    int destination = labels[next] > 0 ? labels[next] : next; // check for possible snake or ladder
+                    if (destination == board.length * board.length) return path;
+
+                    if (visited[destination] == 0) {
+                        planned.offer(destination);
+                        visited[destination] = 1;
+                    }
+                }
+            }
+        }
+
+        return -1;
+    }
+
+    private int[] initLabels(int[][] board) {
+        int[] labels = new int[board.length * board.length + 1];
+        boolean goRight = true;
+        int val = 1;
+        for (int row = board.length - 1; row >= 0; row--) {
+            for (int col = 0; col < board[0].length; col++) {
+                labels[val++] = goRight ? board[row][col] : board[row][board[0].length - col - 1];
+            }
+
+            goRight = !goRight;
+        }
+
+        return labels;
+    }
+}

src/matrix/EqualRowAndColumnPairs.java

@@ -0,0 +1,56 @@
+package matrix;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/equal-row-and-column-pairs
+ * Difficulty: Medium
+ * Time complexity: O(n^3)
+ * Space complexity: O(n^2)
+ */
+public class EqualRowAndColumnPairs {
+
+    public int equalPairsViaFreqMap(int[][] grid) {
+        Map<String, Integer> freqMap = new HashMap<>();
+        for (int[] row : grid) {
+            freqMap.merge(Arrays.toString(row), 1, Integer::sum);
+        }
+
+        int pairs = 0;
+        for (int col = 0; col < grid[0].length; col++) {
+            int[] column = new int[grid.length];
+            for (int row = 0; row < grid[0].length; row++) {
+                column[row] = grid[row][col];
+            }
+
+            pairs += freqMap.getOrDefault(Arrays.toString(column), 0);
+        }
+
+        return pairs;
+    }
+
+    public int equalPairsViaTransposition(int[][] grid) {
+        int[][] transposed = transpose(grid);
+        int pairs = 0;
+        for (int[] originalRow : grid) {
+            for (int[] transposedRow : transposed) {
+                if (Arrays.equals(originalRow, transposedRow)) pairs++;
+            }
+        }
+
+        return pairs;
+    }
+
+    private int[][] transpose(int[][] grid) {
+        int[][] transposed = new int[grid[0].length][grid.length];
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                transposed[j][i] = grid[i][j];
+            }
+        }
+
+        return transposed;
+    }
+}