GitBook: [master] 3 pages modified

Author: just4once

SUMMARY.md

@@ -59,6 +59,7 @@
     * [215-kth-largest-element-in-an-array](leetcode/divide-and-conquer/215-kth-largest-element-in-an-array.md)
     * [218-the-skyline-problem](leetcode/divide-and-conquer/218-the-skyline-problem.md)
     * [241-different-ways-to-add-parentheses](leetcode/divide-and-conquer/241-different-ways-to-add-parentheses.md)
+    * [282-expression-add-operators](leetcode/divide-and-conquer/282-expression-add-operators.md)
   * [hash-table](leetcode/hash-table/README.md)
     * [003-longest-substring-without-repeating-characters](leetcode/hash-table/003-longest-substring-without-repeating-characters.md)
     * [030-substring-with-concatenation-of-all-words](leetcode/hash-table/030-substring-with-concatenation-of-all-words.md)

leetcode/divide-and-conquer/241-different-ways-to-add-parentheses.md

@@ -35,7 +35,9 @@ Explanation:
    3. Time complexity O\(3^n\)
    4. Space complexity O\(3^n\)
 2. Divide and Conquer \(Cached\)
-   1. 
+   1. Avoid repetitive calculation
+   2. Time complexity O\(?\)
+   3. Space complexity o\(?\)
 3. asd
 
 ## Solution
@@ -64,5 +66,38 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    
+    public List<Integer> diffWaysToCompute(String input) {
+        // Use cache to avoid repeative calculaiton
+        Map<String, List<Integer>> cache = new HashMap<>();
+        return search(input, cache);
+    }
+    
+    private List<Integer> search(String input, Map<String, List<Integer>> cache) {
+        if (cache.containsKey(input)) return cache.get(input);
+        List<Integer> res = new ArrayList<>();
+        for (int i = 0; i < input.length(); i++) {
+            char c = input.charAt(i);
+            if (c == '+' || c == '-' || c == '*') {
+                List<Integer> left = diffWaysToCompute(input.substring(0, i));
+                List<Integer> right = diffWaysToCompute(input.substring(i + 1, input.length()));
+                for (int n1 : left) {
+                    for (int n2 : right) {
+                        if (c == '+') res.add(n1 + n2);
+                        else if (c == '-') res.add(n1 - n2);
+                        else res.add(n1 * n2);
+                    }
+                }
+            }
+        }
+        if (res.size() == 0) res.add(Integer.parseInt(input));
+        cache.put(input, res);
+        return res;
+    }
+}
+```
+
 ## Additional {#additional}
 

leetcode/divide-and-conquer/282-expression-add-operators.md

@@ -0,0 +1,59 @@
+# 282-expression-add-operators
+
+## Question {#question}
+
+Given a string that contains only digits `0-9` and a target value, return all possibilities to add **binary** operators \(not unary\) `+`, `-`, or `*`between the digits so they evaluate to the target value.
+
+**Example 1:**
+
+```text
+Input: num = "123", target = 6
+Output: ["1+2+3", "1*2*3"] 
+```
+
+**Example 2:**
+
+```text
+Input: num = "232", target = 8
+Output: ["2*3+2", "2+3*2"]
+```
+
+**Example 3:**
+
+```text
+Input: num = "105", target = 5
+Output: ["1*0+5","10-5"]
+```
+
+**Example 4:**
+
+```text
+Input: num = "00", target = 0
+Output: ["0+0", "0-0", "0*0"]
+```
+
+**Example 5:**
+
+```text
+Input: num = "3456237490", target = 9191
+Output: []
+```
+
+
+
+## Thought Process {#thought-process}
+
+1. Divide and Conquer
+   1. Similar to 241, we can divide the number at each position and check if there is way to get target using different operation
+   2. Time complexity O\(?\)
+   3. Space complexity O\(?\)
+2. asd
+
+## Solution
+
+```java
+
+```
+
+## Additional {#additional}
+