Question

我正在尝试通过Interviewbit提出以下问题：

给定一个m×n的网格，其中填充了非负数，请找到一条从左上到右下的路径，以使沿着该路径的所有数字的总和最小。

注意：您只能在任何时间点向下或向右移动。

我写了以下备忘录解决方案：

int minPath(vector<vector<int> > &A, int i, int j, vector<vector<int> > &dp) {
if (dp[i][j] >= 0)
    return dp[i][j];
else if (i == A.size() - 1 && j == A[0].size() - 1)
    return dp[i][j] = A[i][j];
else if (i == A.size() - 1)
    return dp[i][j] = A[i][j] + minPath(A, i, j + 1, dp);
else if (j == A[0].size() - 1)
    return dp[i][j] = A[i][j] + minPath(A, i + 1, j, dp);
else
    return dp[i][j] = A[i][j] + min(minPath(A, i + 1, j, dp), minPath(A, i, j + 1, dp));
}

int Solution::minPathSum(vector<vector<int> > &A) {
if (A.size() == 0)
    return 0;

vector<vector<int> > dp(A.size(), vector<int>(A[0].size(), -1));
return minPath(A, 0, 0, dp);
}

此解决方案在提交过程中提供了一个标题。

过了一会儿，我查看了编辑代码，他们遵循了以下列表方法：

int minPathSum(vector<vector<int> > &grid) {
        if (grid.size() == 0) return 0;
        int m = grid.size(), n = grid[0].size();
        int minPath[m + 1][n + 1];
        for (int i = 0; i < m; i++) {
            minPath[i][0] = grid[i][0]; 
            if (i > 0) minPath[i][0] += minPath[i - 1][0];
            for (int j = 1; j < n; j++) {
                minPath[i][j] = grid[i][j] + minPath[i][j-1];
                if (i > 0) minPath[i][j] = min(minPath[i][j], grid[i][j] + minPath[i-1][j]);
            }
        }
    return minPath[m-1][n-1];
}

根据我的说法，两个代码的时间复杂度似乎相同，但我的代码似乎赋予了TLE。我到底哪里出问题了？

Answer 1

测试用例在网格中具有负数（尽管它们明确提到了非负数）。因此dp [i] [j]可以为负，但您的函数将永远不会考虑这些值。只是使用另一个向量来存储被访问的单元格，它就被接受了。

int minPath(vector<vector<int> > &A, int i, int j, vector<vector<int> > &dp,vector<vector<bool> > &vis)
{
    if (vis[i][j])
        return dp[i][j];
    vis[i][j] = 1;
    if (i == A.size() - 1 && j == A[0].size() - 1)
        return dp[i][j] = A[i][j];
    else if (i == A.size() - 1)
        return dp[i][j] = A[i][j] + minPath(A, i, j + 1, dp, vis);
    else if (j == A[0].size() - 1)
        return dp[i][j] = A[i][j] + minPath(A, i + 1, j, dp, vis);
    else
        return dp[i][j] = A[i][j] + min(minPath(A, i + 1, j, dp, vis), minPath(A, i, j + 1, dp, vis));
}

int Solution::minPathSum(vector<vector<int> > &A)
{
    if (A.size() == 0)
        return 0;

    vector<vector<int> > dp(A.size(), vector<int>(A[0].size(), -1));
    vector<vector<bool> > vis(A.size(), vector<bool>(A[0].size(), 0));
    return minPath(A, 0, 0, dp, vis);
}

记忆化解决方案提供TLE，而列表解决方案则不提供

1 个答案: