241.为运算表达式设计优先级*

给你一个由数字和运算符组成的字符串 expression ，按不同优先级组合数字和运算符，计算并返回所有可能组合的结果。你可以 按任意顺序 返回答案。

生成的测试用例满足其对应输出值符合 32 位整数范围，不同结果的数量不超过 104 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/different-ways-to-add-parentheses
 

思路：

首先将字符串转换为数字和符号保存在ops中，符号分别用-1、-2、-3表示。然后用dp[l][r]存储l到r的所有计算结果，深度搜索从l到r的所有结果。

代码如下：

class Solution {

    static final int ADDTION=-1;

    static final int SUBTRACTION=-2;

    static final int MULTIPLICATION=-3;

    public List<Integer> diffWaysToCompute(String expression) {

        List<Integer> ops=new ArrayList<Integer>();

        for(int i=0;i<expression.length();){

            if(!Character.isDigit(expression.charAt(i))){

                if(expression.charAt(i)=='+'){

                    ops.add(ADDTION);

                }

                else if(expression.charAt(i)=='-'){

                    ops.add(SUBTRACTION);

                }

                else{

                    ops.add(MULTIPLICATION);

                }

                i++;

            }

            else{

                int t=0;

                while(i<expression.length()&&Character.isDigit(expression.charAt(i))){

                    t=t*10+expression.charAt(i)-'0';

                    i++;

                }

                ops.add(t);

            }

        }

        List<Integer>[][] dp=new List[ops.size()][ops.size()];

        for(int i=0;i<ops.size();i++){

            for(int j=0;j<ops.size();j++){

                dp[i][j]=new ArrayList<Integer>();

            }

        }

        return dfs(dp,0,ops.size()-1,ops);

    }

    public List<Integer> dfs(List<Integer>[][] dp,int l,int r,List<Integer> ops){

        if(dp[l][r].isEmpty()){

            if(l==r){

                dp[l][r].add(ops.get(l));

            }

            else{

                for(int i=l;i<r;i+=2){

                    List<Integer> left=dfs(dp,l,i,ops);

                    List<Integer> right=dfs(dp,i+2,r,ops);

                    for(int lv:left){

                        for(int rv:right){

                            if(ops.get(i+1)==ADDTION){

                                dp[l][r].add(lv+rv);

                            }

                            else if(ops.get(i+1)==SUBTRACTION){

                                dp[l][r].add(lv-rv);

                            }

                            else{

                                dp[l][r].add(lv*rv);

                            }

                        }

                    }

                }

            }

        }

        return dp[l][r];

    }

}