update

Author: OneCodeMonkey

contest/leetcode_biweek_60/leetcode_1991_find_the_middle_index_in_array.java

@@ -0,0 +1,22 @@
+// AC: Runtime: 0 ms, faster than 100.00% of Java online submissions for Find the Middle Index in Array.
+// Memory Usage: 38.2 MB, less than 91.66% of Java online submissions for Find the Middle Index in Array.
+// .
+// T:O(n), S:O(1)
+//
+class Solution {
+    public int findMiddleIndex(int[] nums) {
+        int size = nums.length, sum = 0, tempSum = 0;
+        for (int i: nums) {
+            sum += i;
+        }
+        for (int i = 0; i < size; i++) {
+            tempSum += nums[i];
+            int leftSum = tempSum - nums[i], rightSum = sum - tempSum;
+            if (leftSum == rightSum) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+}

contest/leetcode_biweek_60/leetcode_1993_Operations_on_Tree.java

@@ -0,0 +1,92 @@
+// AC: Runtime: 287 ms, faster than 32.35% of Java online submissions for Operations on Tree.
+// Memory Usage: 47.5 MB, less than 68.04% of Java online submissions for Operations on Tree.
+// .
+// T: lock:O(n), upgrade:O(n^2)
+//
+class LockingTree {
+    public HashMap<Integer, Integer> relation;
+    public HashMap<Integer, List<Integer>> parentToChildRelation;
+    public HashMap<Integer, Integer> lockUserRecord;
+
+    public LockingTree(int[] parent) {
+        int size = parent.length;
+        relation = new HashMap<>();
+        parentToChildRelation = new HashMap<>();
+        lockUserRecord = new HashMap<>();
+        for (int i = 0; i < size; i++) {
+            relation.put(i, parent[i]);
+            if (parentToChildRelation.containsKey(parent[i])) {
+                parentToChildRelation.get(parent[i]).add(i);
+            } else {
+                List<Integer> tempList = new LinkedList<>();
+                tempList.add(i);
+                parentToChildRelation.put(parent[i], tempList);
+            }
+        }
+    }
+
+    public boolean lock(int num, int user) {
+        if (lockUserRecord.containsKey(num)) {
+            return false;
+        } else {
+            lockUserRecord.put(num, user);
+            return true;
+        }
+    }
+
+    public boolean unlock(int num, int user) {
+        if (lockUserRecord.containsKey(num) && lockUserRecord.get(num) == user) {
+            lockUserRecord.remove(num);
+            return true;
+        }
+
+        return false;
+    }
+
+    public boolean upgrade(int num, int user) {
+        if (!lockUserRecord.containsKey(num)) {
+            // ancester has no lock.
+            boolean ancestorHasLock = false;
+            int pos = num;
+            while (relation.get(pos) != -1) {
+                int parent = relation.get(pos);
+                if (lockUserRecord.containsKey(parent)) {
+                    ancestorHasLock = true;
+                    break;
+                }
+                pos = parent;
+            }
+            if (ancestorHasLock) {
+                return false;
+            }
+
+            // check child has lock
+            // leaf node
+            if (!parentToChildRelation.containsKey(num)) {
+                return false;
+            }
+            boolean childHasLock = false;
+            List<Integer> searchChild = new LinkedList<>(parentToChildRelation.get(num));
+            while (!searchChild.isEmpty()) {
+                List<Integer> newSearchList = new LinkedList<>();
+                for (int i: searchChild) {
+                    if (lockUserRecord.containsKey(i)) {
+                        childHasLock = true;
+                        lockUserRecord.remove(i);
+                    }
+
+                    newSearchList.addAll(parentToChildRelation.getOrDefault(i, new LinkedList<>()));
+                }
+                searchChild = newSearchList;
+            }
+            if (!childHasLock) {
+                return false;
+            }
+            lockUserRecord.put(num, user);
+
+            return true;
+        }
+
+        return false;
+    }
+}

leetcode_solved/[editing]leetcode_0092_Reverse_Linked_List_II.cpp

@@ -0,0 +1,44 @@
+// AC: Runtime: 0 ms, faster than 100.00% of Java online submissions for Reverse Linked List II.
+// Memory Usage: 36.5 MB, less than 82.11% of Java online submissions for Reverse Linked List II.
+// find the start position and end position of range to be reversed. and record the range values. then assign it to list nodes in reverse order.
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public ListNode reverseBetween(ListNode head, int left, int right) {
+        if (head == null || left == right) {
+            return head;
+        }
+
+        ListNode fast = head, slow = head;
+        int length = right - left;
+        while (length-- > 0) {
+            fast = fast.next;
+        }
+
+        // find the start position and end position.
+        int leftCopy = left - 1;
+        while (leftCopy-- > 0) {
+            slow = slow.next;
+            fast = fast.next;
+        }
+
+        // record the range values.
+        ListNode temp = slow;
+        List<Integer> record = new ArrayList<>();
+        record.add(slow.val);
+        while (temp != fast) {
+            temp = temp.next;
+            record.add(temp.val);
+        }
+
+        // assign values in reverse order.
+        int pos = record.size() - 1;
+        slow.val = record.get(pos--);
+        while (slow != fast) {
+            slow = slow.next;
+            slow.val = record.get(pos--);
+        }
+
+        return head;
+    }
+}

leetcode_solved/[editing]leetcode_0096_Unique_Binary_Search_Trees.cpp

@@ -0,0 +1,18 @@
+// AC: Runtime: 0 ms, faster than 100.00% of Java online submissions for Unique Binary Search Trees.
+// Memory Usage: 37.5 MB, less than 18.78% of Java online submissions for Unique Binary Search Trees.
+// DP.
+// T:O(n ^ 2), S:O(n)
+// 
+class Solution {
+    public int numTrees(int n) {
+        int[] dp = new int[n + 1];
+        dp[0] = 1;
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= i; j++) {
+                dp[i] += dp[j - 1] * dp[i - j];
+            }
+        }
+
+        return dp[n];
+    }
+}

leetcode_solved/[editing]leetcode_0139_Word_Break.cpp

@@ -0,0 +1,23 @@
+// AC: Runtime: 10 ms, faster than 25.12% of Java online submissions for Word Break.
+// Memory Usage: 44.1 MB, less than 7.54% of Java online submissions for Word Break.
+// DP.
+// T:O(n ^ 2), S:O(n)
+//
+class Solution {
+    public boolean wordBreak(String s, List<String> wordDict) {
+        int size = s.length();
+        boolean[] dp = new boolean[size + 1];
+        HashSet<String> record = new HashSet<>(wordDict);
+        dp[0] = true;
+        for (int i = 0; i < size; i++) {
+            for (int j = 0; j <= i; j++) {
+                if (dp[j] && record.contains(s.substring(j, i + 1))) {
+                    dp[i + 1] = true;
+                    break;
+                }
+            }
+        }
+
+        return dp[size];
+    }
+}

leetcode_solved/[editing]leetcode_0207_Course_Schedule.cpp

@@ -0,0 +1,49 @@
+// dfs + topo sorting
+// AC: Runtime: 28 ms, faster than 8.34% of Java online submissions for Course Schedule.
+// Memory Usage: 45 MB, less than 16.13% of Java online submissions for Course Schedule.
+// 确定有向图中无环即为 true，否则为 false，课程成环相互依赖无法全部修完
+// T:O(m + n), O(m + n), m 为点数，n 为边数
+// 
+class Solution {
+    List<List<Integer>> edges;
+    int[] visited;
+    boolean flag = true;
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        edges = new LinkedList<>();
+        visited = new int[numCourses];
+        for (int i = 0; i < numCourses; i++) {
+            edges.add(new LinkedList<>());
+        }
+        for (int[] arr: prerequisites) {
+            edges.get(arr[1]).add(arr[0]);
+        }
+
+        for (int i = 0; i < numCourses && flag; i++) {
+            if (visited[i] == 0) {
+                dfs(i);
+                if (!flag) {
+                    return flag;
+                }
+            }
+        }
+
+        return flag;
+    }
+
+    private void dfs(int i) {
+        visited[i] = 1;
+        for (int v: edges.get(i)) {
+            if (visited[v] == 0) {
+                dfs(v);
+                if (!flag) {
+                    return;
+                }
+            } else if (visited[v] == 1) {   // 形成环
+                flag = false;
+                return;
+            }
+        }
+
+        visited[i] = 2;
+    }
+}

leetcode_solved/[editing]leetcode_0208_Implement_Trie_(Prefix_Tree).cpp

@@ -0,0 +1,70 @@
+// AC: Runtime: 28 ms, faster than 99.62% of Java online submissions for Implement Trie (Prefix Tree).
+// Memory Usage: 48.3 MB, less than 77.69% of Java online submissions for Implement Trie (Prefix Tree).
+// understand the definition of trie tree. using a isWord boolean and children[26] to record its existence of a word prefix, 
+// and to enrich feature, we can add wordCount to record the number words.
+// T: insert: O(n), search: O(n), startsWith: O(n), S:O(m * n),  n is the length of string, m is the number of strings.
+//  
+class TrieNode {
+    boolean isWord;
+    TrieNode[] children;
+
+    public TrieNode() {
+        isWord = false;
+        children = new TrieNode[26];
+    }
+}
+
+class Trie {
+    private TrieNode root;
+
+    /** Initialize your data structure here. */
+    public Trie() {
+        root = new TrieNode();
+    }
+
+    /** Inserts a word into the trie. */
+    public void insert(String word) {
+        TrieNode parent = root;
+        for (int i = 0; i < word.length(); i++) {
+            int charI = word.charAt(i) - 'a';
+            if (parent.children[charI] == null) {
+                parent.children[charI] = new TrieNode();
+            }
+            parent = parent.children[charI];
+        }
+        parent.isWord = true;
+    }
+
+    /** Returns if the word is in the trie. */
+    public boolean search(String word) {
+        TrieNode target = find(word);
+        return target != null && target.isWord;
+    }
+
+    public TrieNode find(String word) {
+        TrieNode parent = root;
+        for (int i = 0; i < word.length(); i++) {
+            int charI = word.charAt(i) - 'a';
+            if (parent.children[charI] == null) {
+                return null;
+            }
+            parent = parent.children[charI];
+        }
+
+        return parent;
+    }
+
+    /** Returns if there is any word in the trie that starts with the given prefix. */
+    public boolean startsWith(String prefix) {
+        TrieNode parent = root;
+        for (int i = 0; i < prefix.length(); i++) {
+            int charI = prefix.charAt(i) - 'a';
+            if (parent.children[charI] == null) {
+                return false;
+            }
+            parent = parent.children[charI];
+        }
+
+        return true;
+    }
+}