Question

我有一个算法，我想找出它的复杂性，但有递归，我不知道如何计算递归。我的代码是：

public boolean algorithm(int x, int y) {
    if (x == matrixHeight - 1 && matrix1[x][y] == '0') {
        return true;
    } else if (x == 1 && matrix1[x-1][y] == '0') {
        return true;
    } else if (y == matrixWidth - 1 && matrix2[x][y] == '0') {
        return true;
    } else if (y == 1 && matrix2[x][y-1] == '0') {
        return true;
    }
    if (matrix1[x-1][y] == '0' && tempMatrix[x-1][y] == '-'){
        path.push(new int[]{x-1, y});
        tempMatrix[x-1][y] = '+'
        if (!algorithm(x-1, y)) {
            path.pop();
        } else {
            return true;
        }
    }
    if (matrix2[x][y] == '0' && tempMatrix[x][y+1] == '-'){
        path.push(new int[]{x, y+1});
        tempMatrix[x][y+1] = '+';
        if (!algorithm(x, y+1)) {
            path.pop();
        } else {
            return true;
        }
    }
    if (matrix1[x][y] == '0' && tempMatrix[x+1][y] == '-'){
        path.push(new int[]{x+1, y});
        tempMatrix[x+1][y] = '+';
        if (!algorithm(x+1, y)) {
            path.pop();
        } else {
            return true;
        }
    }
    if (matrix2[x][y-1] == '0' && tempMatrix[x][y-1] == '-'){
        path.push(new int[]{x, y-1});
        tempMatrix[x][y-1] = '+';
        if (!algorithm(x, y-1)) {
            path.pop();
        } else {
            return true;
        }
    }
    return false;
}

在那里，x，y是矩阵中的坐标。
matrix1和matrix2是包含'0'或'1'
tempMatrix是一个包含“+”或“ - ”
path是一个堆栈
matrixHeight是matrix1.length
matrixWidth是matrix[0].length
N，M是矩阵的大小（常量）

注意：这是使用回溯的迷宫求解器。

Answer 1

对于递归，您需要生成递归关系并求解。见http://en.wikipedia.org/wiki/Recurrence_relation。没有固定的方法来解决每个递归关系，甚至无法从算法中生成一个。

一个例子是合并排序。考虑每次递归调用完成了多少工作。首先，有一个恒定的时间划分;然后进行两次递归调用;然后有一个线性时间合并。递归调用需要多少工作？好吧，每个人做同样的事情，两个递归调用加上线性合并步骤。所以你需要一个表达树的深度和宽度。你知道输入大小为n，树的高度是O（log（n）），并且在每一步完成O（n）合并工作，所以O（n log（n））的工作是总计。

Answer 2

它看起来像深度第一个迷宫求解器，如果你可以退出迷宫，则返回true，否则返回false。复杂度为O(lines * columns)，因为在最坏的情况下，您会访问每个单元格一次。

从（1,1）开始。您的算法将上升，回溯，向右，再次尝试，回溯，再次向右，回溯，然后向下等等。对于像这样构造的迷宫，看起来你的算法将花费大量时间来解决它们。

事实上，大多数递归（深度优先更准确）方法将花费很长时间，因为总是可以强制它们执行最大步数。

查看Lee algorithm以获得更好的方法。

Answer 3

实际上，对该算法的复杂性进行了非常简单的分析。

对algorithm的每次调用都会对algorithm进行零到四次递归调用，并执行一些不变的其他工作。因此，如果我们可以约束algorithm被调用的次数，那么我们就知道复杂性。现在，请注意，在每次调用algorithm之前（第一个除外），您将tempMatrix的元素从“ - ”更改为“+”。因此，对算法的调用次数受tempMatrix大小的限制，复杂度为O(matrixWidth * matrixHeight)。

另一种方法（对于更有意义的变量名更明显）只是注意到你正在x-y网格上进行深度优先搜索。所以每个“广场”都会被访问过一次。

递归算法的复杂性

3 个答案: