add new codes

Author: tg123

count-univalue-subtrees/README.md

@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+import java.util.Objects; // remove after leetcode support import this by default
+
+public class Solution {
+
+    void patch(Integer[] v, TreeNode parent, TreeNode me){
+        if(me == null){
+            v[1] = parent.val;
+        }
+    }
+
+    // [count, uniq val]
+    Integer[] _countUnivalSubtrees(TreeNode root) {
+
+        if(root == null) return new Integer[]{0, null};
+
+        Integer[] left  = _countUnivalSubtrees(root.left);
+        patch(left, root, root.left);
+
+        Integer[] right = _countUnivalSubtrees(root.right);
+        patch(right, root, root.right);
+
+        if(Objects.equals(left[1], root.val) && Objects.equals(right[1], root.val)){
+            return new Integer[]{left[0] + right[0] + 1, root.val};
+        }
+
+        return new Integer[]{left[0] + right[0], null};
+    }
+
+    public int countUnivalSubtrees(TreeNode root) {
+        return _countUnivalSubtrees(root)[0];
+    }
+}

count-univalue-subtrees/Solution.java

@@ -0,0 +1,7 @@
+---
+layout: solution
+title: Count Univalue Subtrees
+date: 2015-08-06 22:25:20+08:00
+leetcode_id: 250
+---
+{% include_relative README.md %}

count-univalue-subtrees/index.md

@@ -0,0 +1,81 @@
+public class Solution {
+
+    int calc(int l, int r, char op){
+        switch(op){
+            case '+':
+                return l + r;
+            case '-':
+                return l - r;
+            case '*':
+                return l * r;
+        }
+
+        // unreachable
+        throw new RuntimeException();
+    }
+
+    List<Integer> merge(List<Integer>left, List<Integer> right, char op){
+        if(left.isEmpty())  return right;
+        if(right.isEmpty()) return left;
+
+        List<Integer> rt = new ArrayList<>();
+
+        for(int l : left){
+            for(int r : right){
+                rt.add(calc(l, r, op));
+            }
+        }
+
+        return rt;
+    }
+
+    List<Integer> diffWaysToCompute(Integer[] nums, int nst, int ned, Character[] ops){
+
+        List<Integer> rt = new ArrayList<>();
+
+        if(nst + 1 == ned){
+            rt.add(nums[nst]);
+            return rt;
+        }
+
+        for(int i = nst; i < ned - 1; i++){
+            char op = ops[i];
+            List<Integer> left  = diffWaysToCompute(nums, nst, i + 1, ops);
+            List<Integer> right = diffWaysToCompute(nums, i + 1, ned, ops);
+
+            rt.addAll(merge(left, right, op));
+        }
+
+        return rt;
+    }
+
+    public List<Integer> diffWaysToCompute(String input) {
+        Scanner scanner = new Scanner(input);
+        scanner.useDelimiter("");
+
+        List<Integer> nums = new ArrayList<>();
+        List<Character> ops = new ArrayList<>();
+
+        while(scanner.hasNext()){
+            boolean num = false;
+            int buf = 0;
+            while (scanner.hasNextInt()){
+                num = true;
+                buf = buf * 10 + scanner.nextInt();
+            }
+
+            if(num){
+                nums.add(buf);
+                continue;
+            }
+
+            Character op = scanner.next().charAt(0);
+            ops.add(op);
+        }
+
+        Integer[]   _nums = nums.toArray(new Integer[0]);
+        Character[] _ops  = ops.toArray(new Character[0]);
+
+        return diffWaysToCompute(_nums, 0, _nums.length, _ops);
+    }
+}

different-ways-to-add-parentheses/README.md

@@ -0,0 +1,7 @@
+---
+layout: solution
+title: Different Ways to Add Parentheses
+date: 2015-08-06 22:21:28+08:00
+leetcode_id: 241
+---
+{% include_relative README.md %}

different-ways-to-add-parentheses/Solution.java

@@ -0,0 +1,33 @@
+public class Vector2D {
+
+    Iterator<List<Integer>> outterIter;
+    Iterator<Integer> innerIter = Collections.emptyIterator();
+
+    public Vector2D(List<List<Integer>> vec2d) {
+        outterIter = vec2d.iterator();
+    }
+
+    public int next() {
+        return innerIter.next();
+    }
+
+    public boolean hasNext() {
+        if(innerIter.hasNext()){
+            return true;
+        }
+
+        if(!outterIter.hasNext()){
+            return false;
+        }
+
+        innerIter = outterIter.next().iterator();
+
+        return hasNext();
+    }
+}
+
+/**
+ * Your Vector2D object will be instantiated and called as such:
+ * Vector2D i = new Vector2D(vec2d);
+ * while (i.hasNext()) v[f()] = i.next();
+ */

different-ways-to-add-parentheses/index.md

@@ -0,0 +1 @@
+Solution.java

flatten-2d-vector/README.md

@@ -0,0 +1,7 @@
+---
+layout: solution
+title: Flatten 2D Vector
+date: 2015-08-06 22:27:26+08:00
+leetcode_id: 251
+---
+{% include_relative README.md %}