java数据结构与算法刷题-----LeetCode241. 为运算表达式设计优先级

java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)：https://blog.csdn.net/grd_java/article/details/123063846

分治+后序遍历+记忆化搜索

解题思路：时间复杂度O($2^n$)，每个运算符两边都需要使用后序遍历进行分治，空间复杂度O($2^n$)

1. 遍历字符串遇到运算符x后，就以x为中心分成左右两部分，这两部分都不包含当前x这个运算符
2. 对两部分不断进行分治，遇到运算符就分为两部分。直到当前进行分治的字符串是纯数字，没有运算符,就返回这个数字
3. 当我们接收到分治处理完成的数字列表时，对左右两部分的数字，用运算符x进行枚举组合。这样就完成了枚举所有运算符不同优先级的不同结果
4. 但是分治过程中，会发现有很多重复操作，所以我们可以用map保存每次分治结果，如果下次是相同的分治过程，就直接返回map中保存的结果

案例：分治+后序遍历

1. 找到第一个运算符2*3-4 * 5,将其分为两部分，2和3-4 * 5，分别对两部分进行后序遍历。其中左边部分是2，不继续遍历
2. 3-4 * 5分成两部分为3和4 * 5，左边部分是3，不继续遍历
3. 4 * 5分成两部分为4和5，都不进行遍历，然后参与运算获取(4 * 5)
4. 回到3-4 * 5,参与运算获得3 - (4 * 5)继续分治，这次找第二个运算符3-4 * 5,分成两部分3-4和5.右边部分为5不继续遍历
5. 3-4分成两部分，都是数字，然后参与运算获得(3-4)
6. 回到3-4 * 5，此时左边为第5步获得的(3-4)，参与运算获得(3-4) * 5
7. 回到2*3-4 * 5，此时左边为2，右边为(3-4) * 5和3 - (4 * 5)。参与运算获得第一个答案：2 * ((3-4) * 5)和第二个答案：2 * (3 - (4 * 5))

然后找第二个运算符2 * 3-4 * 5继续左右两边2 * 3和4 * 5进行后序遍历分治

8. 分治后获得(2*3)和(4*5),回到2 * 3-4 * 5运算后得到第3个答案：(2 * 3) - (4 * 5)
9. 回到2 * 3-4 * 5,找第3个运算符2 * 3-4 * 5,分两部分为2 * 3-4和5
10. 2 * 3-4

1. 第一个运算符2 * 3-4,获得(2 * (3-4))
2. 第二个运算符2 * 3-4,获得((2 * 3)-4))

11. 2 * 3-4 * 5,左边有两个结果(2 * (3-4))和((2 * 3)-4))

获得第4个答案：(2 * (3-4))*5和第5个答案：((2 * 3)-4))*5

代码

class Solution {
    Map<String, List<Integer>> map=new HashMap<>();//记忆化搜索，已经处理过的，不重复处理
    //入口方法
    public List<Integer> diffWaysToCompute(String expression) {
        return dfs(expression);
    }
    //判断当前子串是否是纯数字
    public int parseInt(String str){
        for(int i=0;i<str.length();i++){
            if(!Character.isDigit(str.charAt(i)))return -1;//如果有一个字符不是数字就返回-1
        }
        return Integer.parseInt(str);//否则将其转换为int
    }
    //分治利用后序遍历求解。遇到一个运算符x，就去计算运算符左边和右边的所有可能结果
    //最后将这些结果用运算符x组合
    public List<Integer> dfs(String str){
        int num=parseInt(str);//判断当前字符串是否是纯数字
        if(num>=0) return new ArrayList<Integer>(){{add(num);}};//如果是，将其添加到list中返回
        //如果不是，判断当前字符串是否预处理过，如果处理过，直接返回上次处理的结果
        if(map.containsKey(str))return map.get(str);
        //如果没有预处理过
        List<Integer> res = new ArrayList<>();
        for(int i=0;i<str.length();i++){//遍历字符串
            char ch=str.charAt(i);//获取字符
            if(ch=='+' || ch=='-' || ch=='*'){//如果当前i字符是符号
                //left是对当前i符号的左边的表达式进行分治
                List<Integer> left = dfs(str.substring(0,i));
                //right是对当前i符号右边的表达式进行分治
                List<Integer> right = dfs(str.substring(i+1));
                int val=0;
                for(int l:left){//拿到i左边的表达式所有结果
                    for(int r:right){//拿到i右边表达式所有可能的结果
                        switch(ch){//通过当前i运算符将所有结果进行枚举
                            case '+':
                                val=l+r;
                                break;
                            case '-':
                                val=l-r;
                                break;
                            case '*':
                                val=l*r;
                                break;
                            default:
                        }
                        res.add(val);//将当前结果添加到链表中
                    }
                }
            }
        }
        map.put(str, res);//已经处理过的结果进行保存，不要重复处理
        return res;
    }
    
}