g0201_0300.s0241_different_ways_to_add_parentheses.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g0201_0300.s0241_different_ways_to_add_parentheses;

// #Medium #String #Dynamic_Programming #Math #Recursion #Memoization
// #2022_07_05_Time_3_ms_(70.81%)_Space_42.5_MB_(73.65%)

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 241 - Different Ways to Add Parentheses\.
 *
 * Medium
 *
 * Given a string `expression` of numbers and operators, return _all possible results from computing all the different possible ways to group numbers and operators_. You may return the answer in **any order**.
 *
 * **Example 1:**
 *
 * **Input:** expression = "2-1-1"
 *
 * **Output:** [0,2]
 *
 * **Explanation:** ((2-1)-1) = 0 (2-(1-1)) = 2 
 *
 * **Example 2:**
 *
 * **Input:** expression = "2\*3-4\*5"
 *
 * **Output:** [-34,-14,-10,-10,10]
 *
 * **Explanation:**
 *
 *     (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 
 *
 * **Constraints:**
 *
 * *   `1 <= expression.length <= 20`
 * *   `expression` consists of digits and the operator `'+'`, `'-'`, and `'*'`.
 * *   All the integer values in the input expression are in the range `[0, 99]`.
**/
public class Solution {
    public List diffWaysToCompute(String expression) {
        return diffWaysToCompute(expression, new HashMap<>());
    }

    private List diffWaysToCompute(String expression, Map> map) {
        if (map.containsKey(expression)) {
            return map.get(expression);
        }
        List values = new ArrayList<>();
        if (!hasOperator(expression)) {
            // base case
            values.add(Integer.parseInt(expression));
        } else {
            // Recursive case. DFS
            for (int i = 0; i < expression.length(); i++) {
                char symbol = expression.charAt(i);

                if (!Character.isDigit(symbol)) {
                    List left = diffWaysToCompute(expression.substring(0, i), map);
                    List right = diffWaysToCompute(expression.substring(i + 1), map);
                    for (Integer l : left) {
                        for (Integer r : right) {
                            switch (symbol) {
                                case '+':
                                    values.add(l + r);
                                    break;
                                case '-':
                                    values.add(l - r);
                                    break;
                                case '*':
                                    values.add(l * r);
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                }
            }
        }
        map.put(expression, values);
        return values;
    }

    private boolean hasOperator(String expression) {
        for (int i = 0; i < expression.length(); i++) {
            switch (expression.charAt(i)) {
                case '+':
                case '-':
                case '*':
                    return true;
                default:
                    break;
            }
        }
        return false;
    }
}