practice

Author: metanet

src/problems/leetcode/CourseSchedule.java

@@ -138,7 +138,6 @@ public boolean equals(Object obj) {
     public static boolean canFinish(int numCourses, int[][] prerequisites) {
         // course -> preq course
         Map<Integer, List<Integer>> edges = new HashMap<>();
-
         for (int[] p : prerequisites) {
             edges.computeIfAbsent(p[0], (k) -> new ArrayList<>()).add(p[1]);
         }

src/problems/leetcode/CourseScheduleII.java

@@ -49,7 +49,8 @@ private List[] buildAdjList(int numCourses, int[][] prerequisites) {
         return preLists;
     }
 
-    private void DFS(int course, List[] preLists, Set<Integer> visited, boolean[] done, List<Integer> completedCourses) {
+    private void DFS(int course, List[] preLists, Set<Integer> visited, boolean[] done,
+            List<Integer> completedCourses) {
         visited.add(course);
         done[course] = true;
         List<Integer> preCourses = preLists[course];
@@ -65,13 +66,58 @@ private void DFS(int course, List[] preLists, Set<Integer> visited, boolean[] do
         }
 
         visited.remove(course);
-
         completedCourses.add(course);
     }
 
+    public int[] findOrder2(int numCourses, int[][] prerequisites) {
+        // course -> preq course
+        Map<Integer, List<Integer>> edges = new HashMap<>();
+        for (int[] p : prerequisites) {
+            edges.computeIfAbsent(p[0], (k) -> new ArrayList<>()).add(p[1]);
+        }
+
+        try {
+            boolean[] done = new boolean[numCourses];
+            boolean[] currentPath = new boolean[numCourses];
+            List<Integer> completed = new ArrayList<>();
+            for (int course = 0; course < numCourses; course++) {
+                if (!done[course]) {
+                    tpl(edges, course, done, completed, currentPath);
+                }
+            }
+
+            // System.out.println("completed=" + completed);
+            return completed.stream()
+                                .mapToInt(Integer::intValue)
+                                .toArray();
+        } catch (IllegalArgumentException e) {
+            return new int[0];
+        }
+    }
+
+    private void tpl(Map<Integer, List<Integer>> edges, int course, boolean[] done, List<Integer> completed, boolean[] currentPath) {
+        currentPath[course] = true;
+        done[course] = true;
+        List<Integer> preqs = edges.get(course);
+        if (preqs != null) {
+            for (int preq : preqs) {
+                if (currentPath[preq]) {
+                    throw new IllegalArgumentException();
+                } else if (!done[preq]) {
+                    tpl(edges, preq, done, completed, currentPath);
+                }
+            }
+        }
+        completed.add(course);
+        currentPath[course] = false;
+    }
+
     public static void main(String[] args) {
-        int[] order = new CourseScheduleII().findOrder(5, new int[][]{{0, 1}, {1, 2}, {1, 3}, {3, 4}, {4, 3}});
-//        int[] order = new CourseScheduleII().findOrder(3, new int[][] {{0, 1}, {0, 2}, {1, 2}});
+        // int[] order = new CourseScheduleII().findOrder(5, new int[][]{{0, 1}, {1, 2},
+        // {1, 3}, {3, 4}, {4, 3}});
+        // int[] order = new CourseScheduleII().findOrder(3, new int[][] {{0, 1}, {0,
+        // 2}, {1, 2}});
+        int[] order = new CourseScheduleII().findOrder(3, new int[][] { { 0, 1 }, { 1, 0 } });
         System.out.println(Arrays.toString(order));
     }
 

src/problems/leetcode/HIndex.java

@@ -0,0 +1,28 @@
+package problems.leetcode;
+
+// https://leetcode.com/problems/h-index/
+public class HIndex {
+    
+    // https://leetcode.com/problems/h-index/solutions/70768/java-bucket-sort-o-n-solution-with-detail-explanation/
+    public int hIndex(int[] citations) {
+        int n = citations.length;
+        int[] buckets = new int[n+1];
+        for (int c : citations) {
+            if (c >= n) {
+                buckets[n]++;
+            } else {
+                buckets[c]++;
+            }
+        }
+        int count = 0;
+        for(int i = n; i >= 0; i--) {
+            count += buckets[i];
+            if (count >= i) {
+                return i;
+            }
+        }
+        
+        return 0;   
+    }
+
+}

src/problems/leetcode/ImplementStackUsingQueues.java

@@ -0,0 +1,62 @@
+package problems.leetcode;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+// https://leetcode.com/problems/implement-stack-using-queues/submissions/
+public class ImplementStackUsingQueues {
+
+    private static class MyStack {
+
+        // push 1
+        // push 2
+        // push 3
+        // peek -> 3
+        // pop 3
+        // push 4
+        // peek -> 4
+    
+        // 1 -> 2 -> 3 -> 4
+    
+        private Deque<Integer> queue1 = new ArrayDeque<>();
+        private Deque<Integer> queue2 = new ArrayDeque<>();
+    
+        public MyStack() {
+            
+        }
+        
+        public void push(int x) {
+            queue1.addLast(x);
+        }
+        
+        public int pop() {
+            while (queue1.size() > 1) {
+                queue2.addLast(queue1.removeFirst());
+            }
+    
+            int i = queue1.removeFirst();
+            Deque<Integer> temp = queue1;
+            queue1 = queue2;
+            queue2 = temp;
+            return i;
+        }
+        
+        public int top() {
+            int i = pop();
+            push(i);
+            return i;
+        }
+        
+        public boolean empty() {
+            return queue1.isEmpty();
+        }
+    }
+
+    public static void main(String[] args) {
+        MyStack stack = new MyStack();
+        stack.push(1);
+        System.out.println(stack.pop());
+        System.out.println(stack.empty());
+    }
+    
+}

src/problems/leetcode/KthSmallestElementInBST.java

@@ -17,45 +17,24 @@ private static class TreeNode {
         }
     }
 
-//    public int kthSmallest(TreeNode root, int k) {
-//        List<Integer> visited = new ArrayList<>();
-//        kthSmallest(root, k, visited);
-//        return visited.get(k - 1);
-//    }
+    private int i;
+    private int value;
 
     public int kthSmallest(TreeNode root, int k) {
-        kthSmallest2(root, k);
-        return found.val;
+        traverse(root, k);
+        return value;
     }
 
-    private void kthSmallest(TreeNode node, int k, List<Integer> visited) {
-        if (node == null) {
+    private void traverse(TreeNode root, int k) {
+        if (root == null) {
             return;
         }
-
-        kthSmallest(node.left, k, visited);
-        visited.add(node.val);
-        if (visited.size() < k) {
-            kthSmallest(node.right, k, visited);
-        }
-    }
-
-    private int count;
-    private TreeNode found;
-
-    private void kthSmallest2(TreeNode node, int k) {
-        if (node == null) {
+        traverse(root.left, k);
+        if (++i == k) {
+            value = root.val;
             return;
         }
-
-        kthSmallest2(node.left, k);
-
-        if (found == null && ++count == k) {
-            found = node;
-            return;
-        }
-
-        kthSmallest2(node.right, k);
+        traverse(root.right, k);
     }
 
 }

src/problems/leetcode/LowestCommonAncestorOfBinaryTree.java

@@ -34,53 +34,55 @@ public static void main(String[] args) {
         root.left.right.left = new TreeNode(7);
         root.left.right.right = new TreeNode(4);
 
-        TreeNode ancestor = new LowestCommonAncestorOfBinaryTree().lowestCommonAncestor(root, new TreeNode(6), new TreeNode(4));
+        TreeNode ancestor = new LowestCommonAncestorOfBinaryTree().lowestCommonAncestor(root, new TreeNode(6),
+                new TreeNode(4));
 
         System.out.println(ancestor.val);
     }
 
-    private List<List<TreeNode>> knownPaths = new ArrayList<>();
-
     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
         if (root == null || root.val == p.val || root.val == q.val) {
             return root;
         }
 
-        lowestCommonAncestor(root, p, q, new ArrayList<>());
-
-        assert knownPaths.size() == 2;
-
-        List<TreeNode> path1 = knownPaths.get(0), path2 = knownPaths.get(1);
-        TreeNode ancestor = path1.get(0);
-        for (int i = 1; i < Math.min(path1.size(), path2.size()); i++) {
-            TreeNode node1 = path1.get(i), node2 = path2.get(i);
-            if (node1 == node2) {
-                ancestor = node1;
-            } else {
-                break;
-            }
+        TreeNode l = lowestCommonAncestor(root.left, p, q);
+        TreeNode r = lowestCommonAncestor(root.right, p, q);
+        if (l == null) {
+            return r;
+        } else if (r == null) {
+            return l;
         }
+        
+        return root;
+    }
 
+    private TreeNode ancestor;
+
+    public TreeNode lowestCommonAncestor2(TreeNode root, TreeNode p, TreeNode q) {
+        traverse(root, p.val, q.val);
         return ancestor;
     }
 
-    private void lowestCommonAncestor(TreeNode node, TreeNode p, TreeNode q, List<TreeNode> path) {
-        if (node == null || knownPaths.size() == 2) {
-            return;
+    private boolean traverse(TreeNode root, int p, int q) {
+        if (root == null) {
+            return false;
         }
 
-        path.add(node);
-
-        if (node.val == p.val) {
-            knownPaths.add(new ArrayList<>(path));
-        } else if (node.val == q.val) {
-            knownPaths.add(new ArrayList<>(path));
+        if (root.val < Math.min(p, q)) {
+            return traverse(root.right, p, q);
+        } else if (root.val > Math.max(p, q)) {
+            return traverse(root.left, p, q);
         }
 
-        lowestCommonAncestor(node.left, p, q, path);
-        lowestCommonAncestor(node.right, p, q, path);
+        boolean foundHere = (root.val == p || root.val == q);
+        boolean foundLeft = traverse(root.left, p, q);
+        boolean foundRight = traverse(root.right, p, q);
+        // System.out.println("val=" + root.val + ", here=" + foundHere + ", left=" +
+        // foundLeft + ", right=" + foundRight);
+        if ((foundHere && (foundLeft || foundRight)) || (foundLeft && foundRight)) {
+            ancestor = root;
+        }
 
-        path.remove(path.size() - 1);
+        return foundHere || foundLeft || foundRight;
     }
-
 }