Update

Author: ex01tus

src/graph/AlienDictionary.java

@@ -0,0 +1,88 @@
+package graph;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/alien-dictionary
+ * Difficulty: Hard
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class AlienDictionary {
+
+    public String alienOrderViaTopologicalSort(String[] words) {
+        Map<Character, List<Character>> adjList = buildAdjList(words);
+        if (adjList.isEmpty()) return "";
+
+        // topologically sorted (DESC) graph nodes
+        StringBuilder sortedChars = new StringBuilder();
+        int[] visited = new int[26];
+        for (char c : adjList.keySet()) {
+            if (visited[c - 'a'] == 0 && hasCycle(c, adjList, visited, sortedChars)) {
+                // cycle found -> no valid answer
+                return "";
+            }
+        }
+
+        return sortedChars.reverse().toString();
+    }
+
+    private boolean hasCycle(
+            char start,
+            Map<Character, List<Character>> adjList,
+            int[] visited,
+            StringBuilder sortedChars) {
+        Deque<Character> stack = new LinkedList<>();
+        stack.push(start);
+
+        while (!stack.isEmpty()) {
+            char current = stack.pop();
+            if (visited[current - 'a'] == 0) {
+                visited[current - 'a'] = 1;
+                stack.push(current);
+
+                for (char neighbor : adjList.getOrDefault(current, List.of())) {
+                    if (visited[neighbor - 'a'] == 1) return true;
+                    if (visited[neighbor - 'a'] == 0) {
+                        stack.push(neighbor);
+                    }
+                }
+            } else if (visited[current - 'a'] == 1) {
+                visited[current - 'a'] = 2;
+                sortedChars.append(current);
+            }
+        }
+
+        return false;
+    }
+
+    private Map<Character, List<Character>> buildAdjList(String[] words) {
+        Map<Character, List<Character>> adjList = new HashMap<>();
+
+        // find all nodes
+        for (String word : words) {
+            for (char c : word.toCharArray()) {
+                adjList.putIfAbsent(c, new ArrayList<>());
+            }
+        }
+
+        // find all edges
+        for (int i = 1; i < words.length; i++) {
+            String word1 = words[i - 1];
+            String word2 = words[i];
+
+            // prefix goes after longer word -> invalid sequence
+            if (word2.length() < word1.length() && word1.startsWith(word2)) return Map.of();
+
+            for (int j = 0; j < Math.min(word1.length(), word2.length()); j++) {
+                // find first non match
+                if (word1.charAt(j) != word2.charAt(j)) {
+                    adjList.get(word1.charAt(j)).add(word2.charAt(j));
+                    break;
+                }
+            }
+        }
+
+        return adjList;
+    }
+}

src/graph/CourseSchedule2.java

@@ -12,7 +12,7 @@ public class CourseSchedule2 {
     private int[] visited;
     private Deque<Integer> topologicalPath;
 
-    public int[] findOrder(int numCourses, int[][] prerequisites) {
+    public int[] findOrderViaTopologicalSort(int numCourses, int[][] prerequisites) {
         visited = new int[numCourses];
         topologicalPath = new LinkedList<>();
         Map<Integer, List<Integer>> adjList = buildAdjList(prerequisites);

src/linked_list/PartitionList.java

@@ -0,0 +1,38 @@
+package linked_list;
+
+/**
+ * Description: https://leetcode.com/problems/partition-list
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class PartitionList {
+
+    public ListNode partition(ListNode head, int x) {
+        ListNode dummyLeft = new ListNode();
+        ListNode left = dummyLeft;
+        ListNode dummyRight = new ListNode();
+        ListNode right = dummyRight;
+
+        while (head != null) {
+            if (head.val < x) {
+                left.next = head;
+                left = left.next;
+            } else {
+                right.next = head;
+                right = right.next;
+            }
+
+            head = head.next;
+        }
+
+        right.next = null;
+        left.next = dummyRight.next;
+        return dummyLeft.next;
+    }
+
+    private static class ListNode {
+        int val;
+        ListNode next;
+    }
+}

src/math/CheckIfItIsStraightLine.java

@@ -0,0 +1,26 @@
+package math;
+
+/**
+ * Description: https://leetcode.com/problems/check-if-it-is-a-straight-line
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class CheckIfItIsStraightLine {
+
+    public boolean checkStraightLine(int[][] coordinates) {
+        double slope = getSlope(coordinates[0], coordinates[1]);
+        for (int i = 2; i < coordinates.length; i++) {
+            if (getSlope(coordinates[i], coordinates[i - 1]) != slope) return false;
+        }
+
+        return true;
+    }
+
+    private double getSlope(int[] point1, int[] point2) {
+        if (point1[0] == point2[0]) return Double.POSITIVE_INFINITY;
+        if (point1[1] == point2[1]) return 0.0;
+
+        return (double) (point1[1] - point2[1]) / (point1[0] - point2[0]);
+    }
+}

src/trie/SearchSuggestionsSystem.java

@@ -0,0 +1,65 @@
+package trie;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/search-suggestions-system
+ * Difficulty: Medium
+ */
+public class SearchSuggestionsSystem {
+
+    private static final int SUGGESTIONS_SIZE_LIMIT = 3;
+
+    public List<List<String>> suggestedProducts(String[] products, String searchWord) {
+        Node trie = buildTrie(products);
+
+        List<List<String>> suggestions = new ArrayList<>();
+        boolean noMoreSuggestions = false;
+        for (char c : searchWord.toCharArray()) {
+            Node child = trie.children.get(c);
+            if (child == null) noMoreSuggestions = true;
+
+            if (noMoreSuggestions) {
+                suggestions.add(List.of());
+            } else {
+                suggestions.add(child.suggestions);
+                trie = child;
+            }
+        }
+
+        return suggestions;
+    }
+
+    private Node buildTrie(String[] products) {
+        Arrays.sort(products);
+
+        Node root = new Node();
+        for (String product : products) {
+            Node current = root;
+            for (char c : product.toCharArray()) {
+                Node child = current.children.computeIfAbsent(c, __ -> new Node());
+                child.addSuggestion(product);
+                current = child;
+            }
+        }
+
+        return root;
+    }
+
+    private static class Node {
+
+        private final Map<Character, Node> children;
+        private final List<String> suggestions;
+
+        public Node() {
+            this.children = new HashMap<>();
+            this.suggestions = new ArrayList<>();
+        }
+
+        public void addSuggestion(String product) {
+            if (suggestions.size() < SUGGESTIONS_SIZE_LIMIT) {
+                suggestions.add(product);
+            }
+        }
+    }
+}