Question

为了清楚，这是不是家庭作业，我在自己的时间学习CS！

我最近在Charles Phillips购买了一本名为“50个逻辑思维谜题”的书。我开始其中一个，我发现我可以使用递归来解决问题。这是（转述）问题：

在每个空格中插入一个数学运算符（+， - ，÷，x）来求解等式：

6 _ 3 _ 5 _ 7 _ 4 _ 8 = 13

据我所知，为了使用递归来解决这个问题，我首先需要确定一个基本案例。但是，我在这方面遇到了麻烦。

所以我的问题是，什么是可能的基础案例，我该如何开始实施呢？递归函数看起来像什么（参数，返回类型等）？（代码请帮忙）！

这是我到目前为止所做的：我认为几乎正常工作

请参阅我的答案以了解实施

N.b。我正在使用 Java

Answer 1

我认为停止条件应该意味着满足等式：所有操作符都被填入，操作导致正确的相等。

我将等式表示为一个解析树，其中叶子为数字，父亲为运算符。树自然适合递归，因为它是一个分层数据结构。

使操作符假设根操作为减号，右子项为期望值（13），左子项为左侧。添加运算符，计算树并回溯，直到满足停止条件。

Answer 2

基本情况是所有空白都被操作员填写。您可以使用深度优先回溯搜索来解决此问题：

algorithm dfs(i):
    if i == num_blanks:  # base case: filled in all the blanks
        if equation_solved():
            return the operators you filled in
    else:
        for op in (+, -, ÷, ×):
            blank[i] = op
            if dfs(i + 1) returns a solution:
                return that solution
            blank[i] = _     # restore to previous state

这是一种搜索整个组合空间的递归方式。（我希望这不会破坏你的练习;我用伪代码把它写成给你留下实现。）

Answer 3

您可以将其视为决策树。

              6
        /    /    \    \
        +   -     *    /
        3                    Assuming you choose + for the first operator
/    /       \    \
+   -        *    /
5   5        5    5
    ^             ^
    6 + 3 - 5     6 + 3 / 5

然后，您可以使用图形遍历算法（如DFS或BFS）来检查结果。两者都是自然递归的。

Answer 4

这是我最终得到的实现，但首先解释了问题的解决方案：

基本情况（如larsmans和Jan Dvorak所说）是所有“_”都填充了运算符（例如“+”）。
该函数调用自身，每次添加另一个参数，直到它到达不正确的基本情况（例如“6 + 3 + 5 + 7 + 4-8 = 13”）或它有正确的答案。
如果基本情况不正确，那么我们会不断提升我们可以更改的运营商级别。

以下是代码：

class GapFill {

    private static String numbers; //E.g. 6_5_4=15
    private static String[] blank; //Array of operators to go in the blanks

    //Where:
    //p = plus
    //m = minus
    //d = divide
    //t = times
    private static String[] operators = {"p", "m", "d,", "t"};

    public static void main(String[] args) {
        numbers = args[0];
        blank = new String[numbers.split("_").length - 1];
        if(dfs(0)) { //If a solution was found
            int count = 0;
            while(numbers.indexOf("_")!=-1) {
                int index = numbers.indexOf("_");
                numbers = numbers.substring(0,index)+blank[count]+numbers.substring(index+1);
                count++;
            }
            System.out.println(numbers);
        }
    }

    private static boolean dfs(int i) {
        if(i == blank.length) {  //base case: filled in all the blanks
            return solveEquation();
        }
        for(String op : operators) {
            blank[i] = op;
            if(dfs(i + 1)) {
                return true;
            }
        }
        blank[i] = "_"; //restore to previous state
        return false;
    }

    private static boolean solveEquation() {
        String[] eachNumber = numbers.substring(0, numbers.indexOf("=")).split("_");
        String finalResult = numbers.substring(numbers.indexOf("=")+1, numbers.length());
        double currentResult = Double.parseDouble(eachNumber[0]);
        for(int i=1;i<eachNumber.length;i++) {
            String op = blank[i-1];
            if(op==operators[0]) {
                currentResult = currentResult + Integer.parseInt(eachNumber[i]);
            } else if(op==operators[1]) {
                currentResult = currentResult - Integer.parseInt(eachNumber[i]);
            } else if(op==operators[2]) {
                currentResult = currentResult / Integer.parseInt(eachNumber[i]);
            } else if(op==operators[3]) {
                currentResult = currentResult * Integer.parseInt(eachNumber[i]);
            }
        }
        return (currentResult==Integer.parseInt(finalResult));
    }

}

java GapFill 6_3_5_7_4_8=13的输出为6m3p5m7p4p8=13。

使用“p，m，d，t”符号代替“+， - ，÷，×”，因为终端不喜欢×或÷

在Java中实现递归

4 个答案: