update

Author: OneCodeMonkey

leetcode_solved/[editing]leetcode_0289_Game_of_Life.cpp

@@ -0,0 +1,52 @@
+// AC: Runtime: 1 ms, faster than 23.27% of Java online submissions for Game of Life.
+// Memory Usage: 38.9 MB, less than 8.21% of Java online submissions for Game of Life.
+// .
+// T:O(9 * n) ~ O(n), S:O(1)
+//
+class Solution {
+    public void gameOfLife(int[][] board) {
+        int row = board.length, col = board[0].length;
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                int countOne = 0;
+                for (int t = Math.max(0, i - 1); t <= Math.min(row - 1, i + 1); t++) {
+                    for (int k = Math.max(0, j - 1); k <= Math.min(col - 1, j + 1); k++) {
+                        if (t == i && k == j) {
+                            continue;
+                        }
+                        if (board[t][k] == 1 || board[t][k] == -1) {
+                            countOne++;
+                        }
+                    }
+                }
+                if (board[i][j] == 1) {
+                    if (countOne < 2) {
+                        // live cell will dead
+                        board[i][j] = -1;
+                    } else if (countOne == 2 || countOne == 3) {
+                        // live
+                    } else {
+                        // over-population, die
+                        board[i][j] = -1;
+                    }
+                } else {
+                    if (countOne == 3) {
+                        // dead cell will birth
+                        board[i][j] = -2;
+                    }
+                }
+            }
+        }
+
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (board[i][j] == -1) {
+                    board[i][j] = 0;
+                }
+                if (board[i][j] == -2) {
+                    board[i][j] = 1;
+                }
+            }
+        }
+    }
+}

leetcode_solved/[editing]leetcode_0337_House_Robber_III.cpp

@@ -0,0 +1,38 @@
+// AC: Runtime: 2 ms, faster than 41.52% of Java online submissions for House Robber III.
+// Memory Usage: 39 MB, less than 19.68% of Java online submissions for House Robber III.
+// recursive. if rob root, then rob root's left and right subtree's childs. if not rob root, then rob root's left and right subtrees.
+// T:O(n), S:O(n)
+// 
+class Solution {
+    private HashMap<TreeNode, Integer> record;
+    public int rob(TreeNode root) {
+        record = new HashMap<>();
+        return solve(root);
+    }
+
+    private int solve(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        if (root.left == null && root.right == null) {
+            return root.val;
+        }
+        if (record.containsKey(root)) {
+            return record.get(root);
+        }
+        int val1 = root.val;
+        if (root.left != null) {
+            val1 += solve(root.left.left) + solve(root.left.right);
+        }
+        if (root.right != null) {
+            val1 += solve(root.right.left) + solve(root.right.right);
+        }
+
+        int val2 = solve(root.left) + solve(root.right);
+
+        int ret = Math.max(val1, val2);
+        record.put(root, ret);
+
+        return ret;
+    }
+}

leetcode_solved/[editing]leetcode_1017_Convert_to_Base_-2.cpp

@@ -0,0 +1,19 @@
+// AC: Runtime: 1 ms, faster than 63.70% of Java online submissions for Convert to Base -2.
+// Memory Usage: 38.5 MB, less than 6.67% of Java online submissions for Convert to Base -2.
+// some tricks to use bit manipulation
+// T:O(logn), S:O(logn)
+//
+class Solution {
+    public String baseNeg2(int n) {
+        if (n == 0) {
+            return "0";
+        }
+        StringBuilder ret = new StringBuilder();
+        while (n != 0) {
+            ret.append(n & 1);
+            n = -(n >> 1);
+        }
+
+        return ret.reverse().toString();
+    }
+}

leetcode_solved/[editing]leetcode_1041_Robot_Bounded_In_Circle.cpp

@@ -0,0 +1,41 @@
+// AC: Runtime: 16 ms, faster than 5.52% of Java online submissions for Robot Bounded In Circle.
+// Memory Usage: 40.5 MB, less than 5.04% of Java online submissions for Robot Bounded In Circle.
+// using at most 4-loop to check instructions can make how many moves. using two loop to check whether it forms a circle.
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public boolean isRobotBounded(String instructions) {
+        HashSet<String> record = new HashSet<>();
+        int curX = 0, curY = 0, dir = 0;
+        record.add(curX + "#" + curY);
+        int[] count = new int[2];
+        for (int loop = 0; loop < 2; loop++) {
+            for (int i = 0; i < 4; i++) {
+                for (char c : instructions.toCharArray()) {
+                    if (c == 'G') {
+                        if (dir == 0) {
+                            curY++;
+                        } else if (dir == 1) {
+                            curX++;
+                        } else if (dir == 2) {
+                            curY--;
+                        } else {
+                            curX--;
+                        }
+
+                        // check loop
+                        String temp = curX + "#" + curY;
+                        record.add(temp);
+                    } else if (c == 'L') {
+                        dir = (dir == 0) ? 3 : dir - 1;
+                    } else {
+                        dir = (dir == 3) ? 0 : dir + 1;
+                    }
+                }
+            }
+            count[loop] = record.size();
+        }
+
+        return count[0] == count[1];
+    }
+}

leetcode_solved/[editing]leetcode_1262_Greatest_Sum_Divisible_by_Three.cpp

@@ -0,0 +1,53 @@
+// AC: Runtime: 10 ms, faster than 45.69% of Java online submissions for Greatest Sum Divisible by Three.
+// Memory Usage: 44.7 MB, less than 47.20% of Java online submissions for Greatest Sum Divisible by Three.
+// .
+// T:O(nlogn), S:O(logn)
+//
+class Solution {
+    public int maxSumDivThree(int[] nums) {
+        Arrays.sort(nums);
+        int sum = 0, firstModOne = -1, firstModTwo = -1, secondModOne = -1, secondModTwo = -1;
+        for (int i : nums) {
+            sum += i;
+        }
+        if (sum % 3 == 1) {
+            for (int num : nums) {
+                if (num % 3 == 1) {
+                    if (firstModTwo != -1 && secondModTwo != -1) {
+                        return sum - Math.min(num, firstModTwo + secondModTwo);
+                    } else {
+                        return sum - num;
+                    }
+                } else if (num % 3 == 2) {
+                    if (firstModTwo == -1) {
+                        firstModTwo = num;
+                    } else if (secondModTwo == -1) {
+                        secondModTwo = num;
+                    }
+                }
+            }
+
+            return (firstModTwo != -1 && secondModTwo != -1) ? sum - firstModTwo - secondModTwo : 0;
+        } else if (sum % 3 == 2) {
+            for (int num : nums) {
+                if (num % 3 == 1) {
+                    if (firstModOne == -1) {
+                        firstModOne = num;
+                    } else if (secondModOne == -1) {
+                        secondModOne = num;
+                    }
+                } else if (num % 3 == 2) {
+                    if (firstModOne != -1 && secondModOne != -1) {
+                        return sum - Math.min(num, firstModOne + secondModOne);
+                    } else {
+                        return sum - num;
+                    }
+                }
+            }
+
+            return (firstModOne != -1 && secondModOne != -1) ? sum - firstModOne - secondModOne : 0;
+        } else {
+            return sum;
+        }
+    }
+}

leetcode_solved/leetcode_0289_Game_of_Life.java

@@ -0,0 +1,16 @@
+// AC: Runtime: 3 ms, faster than 100.00% of Java online submissions for Minimum Difference Between Highest and Lowest of K Scores.
+// Memory Usage: 38.8 MB, less than 100.00% of Java online submissions for Minimum Difference Between Highest and Lowest of K Scores.
+// sort and compare nums[i + k - 1] - nums[i].
+// T:O(nlogn), S:O(logn)
+//
+class Solution {
+    public int minimumDifference(int[] nums, int k) {
+        int size = nums.length, ret = Integer.MAX_VALUE;
+        Arrays.sort(nums);
+        for (int i = 0; i < size - k + 1; i++) {
+            ret = Math.min(ret, nums[i + k - 1] - nums[i]);
+        }
+
+        return ret;
+    }
+}

leetcode_solved/leetcode_0337_House_Robber_III.java

@@ -0,0 +1,44 @@
+// AC: Runtime: 20 ms, faster than 75.00% of Java online submissions for Find the Kth Largest Integer in the Array.
+// Memory Usage: 47.5 MB, less than 50.00% of Java online submissions for Find the Kth Largest Integer in the Array.
+// treemap
+// T:O(nlogn), S:O(n)
+//
+class Solution {
+    public String kthLargestNumber(String[] nums, int k) {
+        TreeMap<Integer, List<String>> record = new TreeMap<>(new Comparator<Integer>() {
+            @Override
+            public int compare(Integer o1, Integer o2) {
+                return o2 - o1;
+            }
+        });
+        for (String str: nums) {
+            int len = str.length();
+            if (record.containsKey(len)) {
+                record.get(len).add(str);
+            } else {
+                List<String> tempList = new ArrayList<>();
+                tempList.add(str);
+                record.put(len, tempList);
+            }
+        }
+
+        int count = 0;
+        for (int len: record.keySet()) {
+            int lenCount = record.get(len).size();
+            if (count + lenCount >= k) {
+                // return list
+                record.get(len).sort(new Comparator<String>() {
+                    @Override
+                    public int compare(String o1, String o2) {
+                        return o2.compareTo(o1);
+                    }
+                });
+                return record.get(len).get(k - count - 1);
+            } else {
+                count += lenCount;
+            }
+        }
+
+        return nums[0];
+    }
+}