LeetCode 241. Design priorities for operational expressions

241. Design priorities for operation expressions

 

【 Divide and conquer 】 Divide left and right according to operation symbols , After recursively processing the left and right sides, the possible results on the left and right sides are combined .

class Solution {

    //  Divide and conquer  9:30 10:34

    List<String> list = new ArrayList();

    List<Integer> diff(int start, int end) {
        if (start == end) {
            String str = list.get(start);
            return new ArrayList<Integer>() {
   { add(Integer.parseInt(str)); }};
        } 
        List<Integer> ans = new ArrayList();
        for (var i = start; i <= end; i++) {
            String str = list.get(i);
            if (str.equals("+") || str.equals("-") || str.equals("*")) {
                List<Integer> left = diff(start, i - 1);
                List<Integer> right = diff(i + 1, end);
                for (var x: left) {
                    for (var y: right) {
                        if (str.equals("+")) {
                            ans.add(x + y);
                        } else if(str.equals("-")) {
                            ans.add(x - y);
                        } else if (str.equals("*")) {
                            ans.add(x * y);
                        }
                    }
                }
            }
        }
        return ans;
    }

    public List<Integer> diffWaysToCompute(String expression) {
        String num = "";
        for (var i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (c >= '0' && c <= '9') {
                num += c;
            } else {
                list.add(num);
                num = "";
                list.add("" + c);
            }
        }
        list.add(num);
        return diff(0, list.size() - 1);
    }
}

【 Optimize 】 Optimize string processing , use StringBuilder Splicing

class Solution {

    //  Divide and conquer  9:30 10:34

    List<String> list = new ArrayList();
    Map<Integer, List<Integer>> map = new HashMap();

    List<Integer> diff(int start, int end) {
        int key = start * 100 + end;
        if (map.containsKey(key)) {
            // System.out.println("en");
            return map.get(key);
        }
        if (start == end) {
            String str = list.get(start);
            List<Integer> ret = new ArrayList();
            ret.add(Integer.parseInt(str));
            map.put(key, ret);
            return ret;
        } 
        List<Integer> ans = new ArrayList();
        for (var i = start; i <= end; i++) {
            String str = list.get(i);
            if (str.equals("+") || str.equals("-") || str.equals("*")) {
                List<Integer> left = diff(start, i - 1);
                List<Integer> right = diff(i + 1, end);
                for (var x: left) {
                    for (var y: right) {
                        if (str.equals("+")) {
                            ans.add(x + y);
                        } else if(str.equals("-")) {
                            ans.add(x - y);
                        } else if (str.equals("*")) {
                            ans.add(x * y);
                        }
                    }
                }
            }
        }
        map.put(key, ans);
        return ans;
    }

    public List<Integer> diffWaysToCompute(String expression) {
        StringBuilder sb = new StringBuilder();
        for (var i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (c >= '0' && c <= '9') {
                sb.append(c);
            } else {
                list.add(sb.toString());
                sb = new StringBuilder();
                list.add(String.valueOf(c));
            }
        }
        list.add(sb.toString());
        return diff(0, list.size() - 1);
    }
}