241 为运算表达式设计优先级（记忆化递归）

1. 问题描述：

给定一个含有数字和运算符的字符串，为表达式添加括号，改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, - 以及 * 。

示例 1:

输入: "2-1-1"
输出: [0, 2]
解释: 
((2-1)-1) = 0 
(2-(1-1)) = 2
示例 2:

输入: "2*3-4*5"
输出: [-34, -14, -10, -10, 10]
解释: 
(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

2. 思路分析：

① 其实题目还是很好理解的，根据题目给出的对于表达式中的解析可以知道我们可以将输入的字符串进行分解，第一种分解可以为2与3-4*5的可能情况的乘法运算，第二种的分解可以为2*3与4*5可能情况的减法运算，第三种分解可以为2*3-4与5的乘法运算，对于第一种分解又可以将其分为3与4*5的可能情况的乘法运算，第二种分解还有第三种分解也是类似的，可以知道通过分解之后问题规模在逐步缩小，而且每一次分解的方法都是一样的，这个正是可以使用递归求解的特点

② 通过上面的分析可以知道可以使用递归求解，因为是需要将字符串进行分解那么需要使用一个for循环来截取对应的字符串，对于截取的字符串与剩余的字符串进行递归求解，结果返回一个List<Integer>类型的结果，对于两部分返回的结果进行遍历求解对应的结果

具体的代码如下（来自于LeetCode的题解）：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        System.out.println(s);
        System.out.println(diffWaysToCompute(s));
    }

    public static List<Integer> diffWaysToCompute(String input) {
        if (input.length() == 0) {
            return new ArrayList<>();
        }
        List<Integer> result = new ArrayList<>();
        int num = 0;
        //考虑是全数字的情况
        int index = 0;
        while (index < input.length() && !isOperation(input.charAt(index))) {
            num = num * 10 + input.charAt(index) - '0';
            index++;
        }
        //将全数字的情况直接返回
        if (index == input.length()) {
            result.add(num);
            return result;
        }

        for (int i = 0; i < input.length(); i++) {
            //通过运算符将字符串分成两部分
            if (isOperation(input.charAt(i))) {
                List<Integer> result1 = diffWaysToCompute(input.substring(0, i));
                List<Integer> result2 = diffWaysToCompute(input.substring(i + 1));
                //将两个结果依次运算
                for (int j = 0; j < result1.size(); j++) {
                    for (int k = 0; k < result2.size(); k++) {
                        char op = input.charAt(i);
                        result.add(caculate(result1.get(j), op, result2.get(k)));
                    }
                }
            }
        }
        return result;
    }

    private static int caculate(int num1, char c, int num2) {
        switch (c) {
            case '+':
                return num1 + num2;
            case '-':
                return num1 - num2;
            case '*':
                return num1 * num2;
        }
        return -1;
    }

    private static boolean isOperation(char c) {
        return c == '+' || c == '-' || c == '*';
    }
}

③ 因为两个分支进行递归，所以存在子问题的重复求解，多分支的递归可以画出其中的递归树来理解，可以发现存在很多重复求解的过程，怎么样避免这种情况呢？我们可以使用一个数据结构来进行记录看一下之前是否求解过，假如求解过的话那么可以直接返回之前的求解结果，常用的是使用一个HashMap来进行记录，将求解的中间结果放入到这个map中每一次递归求解的过程先判断再往下进行求解，可以大大减少时间复杂度，使用数据结构来记录一般是看方法中存在着什么参数，而且这些参数是动态变化的，一般来说这些动态变化的参数就可以作为记录的前提，适当使用数组或者是Map等的数据结构来记录，代码如下：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        System.out.println(s);
        System.out.println(diffWaysToCompute(s));
    }

    //添加一个 map
    static HashMap<String,List<Integer>> map = new HashMap<>();
    public static List<Integer> diffWaysToCompute(String input) {
        if (input.length() == 0) {
            return new ArrayList<>();
        }
        //如果已经有当前解了，直接返回
        if(map.containsKey(input)){
            return map.get(input);
        }
        List<Integer> result = new ArrayList<>();
        int num = 0;
        int index = 0;
        while (index < input.length() && !isOperation(input.charAt(index))) {
            num = num * 10 + input.charAt(index) - '0';
            index++;
        }
        if (index == input.length()) {
            result.add(num);
            //存到 map
            map.put(input, result);
            return result;
        }
        for (int i = 0; i < input.length(); i++) {
            if (isOperation(input.charAt(i))) {
                List<Integer> result1 = diffWaysToCompute(input.substring(0, i));
                List<Integer> result2 = diffWaysToCompute(input.substring(i + 1));
                for (int j = 0; j < result1.size(); j++) {
                    for (int k = 0; k < result2.size(); k++) {
                        char op = input.charAt(i);
                        result.add(caculate(result1.get(j), op, result2.get(k)));
                    }
                }
            }
        }
        //存到 map
        map.put(input, result);
        return result;
    }

    private static int caculate(int num1, char c, int num2) {
        switch (c) {
            case '+':
                return num1 + num2;
            case '-':
                return num1 - num2;
            case '*':
                return num1 * num2;
        }
        return -1;
    }

    private static boolean isOperation(char c) {
        return c == '+' || c == '-' || c == '*';
    }
}