[Leetcode] 282. Expression Add Operators

最新推荐文章于 2023-10-16 11:39:44 发布

原创最新推荐文章于 2023-10-16 11:39:44 发布 · 315 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 专栏收录该内容

294 篇文章

订阅专栏

本文探讨了一种利用回溯算法解决数学表达式求值问题的方法，并通过具体的实例详细介绍了如何处理加减乘运算，特别是巧妙地处理连续乘法运算。此外，还介绍了一些优化技巧来减少不必要的计算。

这一题还是需要MARK一下，不是很容易。基本原理是backtrack，但是还需要考虑到乘法这个CASE，除了计算到当前的结果以外，还需要积累乘积的结果。除了需要有一个参数记录累乘的结果意外，还要有一个比较取巧的一点。举个例子

345623，譬如前面3和4我让它先走3 + 4 = 7的recursion branch。然后到了5，在走乘号的branch的时候，我就先减掉4，然后再加上4 * 5，这个时候就变成了 3 + 4 - 4 + 4 * 5 = 3 + 4 * 5 = 23。如果到6还要乘的话，就减掉之前累乘的数字，再将累乘的数字乘以当前的6，就变成了3 + 4 * 5 - 4 * 5 + 4 * 5 * 6 = 123。这个也是对的。如果到了2，我走的branch不是乘，那么累乘的数字就要重新开始算。要注意的是，当重新算累乘的数字的时候，减号对应的累乘的数字应该是一个负数。

再说回backtrack怎么做，其实不复杂。就是循环目前的字符串（或者子字符串，如果已经进入了backtrack的过程）的长度，在循环的过程里，截取对应长度的子字符串变成数字，对其进行加，减，乘三个分支进行下一层的recursion。同时记录到目前为止的计算结果，累乘结果以及对应的结果字符串。当到了最后一层recursion（也就是字符串走到了尽头），看看目前的计算结果是否等于target，是的话就把对应的结果字符串放进结果数组，否则就略过。根据上述的说法，可以得到代码如下：

    public List<String> addOperators(String num, int target) {
        List<String> result = new LinkedList<>();
        buildResults(result, 0, 0, 0, "", num, target);
        return result;
    }
    
    public void buildResults(List<String> result, long curNum, long multiNum, int curpos, String curResult, String num, int target) {
        if (curpos == num.length()) {
            if (curNum == target) {
                result.add(curResult);
            }
        }  else {
            for (int i = curpos; i < num.length(); i++) {
                if (num.charAt(curpos) == '0' && i != curpos) break;
                
                long curVal = Long.parseLong(num.substring(curpos, i + 1));
                if (curpos == 0) {
                    buildResults(result, curVal, curVal, i + 1, curResult + curVal, num, target);
                } else {
                    buildResults(result, curNum + curVal, curVal, i + 1, curResult + "+" + curVal, num, target);
                    buildResults(result, curNum - curVal, -curVal, i + 1, curResult + "-" + curVal, num, target);
                    buildResults(result, curNum - multiNum + multiNum * curVal, curVal * multiNum, i + 1, curResult + "*" + curVal, num, target);                    
                }
            }
        }
    }

上述过程其实还可以进行一些优化的剪枝操作，譬如说在加法的分支上，最大的可以加的数字就是后续的子字符串变成一个数字，如果加上这个数字都小于target，就说明后续操作无论如何都无法达到。减法也是，如果减掉可以减的最大的数字依旧大于target，就说明这个branch也该到此为止了。根据上述理论，可以得到代码如下：

    public List<String> addOperators(String num, int target) {
        List<String> result = new LinkedList<>();
        buildResults(result, 0, 0, 0, "", num, target);
        return result;
    }
    
    public void buildResults(List<String> result, long curNum, long multiNum, int curpos, String curResult, String num, int target) {
        if (curpos == num.length()) {
            if (curNum == target) {
                result.add(curResult);
            }
        }  else {
            for (int i = curpos; i < num.length(); i++) {
                if (num.charAt(curpos) == '0' && i != curpos) break;
                
                long curVal = Long.parseLong(num.substring(curpos, i + 1));
                long maxVal = Long.parseLong(num.substring(curpos));
                if (curpos == 0) {
                    buildResults(result, curVal, curVal, i + 1, curResult + curVal, num, target);
                } else {
                    if (curNum + maxVal >= target) {
                        buildResults(result, curNum + curVal, curVal, i + 1, curResult + "+" + curVal, num, target);
                    }

                    if (curNum - maxVal <= target) {
                        buildResults(result, curNum - curVal, -curVal, i + 1, curResult + "-" + curVal, num, target);
                    }
                    buildResults(result, curNum - multiNum + multiNum * curVal, curVal * multiNum, i + 1, curResult + "*" + curVal, num, target);                    
                }
            }
        }
    }

可以看到的我就是加了一个maxVal以及围绕其进行的剪枝判断。