记忆的解决方案给出了TLE，而列表的解决方案则没有

Memoized solution gives TLE while tabulated solution does not

本文关键字：解决方案 列表 TLE 记忆      更新时间：2023-10-16

我正在尝试从面试中提出以下问题：

给定一个充满非负数数字的M x 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);
}

此解决方案在提交期间给出了一个TLE。

过了一会儿，我看了查看编辑代码，他们遵循了制表方法，如下所示：

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。我到底在哪里？

测试用例在网格中的数字负数(尽管它们已经明确提到了非阴性数字(。因此，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);
}
相关文章：