gsf 第三周

Author: guoshufeng

Week_03/id_30/LeetCode_104_30.java

@@ -0,0 +1,25 @@
+package com.shufeng.algorithm.d0_;
+
+/**
+ * @author gsf
+ */
+public class LeetCode_104_30 {
+
+    public static void main(String[] args) {
+        TreeNode root = new TreeNode(3);
+        root.left = new TreeNode(9);
+        root.right = new TreeNode(20);
+        root.right.left = new TreeNode(15);
+        root.right.right = new TreeNode(7);
+        int i = maxDepth(root);
+        System.out.println(i);
+    }
+
+    public static int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
+    }
+}
+

Week_03/id_30/LeetCode_429_30.java

@@ -0,0 +1,48 @@
+package com.shufeng.algorithm.d0_;
+
+/**
+ * @author gsf
+ */
+public class LeetCode_429_30 {
+
+    public static void main(String[] args) {
+
+        Node root = new Node(1, Arrays.asList(
+                new Node(3, Arrays.asList(
+                        new Node(5, null),
+                        new Node(6, null))),
+                new Node(2, null),
+                new Node(4, null)
+        ));
+        List<List<Integer>> lists = levelOrder(root);
+        System.out.println(lists);
+    }
+
+    public static List<List<Integer>> levelOrder(Node root) {
+        List<List<Integer>> lists = new ArrayList<>();
+        lists.add(new ArrayList<>());
+        if (root == null) {
+            return lists;
+        }
+
+        int num = 0;
+        lists.get(num).add(root.val);
+        levelOrder(root.children, lists, num + 1);
+        return lists;
+    }
+
+    public static void levelOrder(List<Node> children, List<List<Integer>> lists, int num) {
+        if (children == null) {
+            return;
+        }
+        for (int i = 0; i < children.size(); i++) {
+            Node node = children.get(i);
+            if (lists.size() < num + 1) {
+                lists.add(new ArrayList<>());
+            }
+            lists.get(num).add(node.val);
+            levelOrder(node.children, lists, num + 1);
+        }
+    }
+}
+

Week_03/id_30/LeetCode_703_30.java

@@ -0,0 +1,53 @@
+package com.shufeng.algorithm.d0_;
+
+/**
+ * @author gsf
+ */
+public class LeetCode_703_30 {
+
+    public static void main(String[] args) {
+
+        int k = 3;
+        int[] arr = {4, 5, 8, 2};
+        D703 kthLargest = new D703(k, arr);
+        System.out.println(kthLargest.add(3));   // returns 4
+        System.out.println(kthLargest.add(5));   // returns 5
+        System.out.println(kthLargest.add(10));  // returns 5
+        System.out.println(kthLargest.add(9));   // returns 8
+        System.out.println(kthLargest.add(4));   // returns 8
+
+    }
+
+    PriorityQueue<Integer> queue = new PriorityQueue<>();
+    int num = 0;
+
+    public D703(int k, int[] nums) {
+        num = k;
+        for (int i = 0; i < nums.length; i++) {
+            if (queue.size() == k) {
+                Integer peek = queue.peek();
+                if (peek < nums[i]) {
+                    queue.poll();
+                    queue.add(nums[i]);
+                }
+            } else {
+                queue.add(nums[i]);
+            }
+        }
+    }
+
+    public int add(int val) {
+        if (queue.size() == num) {
+            Integer peek = queue.peek();
+            if (peek < val) {
+                queue.poll();
+                queue.add(val);
+                return queue.peek();
+            }
+        } else {
+            queue.add(val);
+        }
+        return queue.peek();
+    }
+}
+

Week_03/id_30/LeetCode_997_30.java

@@ -0,0 +1,43 @@
+package com.shufeng.algorithm.d0_;
+
+/**
+ * @author gsf
+ */
+public class LeetCode_997_30 {
+
+    public static void main(String[] args) {
+        int[][] trust = new int[2][2];
+        int[] a = {1, 3};
+        int[] a1 = {2, 3};
+
+        trust[0] = a;
+        trust[1] = a1;
+
+
+        int judge = findJudge(1, trust);
+        System.out.println(judge);
+    }
+
+    public static int findJudge(int N, int[][] trust) {
+        int[] arr = new int[N + 1];
+        Set<Integer> set = new HashSet<>();
+        for (int i = 0; i < trust.length; i++) {
+            if (trust[i].length > 0) {
+                arr[trust[i][1]]++;
+                set.add(trust[i][0]);
+            }
+        }
+
+        if (set.size() != N - 1) {
+            System.out.println(set.size());
+            return -1;
+        }
+        for (int i = 1; i < arr.length; i++) {
+            if (arr[i] == N - 1) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
+