Question

问题和算法的详情

给定一个MxN网格，从左上角的单元格到达右下角的单元格可以有多少条路径？在任何网格上，您都可以向四个方向移动。唯一的限制是不能多次访问一个单元格。

我们可以使用回溯算法来解决这个问题，这里是代码（reference）：

public class Robot {
    private static int count = 0;
    public static void main(String[] args) {
        Robot robot = new Robot();
        int m = 5, n = 5;
        boolean Visited[][] = new boolean[5][5];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++)
                Visited[i][j] = false;
        }
        robot.traverse(Visited, 0, 0, m, n);
        System.out.println(count);
    }
    /**
     * 
     * @param Visited array
     * @param index i
     * @param index j
     * @param max Row m
     * @param max column n
     */
    private void traverse(boolean Visited[][], int i, int j, int m, int n){
        if(i==m-1&&j==n-1){
            count++;
            return;
        }
        if(isSafe(i, j, m, n, Visited)){
            Visited[i][j]=true;
            traverse(Visited, i, j+1, m, n);
            traverse(Visited, i+1, j, m, n);
            traverse(Visited, i-1, j, m, n);
            traverse(Visited, i, j-1, m, n);
            Visited[i][j] = false;
        }
    }
    /**
     * 
     * @param index i
     * @param index j
     * @param max Row m
     * @param max Column n
     * @param Visited array
     * @return isSafe or not
     */
    private boolean isSafe(int i, int j, int m, int n, boolean Visited[][]){
        if(i>=0&&j>=0&&i<m&&j<n&&!Visited[i][j])
            return true;
        else
            return false;
    }

}

我知道什么？

我对使用替换方法和递归树方法（reference）计算递归算法的时间复杂度有一些了解。我可以计算一些更简单算法的时间复杂度（例如Fibonacci Sequence）。

在此处发布问题之前我做了什么？

我查看了this，this，this和许多其他链接。但我无法将所有这些信息结合在一起，并发现这个问题的时间复杂性。

我尝试使用递归树方法来计算时间复杂度。但是当M＆amp; N很大时，路径可能非常扭曲，我不知道如何扩展树，因为四个方向都是允许的。

在阅读this之后，我有一个粗略的想法，也许我可以根据剩余的网格来思考：

步骤1 - 可以选择MxN网格，因此有MxN可能性。
第2步 - 只能选择MxN-1网格。所以我们有（MxN）x（MxN-1）
等等，直到一个未知的结局。

但是，我还不能完全理解这种算法的时间复杂性。

我想知道什么？

对于像这样的回溯算法，我们如何完全理解它的时间复杂度？

任何想法都表示赞赏。

Answer 1

估计运行时复杂度T的问题可以解决如下。设P=M*N为输入中的单元格总数。在每次递归调用中，permittet单元的数量减少一个，总共有4个递归调用;基本情况的计算成本是不变的，其中没有允许的单元格，这意味着

T(0) = C

保持C某个合适值的位置。对于任意P，我们获得递归关系

T(P) = 4*P(T-1)

并使用归纳法，我们可以证明

T(P) in O(4^P)

成立。总的来说，运行时间在输入的单元格数量中呈指数限制，但这并不意味着这种限制是紧的。

如何计算回溯算法的时间复杂度

1 个答案: