Java 在0'；s和1'；s

我正在制定一项计划，其中规定：

您将获得一个包含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，它解决了上面的测试用例。如何提高该程序的性能？

首先，如果要检查

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];
}

静态整数计数\u dp（整数a[]]{
int行=a.length；
int cols=a[0]。长度；
int[][]dp=新的int[行][cols]；
dp[0][0]=a[0][0]；
对于（int i=1；我认为首先需要检查单元格的值。例如：
如果（a[i][j]==0）返回0；
“它不工作”这对我们没有帮助。程序失败时会做什么，它与预期的行为有何不同？我同意Johnny Mopp的观点。如果您所在的单元格的值为0且在边界上，那么您的代码现在将在该边界上继续，而不是返回0。创建一个矩阵来存储哪个单元格中有多少wa从中删除，然后将其作为控件打印？最好使用调试器解决此类问题（请参见此处：）@Johnnymop，谢谢你，它现在起作用了，有没有办法提高这个程序的性能？你能给我一个如何使用动态编程的片段吗？类似于你的算法，但你不使用递归。创建第二个相同大小的数组。然后你只需按正确的顺序循环数组（例如
）（int i=rows-1；i>=0；i--）for（int j=cols-1；j>=0；j--）
）和现在一样计算值，但不是递归，而是从数组中获取以前计算的值。我尝试了这种方法，但无法得到答案，请您提供一个使用动态编程的解决方案好吗？答案是肯定的。我之前有一个DP解决方案，从右下角开始，到左上角，答案是dp[0][0]。我对您的优化非常感兴趣。我的I，j循环有4个if语句，现在可以看到您如何去掉其中的三个（底部/右侧单元格和每个外部行/列），只留下一个if语句。非常好。。。
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]]