Different Ways to Add Parentheses

Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are +,- and *.

Example 1

Input: "2-1-1".

((2-1)-1) = 0
(2-(1-1)) = 2

Output: [0, 2]

Example 2

Input: "2*3-4*5"

(2*(3-(4*5))) = -34
((2*3)-(4*5)) = -14
((2*(3-4))*5) = -10
(2*((3-4)*5)) = -10
(((2*3)-4)*5) = 10

Output: [-34, -14, -10, -10, 10]

Credits:
Special thanks to @mithmatt for adding this problem and creating all test cases.

Show Tags

Show Similar Problems

Have you met this question in a real interview?

思路：Recursion , every time meet an operator, we need to get the left and right. Then calculate the whole permutation of left and right. DP is only using a HashMap the result. similiar to Unique Binary Search Trees II 

public class Solution {
    public List<Integer> diffWaysToCompute(String input) {
        // List<Integer> ret = new ArrayList<Integer>();
        // int len = input.length();
        // for(int i = 0; i < len; i++){
        //     char curChar = input.charAt(i);
        //     if(curChar == '+' || curChar == '-' || curChar == '*'){
        //         List<Integer> left = diffWaysToCompute(input.substring(0, i));
        //         List<Integer> right = diffWaysToCompute(input.substring(i + 1, len));
        //         for(int leftNum : left){
        //             for(int rightNum : right){
        //                 if(curChar == '+'){
        //                     ret.add(leftNum + rightNum);
        //                 }else if(curChar == '-'){
        //                     ret.add(leftNum - rightNum);
        //                 }else{
        //                     ret.add(leftNum * rightNum);
        //                 }
        //             }
        //         }
        //     }
        // }
        // if(ret.size() < 1)
        //     ret.add(Integer.parseInt(input));
        // return ret;
        HashMap<String, List<Integer>> map = new HashMap<String, List<Integer>>();
        return computeHelper(input, map);
    }
    
    public List<Integer> computeHelper(String input, HashMap<String, List<Integer>> map){
        List<Integer> ret = new ArrayList<Integer>();
        int len = input.length();
        for(int i = 0; i < len; i++){
            char curChar = input.charAt(i);
            if(curChar == '+' || curChar == '-' || curChar == '*'){
                List<Integer> left;
                List<Integer> right;
                if(map.containsKey(input.substring(0, i))){
                    left = map.get(input.substring(0, i));
                }else{
                    left = diffWaysToCompute(input.substring(0, i));
                }
                if(map.containsKey(input.substring(i + 1))){
                    right = map.get(input.substring(i + 1));
                }else{
                    right = diffWaysToCompute(input.substring(i + 1));
                }
                for(int leftNum : left){
                    for(int rightNum : right){
                        if(curChar == '+'){
                            ret.add(leftNum + rightNum);
                        }else if(curChar == '-'){
                            ret.add(leftNum - rightNum);
                        }else{
                            ret.add(leftNum * rightNum);
                        }
                    }
                }
            }
        }
        if(ret.size() < 1)
            ret.add(Integer.parseInt(input));
        return ret;
    }
}