Question

我正在制定一个程序，声明：

您将获得一个包含M行和N列的二维矩阵。您最初位于（0,0），这是数组中的左上角单元格。您可以向右或向下移动。数组填充1和0。 1表示您可以在该单元格中移动，0表示您无法移动该单元格。返回从左上角单元格到右下角单元格的路径数（即（0,0）到（M-1，N-1））。由于答案可能很大，因此您必须返回ans％（10 ^ 9 + 7）。

我尝试实现它并且它适用于某些情况但在某些情况下失败：

static int count(int a[][], int i, int j) {
    int rows = a.length;
    int cols = a[0].length;
    if(a[i][j] == 0)  return 0;
    if (i == rows - 1 && j == cols - 1)
        return a[i][j];
    else if (i == rows - 1)
        return a[i][j + 1];
    else if (j == cols - 1)
        return a[i + 1][j];
    else if (a[i][j] == 1)
        return count(a, i + 1, j) + count(a, i, j + 1);
    else
        return 0;
}

以下数组失败： {{1,1}, {0,1}}

你能帮我解决一下这个程序中的问题吗？

更新

感谢@Johnny Mopp，它解决了上述测试用例。我们如何才能提高该计划的绩效？

Answer 1

首先，如果要检查a[i][j]的值。它是0，你应该返回0。

关于性能，以这种方式编写的算法非常慢，因为您多次计算相同的值。使用记忆（创建第二个数组并保存您返回的每个值，如果您之前没有计算过它，请先在功能检查开始时保存）或使用动态编程解决它。

编辑：你忘了你的模数10 ^ 9 + 7。

第二次编辑（回复你的评论）：就是这样的。我把它分成了三个循环，这样主（第三）循环的操作就更少了，大数据的功能要快得多。我也改变了计算方向，但它根本不重要。

static int count_dp(int a[][]){
    int rows = a.length;
    int cols = a[0].length;
    int[][] dp = new int[rows][cols];

    dp[0][0] = a[0][0];

    for(int i=1;i<rows;i++)
        if(dp[i-1][0]==1 && a[i][0]==1)
            dp[i][0] = 1;

    for(int i=1;i<cols;i++)
        if(dp[0][i-1]==1 && a[0][i]==1)
            dp[0][i] = 1;

    for(int i=1;i<rows;i++)
        for(int j=1;j<cols;j++)
            if(a[i][j]==1)
                dp[i][j] = (dp[i-1][j] + dp[i][j-1])%1000000007;

    return dp[rows-1][cols-1];
}

Answer 2

def path_finder(i,j,m,l,n):
    if i==n-1 and j==n-1:
        if m[i][j]==1:
            l.append([i,j])
            return 1
        else:
            return 0
    if i==n or j==n:
        return 0
    if m[i][j]==0:
        return 0
    l.append([i,j])
    fl=path_finder(i+1,j,m,l,n)   #vertical movement 
    fr=path_finder(i,j+1,m,l,n)   #horizontal movement 
    if not (fl or fr):
        l.pop()
        return 0
    return 1

if __name__=='__main__':
    n=4   #size od matrix
    i=0
    j=0
    m=[[1,1,1,0],
       [1,0,1,1],
       [1,1,0,1],
       [1,1,0,1]]
    l=[]  #empty list to store path indices
    found=path_finder(i,j,m,l,n)
    if found==1:
        for i in l:
            print('({0},{1})'.format(*i),end=' ')
    else:
        print(-1)
# A recursive approach to the solution.
# Works for all values of n if we can move only right and 
down. Fails if we have to move up or left,Eg: for matrix 
shown below we have to move up in order to get to n, n
[[1 1 1 1 1], 
 [1 0 0 0 0], 
 [1 0 1 1 1], 
 [1 0 1 0 1], 
 [1 1 1 0 1]]

查找0和1的矩阵中的路径总数

2 个答案: