190820

csf0630p · csf0630p · commit e31f912fd657 · 2019-08-20T21:52:01.000-07:00
diff --git a/213_House Robber II.java b/213_House Robber II.java
@@ -0,0 +1,40 @@
+// 1.0 dp O(n)/O(n)
+class Solution {
+    public int rob(int[] nums) {
+        if (nums.length == 0) return 0;
+        if (nums.length == 1) return nums[0];        
+        return Math.max(helper(nums, 0, nums.length - 1),
+                        helper(nums, 1, nums.length));
+    }
+    
+    private int helper(int[] nums, int p, int q) {
+        int[] f = new int[q];
+        f[p] = nums[p];
+        if (q - p > 1)
+            f[p + 1] = Math.max(nums[p], nums[p + 1]);
+        for (int i = p + 2; i < q; i++) {
+            f[i] = Math.max(f[i-2] + nums[i], f[i-1]);
+        }
+        return f[q - 1];
+    }    
+}
+
+// 1.1 O(n)/O(1)
+class Solution {
+    public int rob(int[] nums) {
+        if (nums.length == 0) return 0;
+        if (nums.length == 1) return nums[0];        
+        return Math.max(helper(nums, 0, nums.length - 1),
+                        helper(nums, 1, nums.length));
+    }
+    
+    private int helper(int[] nums, int p, int q) {
+		int pre2 = 0, pre1 = 0;
+		for (int i = first; i <= last; i++) {
+			int cur = Math.max(pre1, pre2 + nums[i]);
+			pre2 = pre1;
+			pre1 = cur;
+		}
+		return pre1;
+    }    
+}
diff --git a/283_Move Zeroes.java b/283_Move Zeroes.java
@@ -0,0 +1,13 @@
+class Solution {
+    public void moveZeroes(int[] nums) {
+        int count = 0;        
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == 0) {
+                count++;
+            } else {
+                nums[i - count] = nums[i];
+            }
+        }
+        for (int i = nums.length - 1; i >= nums.length - count; i--) nums[i] = 0;
+    }
+}
diff --git a/297_Serialize and Deserialize Binary Tree.java b/297_Serialize and Deserialize Binary Tree.java
@@ -0,0 +1,95 @@
+// 1.0 DFS, pre-order
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Codec {
+    private static final String SPL = ",";
+    private static final String NUL = "X";
+
+    // Encodes a tree to a single string.
+    public String serialize(TreeNode root) {
+        StringBuilder sb = new StringBuilder();
+        buildString(root, sb);
+        return sb.toString();
+    }
+
+    private void buildString(TreeNode node, StringBuilder sb) {
+        if (node == null) {
+            sb.append(NUL).append(SPL);
+        } else {
+            sb.append(node.val).append(SPL);
+            buildString(node.left, sb);
+            buildString(node.right,sb);
+        }
+    }
+    // Decodes your encoded data to tree.
+    public TreeNode deserialize(String data) {
+        Deque<String> nodes = new LinkedList<>();
+        nodes.addAll(Arrays.asList(data.split(SPL)));
+        return buildTree(nodes);
+    }
+    
+    private TreeNode buildTree(Deque<String> nodes) {
+        String val = nodes.remove();
+        if (val.equals(NUL)) return null;
+        else {
+            TreeNode node = new TreeNode(Integer.valueOf(val));
+            node.left = buildTree(nodes);
+            node.right = buildTree(nodes);
+            return node;
+        }
+    }
+}
+
+// Your Codec object will be instantiated and called as such:
+// Codec codec = new Codec();
+// codec.deserialize(codec.serialize(root));
+
+// 2.0 BFS
+public class Codec {
+    public String serialize(TreeNode root) {
+        if (root == null) return "";
+        Queue<TreeNode> q = new LinkedList<>();
+        StringBuilder res = new StringBuilder();
+        q.add(root);
+        while (!q.isEmpty()) {
+            TreeNode node = q.poll();
+            if (node == null) {
+                res.append("n ");
+                continue;
+            }
+            res.append(node.val + " ");
+            q.add(node.left);
+            q.add(node.right);
+        }
+        return res.toString();
+    }
+
+    public TreeNode deserialize(String data) {
+        if (data == "") return null;
+        Queue<TreeNode> q = new LinkedList<>();
+        String[] values = data.split(" ");
+        TreeNode root = new TreeNode(Integer.parseInt(values[0]));
+        q.add(root);
+        for (int i = 1; i < values.length; i++) {
+            TreeNode parent = q.poll();
+            if (!values[i].equals("n")) {
+                TreeNode left = new TreeNode(Integer.parseInt(values[i]));
+                parent.left = left;
+                q.add(left);
+            }
+            if (!values[++i].equals("n")) {
+                TreeNode right = new TreeNode(Integer.parseInt(values[i]));
+                parent.right = right;
+                q.add(right);
+            }
+        }
+        return root;
+    }
+}
diff --git a/303_Range Sum Query - Immutable.java b/303_Range Sum Query - Immutable.java
@@ -0,0 +1,21 @@
+class NumArray {
+    
+    private int[] sums = null;
+
+    public NumArray(int[] nums) {
+        sums = new int[nums.length + 1];
+        for (int i = 1; i <= nums.length; i++) {
+            sums[i] = sums[i - 1] + nums[i - 1];
+        }        
+    }
+    
+    public int sumRange(int i, int j) {
+        return sums[j + 1] - sums[i];        
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * int param_1 = obj.sumRange(i,j);
+ */
diff --git a/343_Integer Break.java b/343_Integer Break.java
@@ -0,0 +1,24 @@
+// 1.0 O(n^2)/O(n), dp
+class Solution {
+    public int integerBreak(int n) {
+        int[] dp = new int[n + 1];
+        dp[1] = 1;
+        for (int i = 2; i <= n; i++) {
+            for (int j = 1; j <= i - 1; j++) {
+                dp[i] = Math.max(dp[i], Math.max(j * dp[i - j], j * (i - j)));
+            }
+        }
+        return dp[n];        
+    }
+}
+
+// 2.0 O(logn)或O(1)/O(logn)或O(1) 取决于幂运算pow
+    public int integerBreak(int n) {
+        if(n <= 3) return n - 1;
+        if(n % 3 == 0) 
+            return (int)Math.pow(3, n / 3);
+        else if(n % 3 == 1) 
+            return 4 * (int)Math.pow(3, (n - 4) / 3);
+        else // (n % 3 == 2)
+            return 2 * (int)Math.pow(3, n / 3);            
+    }
diff --git a/413_Arithmetic Slices.java b/413_Arithmetic Slices.java
@@ -0,0 +1,56 @@
+// 1.0 dp, O(n)/O(n)
+
+class Solution {
+    public int numberOfArithmeticSlices(int[] A) {
+        if (A == null || A.length == 0) {
+            return 0;
+        }
+        int n = A.length;
+        int[] dp = new int[n];
+        for (int i = 2; i < n; i++) {
+            if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
+                dp[i] = dp[i - 1] + 1;
+            }
+        }
+        int total = 0;
+        for (int cnt : dp) {
+            total += cnt;
+        }
+        return total;        
+    }
+}
+
+// 1.1 dp, O(n)/O(1)
+    public int numberOfArithmeticSlices(int[] A) {
+        if (A == null || A.length == 0) {
+            return 0;
+        }
+        int n = A.length, cur = 0, res = 0;
+        for (int i = 2; i < n; i++) {
+            if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
+                cur++;
+                res += cur;
+            } else {
+                cur = 0;
+            }
+        }
+        return res;       
+    }
+
+// 2.0 math, O(n)/O(1)
+    public int numberOfArithmeticSlices(int[] A) {
+        if (A == null || A.length == 0) {
+            return 0;
+        }
+        int res = 0, len = 2, n = A.length;
+        for (int i = 2; i < n; ++i) {
+            if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
+                ++len;
+            } else {
+                if (len > 2) res += (len - 1) * (len - 2) * 0.5;
+                len = 2;
+            }
+        }
+        if (len > 2) res += (len - 1) * (len - 2) * 0.5;
+        return res;   
+    }
