表达式求值重点问题探讨
注：一、二部分是精髓也是基础，三及其后部分是一些变形和应用，希望你能从一、二部分获得经验和技巧，充分运用到后面问题的思考中。
先从一个经典的问题谈起，
一、24点问题
*你有 4 张写有 1 到 9 数字的牌。你需要判断是否能通过 *，/，+，-，(，) 的运算得到 24。
output：true/false
Method:
递归执行：
（1）4选2，执行+、-、*、/之一，变为三个数字 //有4选2 有6种选法，即共4*6种情况
（2）3选2，执行+、-、*、/之一，变为二个数字
（3）2选2，执行+、-、*、/之一，变为一个数字
判断是否为24
剪枝：
（1）除法分母不为0
（2）+、*满足交换律 即上述递归执行（1）只有2*6+2*6/2 = 18种解法
代码实现
class Solution {
public boolean judgePoint24(int[] nums) {
ArrayList A = new ArrayList<Double>();
for (int v: nums) A.add((double) v);
return partition(A);
}
public boolean partition(ArrayList<Double> nums) {
if (nums.size() == 0) {
return false;
}
if (nums.size() == 1) {
return Math.abs(nums.get(0) - 24) < 1e-6;
}
for (int i = 0; i < nums.size(); i++) {
for (int j = 0; j < nums.size(); j++) {
// 选择其中任意两个进行运算
//保证这两个不相等
if (i != j) {
ArrayList<Double> nums2 = new ArrayList<>();
//对非被选中的，直接加入
for (int k = 0; k < nums.size(); k++) {
if (k != i && k!=j) {
nums2.add(nums2.get(k));
}
}
//对被选中的运算
for (int k = 0; k < 4; k++) {
if (k < 2 && j > i) {
continue;
} else if (k == 0) {
nums2.add(nums.get(i) + nums.get(j));
} else if (k == 1) {
nums2.add(nums.get(i) * nums.get(j));
} else if (k == 2) {
nums2.add(nums.get(i) - nums.get(j));
} else if (k == 3 && nums.get(j) != 0) {
nums2.add(nums.get(i) / nums.get(j));
} else {
continue;
}
if (partition(nums2)) {
return true;
}
//回退
nums2.remove(nums2.size() - 1);
}
}
}
}
return false;
}
}变形
在这里，想做个小变形，给大家感受一下，
output改成：输出所有满足要求的表达式
其实，只需要少量修改代码，即可完成。
在这里，给出代码解答
class Solution {
public List<String> judgePoint24(int[] nums) {
ArrayList A = new ArrayList<Double>();
List<String> result = new ArrayList<>();
List<String> nowRes = new ArrayList<>();
for (int v: nums) {
A.add((double) v);
nowRes.add(String.valueOf(v));
}
partition(A, nowRes, result);
return result;
}
public void partition(ArrayList<Double> nums, List<String> nowRes, List<String> result) {
if (nums.size() == 0) {
return;
}
if (nums.size() == 1) {
if (Math.abs(nums.get(0) - 24) < 1e-6) {
result.add(nowRes.get(0));
}
}
for (int i = 0; i < nums.size(); i++) {
for (int j = 0; j < nums.size(); j++) {
// 选择其中任意两个进行运算
//保证这两个不相等
if (i != j) {
ArrayList<Double> nums2 = new ArrayList<>();
ArrayList<String> nowRes2 = new ArrayList<>();
//对非被选中的，直接加入
for (int k = 0; k < nums.size(); k++) {
if (k != i && k!=j) {
nums2.add(nums.get(k));
nowRes2.add(nowRes.get(k));
}
}
//对被选中的运算
for (int k = 0; k < 4; k++) {
if (k < 2 && j > i) {
continue;
} else if (k == 0) {
nums2.add(nums.get(i) + nums.get(j));
nowRes2.add(
'(' + nowRes.get(i) + '+' + nowRes.get(j) + ')');
partition(nums2, nowRes2, result);
nums2.remove(nums2.size() - 1);
nowRes2.remove(nowRes2.size() - 1);
} else if (k == 1) {
nums2.add(nums.get(i) * nums.get(j));
nowRes2.add(
"" + nowRes.get(i) + '*' + nowRes.get(j) + "");
partition(nums2, nowRes2, result);
nums2.remove(nums2.size() - 1);
nowRes2.remove(nowRes2.size() - 1);
} else if (k == 2) {
nums2.add(nums.get(i) - nums.get(j));
nowRes2.add(
'(' + nowRes.get(i) + '-' + nowRes.get(j) + ')');
partition(nums2, nowRes2, result);
nums2.remove(nums2.size() - 1);
nowRes2.remove(nowRes2.size() - 1);
} else if (k == 3 && nums.get(j) != 0) {
nums2.add(nums.get(i) / nums.get(j));
nowRes2.add(
"" + nowRes.get(i) + '/' + nowRes.get(j) + "");
partition(nums2, nowRes2, result);
nums2.remove(nums2.size() - 1);
nowRes2.remove(nowRes2.size() - 1);
} else {
continue;
}
}
}
}
}
return;
}
}二、经典表达式求值
在这里不得不谈一些最经典、最基础的问题，在这里将从无括号四则运算、逆波兰式、栈、递归下降来做一个全面的讲解。
无括号四则运算：
处理简单的无括号四则运算，相信每个人都有许多自己的思考，在这里想简单介绍一个回退方法。
伪代码如下：
int curPos; //记录当前遍历到的expression的位置
//记录当前运算结果 以及 上一次运算符和数字
function partition(result, lastOperaNum):
//递归结束
if (cur == expression.length - 1) {
return result
}
//无上次操作数和操作符，表示第一次递归
if (lastOperaNum.length == 0) {
number = getNumber()
partition(number, number)
} else {
oprator = getOperator()
number = getNumber()
if operator is +:
partition(result + number, "+" + number)
if operator is -:
partition(result - number, "-" + number)
//重点！！！！！！！！
//先回退后乘或除!!!
if operation is *:
partition(result - lastOperaNum + (lastoperaNum * nunmber), lastoperaNum * number)
if operation is /:
partition(result - lastOperaNum + (lastoperaNum / nunmber), lastoperaNum / number)
}
逆波兰算法：
核心思想是将普通的中缀表达式转换为后缀表达式。（关于表达式的理解可以去查询DS中关于二叉树的遍历的描述，这里不再赘述）
后缀表达式：运算符在两个操作数的后面。后缀表达式虽然看起来奇怪，不利于人阅读，但利于计算机处理。
1、后缀表达式（逆波兰式）求值
比较简单，直接上伪代码：
function suffixToResult：
for each element in suffix_expression
{
if(element is number)
{
stack.push(element)
}
else if(element is operator)
{
num1 = stack.pop()
num2 = stack.pop()
value = num1 + element + num2
stack.push(value)
}
return stack.pop()
}
}
2、中缀表达式转化为后缀表达式
这是算法的难点，也是重中之重
算法思想：
设置一个stack和一个linear list
其中stack临时存放运算符和左括号的
linear list存放后缀表达式
if number : list.add(number)
if (: stack.push('(')
if ): while(stack.pop == '(')
if operator:
if stack.peek() is not operator: stack.push(operator)
else :
if operator > stack.peek(): stack.push(operator)
else while(stack.peek() <= operator) stack.pop()
算法实现
class solution {
public void getVlaue(String string) {
System.out.println(suffixToResult(infixToSuffix(string)));
}
private boolean isNumber(char character) {
return character >= '0' && character <= '9';
}
private boolean isOperator(char character) {
return !isNumber(character) && character != '(' && character != ')';
}
private int priority(char character) {
if (character == '+' || character == '-') {
return 1;
} else {
return 2;
}
}
private Integer toNumber(String expr) {
int flag = 0;
//["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
if (expr.charAt(0) == '-') {
expr = expr.substring(1);
flag = 1;
}
int number = 0;
int bit = 1;
for (int i = expr.length() - 1; i >= 0; i--) {
number = number + (expr.charAt(i) - '0') * bit;
bit *= 10;
}
if (flag == 0) {
return number;
} else {
return -1 * number;
}
}
public List<String> infixToSuffix(String expr) {
Stack<Character> stack = new Stack<>();
ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < expr.length(); i++) {
if (expr.charAt(i) >= '0' && expr.charAt(i) <= '9') {
String numExpr = "";
while (i < expr.length() && isNumber(expr.charAt(i))) {
numExpr = numExpr + expr.charAt(i);
i++;
}
i--;
list.add(numExpr);
} else if (expr.charAt(i) == '(') {
stack.push(expr.charAt(i));
} else if (expr.charAt(i) == ')') {
while (!stack.isEmpty() && stack.peek() != '(') {
list.add("" + stack.pop());
}
if (!stack.isEmpty()) {
stack.pop();
}
} else {
while (!stack.isEmpty() && isOperator(stack.peek())
&& priority(stack.peek()) >= priority(expr.charAt(i))) {
//System.out.println(priority(stack.peek()));
//System.out.println(priority(expr.charAt(i)));
list.add(stack.pop() + "");
}
stack.push(expr.charAt(i));
}
//System.out.println(stack);
//System.out.println(list);
//System.out.println("-----");
}
while (!stack.isEmpty()) {
list.add(stack.pop() + "");
}
return list;
}
public int suffixToResult(List<String> list) {
//System.out.println(list);
Stack<Integer> stack = new Stack<>();
for (String element : list) {
if (isNumber(element.charAt(0)) || (element.length() > 1 && isNumber(element.charAt(1)))) {
//System.out.println(toNumber(element));
stack.push(toNumber(element));
} else {
//System.out.println(stack);
Integer num1 = stack.pop();
Integer num2 = stack.pop();
Integer value = 0;
if (element.charAt(0) == '+') {
value = num2 + num1;
} else if (element.charAt(0) == '-') {
value = num2 - num1;
} else if (element.charAt(0) == '*') {
value = num2 * num1;
} else if (element.charAt(0) == '/') {
value = num2 / num1;
}
System.out.println(num2);
System.out.println(num1);
System.out.println("***" + value);
stack.push(value);
}
}
return stack.pop();
}
}递归下降算法
递归下降是编译原理中词法分析的重要方法，而利用递归下降进行表达式求值，也是一个强烈推荐的手段！！！思考简单！！逻辑清晰！！！
核心思想
递归下降分析来求表达式的值。表达式的文法如下
expr = term {+、-} term
term = factor {*、/} factor
factor = (expr) or number
其实原理就这么简单，层层递归即可
代码实现
直接上代码，一看就知
class Solution {
int cur = 0;
String str = "";
public double cal(String s) {
this.str = s;
return expression();
}
public double expression() {
double num1 = term();
double num2;
while (cur < str.length() && (str.charAt(cur) == '+' || str.charAt(cur) == '-')) {
char op = str.charAt(cur);
cur++;
num2 = term();
if (op == '+') {
num1 += num2;
} else {
num1 -= num2;
}
}
if (cur < str.length() && str.charAt(cur) == ')') {
cur++;
}
return num1;
}
public double term() {
double num1 = factor();
double num2;
while (cur < str.length() && (str.charAt(cur) == '*' || str.charAt(cur) == '/')) {
char op = str.charAt(cur);
cur++;
num2 = factor();
if (op == '*') {
num1 *= num2;
} else {
num1 /= num2;
}
}
return num1;
}
public double factor() {
double result;
if (str.charAt(cur) == '(') {
cur++;
return expression();
} else {
String string = "";
while (cur < str.length() && isNumber(str.charAt(cur)) ) {
string = string + str.charAt(cur);
cur++;
}
result = toNumber(string);
}
return result;
}
private boolean isNumber(char character) {
return character >= '0' && character <= '9';
}
private Integer toNumber(String expr) {
int flag = 0;
//["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
if (expr.charAt(0) == '-') {
expr = expr.substring(1);
flag = 1;
}
int number = 0;
int bit = 1;
for (int i = expr.length() - 1; i >= 0; i--) {
number = number + (expr.charAt(i) - '0') * bit;
bit *= 10;
}
if (flag == 0) {
return number;
} else {
return -1 * number;
}
}
}三、给表达式添加优先级
Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are +, *and - .
Example 1:
Input: “2-1-1”
Output: [0, 2]
这是一道使用分治算法解决的经典的表达式问题。
思路其实可以与24点相类似。
不同在于
（1）一个添加符号，一个添加了符号后需要添加括号。
（2）一个顺序可变，一个顺序不可变
分治算法的重点在于如何分解成子问题。
其实跟大部分分治策略一样，就是把表达式分隔成左右两边，而分隔符选取为操作符即可。
了解了思路之后，我们就很容易写出partition的递归
function partition:
//因为可能性不止一种，因此使用list存储，即多个分隔符所决定的
LIST result
//递归终止条件
if !input.contain(operatior):
result.append(toNumber(input))
return result
for each element in input:
if element is operator:
for left in partition(input[left]):
for right int partion(input[right]):
result.add(left {+、-、*、/} right)
return result
看完伪代码之后，相信写出代码已经不是什么难事。
public List<Integer> diffWaysToCompute(String input) {
return partition(input);
}
public List<Integer> partition(String input) {
List<Integer> result = new ArrayList<>();
if (!input.contains("+") && !input.contains("-") && !input.contains("*")) {
result.add(Integer.valueOf(input));
return result;
}
for(int i = 0; i < input.length(); i++) {
if (input.charAt(i) == '+' || input.charAt(i) == '-' || input.charAt(i) == '*') {
for(Integer left : partition(input.substring(0, i))) {
for (Integer right : partition(input.substring(i + 1))) {
if (input.charAt(i) == '+') {
result.add(left + right);
} else if (input.charAt(i) == '-') {
result.add(left - right);
} else if (input.charAt(i) == '*') {
result.add(left * right);
}
}
}
}
}
return result;
}当然，在这里我还想再提供一种思路
分割字符串（split），分离出所有参与运算的数字（数量为n）和符号(数量为n-1)
然后与上述方法相同，进行partition，分解复杂度。
但是亲测整体时间复杂度上升（估计来自split等操作）
详细可以参考leetcode上我提供的题解
四、给表达式添加运算符
Given a string that contains only digits 0-9 and a target value, return all possibilities to add binary operators (not unary) +, -, or 、 between the digits so they evaluate to the target value.*
Example 1:
Input: num = “123”, target = 6
Output: [“1+2+3”, "12*3"]
这算是一道比较难的题目了，问题就在于分治递归策略的确定。
相信写了这道题之后，你会有所收获。
而关于本题的解法，可以先充分理解24点这道题的算法设计思路，之后再来思考本题。
个人认为，本题设计难点有以下几点：
1、优先级如何权衡，比如上一步递归到了+法，下一步是乘法，此时上一步计算结果如何修改的问题
在这里我们推荐本文二中的无括号四则运算的方法，采用回溯
2、同样采用子问题分解的策略，如何选取分隔符？
对于一个表达式12，我们可以取1与2中间作为分割，共一种情况
对于123，可以取1、2中，2、3中作为分割，共2+2=4种
对于1234，可以选取3+3+3=9种
以此类推
3、如何分解子问题？
对于一个长度为n的expression，一次递归中，可以选取其n个位置作为可能的运算符号所在地，并对这n个位置进行下一步递归。
expr: 0 1 2 3 4 ... n-1 n
split: 0 1 2 3 ... n-1 n
注意：最后一个位置必须选取。（自行思考原因）
4、如何在递归中保存结果
由于结果有多个，需要用list保存。与给表达式添加优先级一致。
解决了以上四个难点之后，我们的partition就很容易写出
public void partition(String num, int target,
String lastOperaNum,
String curNum,
String tempRes,
List<String> result) {
if (num.length() == 0 && curNum.length() != 0 && new BigInteger(curNum).equals(new BigInteger(String.valueOf(target)))) {
result.add(tempRes);
return;
}
for (int i = 1; i <= num.length(); i++) {
String cur = num.substring(0, i);
if (cur.length() > 1 && cur.charAt(0) == '0') {
return;
}
String next = num.substring(i);
if (tempRes.length() == 0) {
partition(next, target, cur, cur, cur, result);
} else {
partition(next, target, cur,
String.valueOf(new BigInteger(curNum).add(new BigInteger(cur))),
tempRes + "+" + cur, result);
partition(next, target, '-' + cur,
String.valueOf(new BigInteger(curNum).subtract(new BigInteger(cur))),
tempRes + "-" + cur, result);
partition(next, target,
String.valueOf(new BigInteger(lastOperaNum).multiply(new BigInteger(cur))),
String.valueOf(new BigInteger(curNum).subtract(new BigInteger(lastOperaNum)).add(new BigInteger(lastOperaNum).multiply(new BigInteger(cur)))),
tempRes + "*" + cur, result);
}
}
}这是一个典型且综合的应用，希望大家能好好理解
1045
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
