Leetcode - Dynamic Progr - 64. Minimum Path Sum（BFS+DP）

最新推荐文章于 2023-05-09 21:28:02 发布

原创最新推荐文章于 2023-05-09 21:28:02 发布 · 480 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#dp #leetcode #动态规划 #bfs

leetcode 专栏收录该内容

31 篇文章

订阅专栏

本文探讨了一个经典的算法问题——寻找一个矩阵中从左上角到右下角的最小路径和，仅允许向右或向下移动。提供了两种解决方案：一种是广度优先搜索（BFS），但该方法超出了时间限制；另一种是动态规划（DP）方法，该方法成功通过了测试。

1. Problem Description

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

给出一个m*n的矩阵，每个矩阵里有一个值，求从左上角走到右下角经过和最小的路径，输出最小和。

Note：你只可以走右边或者下边。

2. My solution1 BFS（TLE）

先用BFS写的，每次走到一个节点都要把其邻近节点扫一下，复杂度是节点数*2，也就是O[n*m*2]。

结果TLE了……

class Solution
{
private :
    int dir[2][2];
    int row;
    int col;
public:
 
    typedef struct
    {
        int i;
        int j;
        int val;
    } Node;
    bool judge(Node tmp)
    {
        if(tmp.i>=0&&tmp.i<row&&tmp.j>=0&&tmp.j<col)
            return true;
        else
            return false;
    }
    int BFS(vector<vector<int> >& grid)
    {
        queue<Node>que;
        Node q0= {0,0,grid[0][0]};
        que.push(q0);
        int ans=(1<<30)-1;
        while(!que.empty())
        {
            Node ff=que.front();
            que.pop();
 
            if(ff.i==row-1&&ff.j==col-1)
            {
                if(ff.val<ans)
                    ans=ff.val;
                continue;
            }
            for(int i=0; i<2; i++)
            {
                Node tmp;
                int _x=dir[i][0];
                int _y=dir[i][1];
                tmp.i=ff.i+_x;
                tmp.j=ff.j+_y;
                if(judge(tmp))
                {
                    tmp.val=ff.val+grid[tmp.i][tmp.j];
                    que.push(tmp);
                }
            }
        }
        return ans;
    }
    int minPathSum(vector<vector<int> >& grid)
    {
        dir[0][0]= 1,dir[0][1]= 0;
        dir[1][0]= 0,dir[1][1]= 1;
        row=grid.size();
 
        if(row==0)
            return 0;
        col=grid[0].size();
        return BFS(grid);
    }
};

3. My solution2 Dp（AC）

果然还是要DP啊，这个题的DP很好搞，就是dp[i][j]=min(dp[i-1][j],dp[i][j-1]);

因为只能向下或者向右走，O[m*n]的复杂度。

class Solution
{
private:
    int dir[2][2];
    int row;
    int col;
    vector<vector<int> >dp;
public:
    bool judge(int i,int j)
    {
        if(i>=0&&i<row&&j>=0&&j<col)
            return true;
        else
            return false;
    }
    int DynamicProgramming(vector<vector<int> >& grid)
    {
        for(int i=0; i<row; i++)
        {
            for(int j=0; j<col; j++)
            {
                if(judge(i-1,j)&&judge(i,j-1))
                    dp[i][j]=min(dp[i-1][j],dp[i][j-1]);
               else
               {
                  if(judge(i-1,j))
                     dp[i][j]=dp[i-1][j];
                  else if(judge(i,j-1))
                     dp[i][j]=dp[i][j-1];
               }
                dp[i][j]+=grid[i][j];
            }
        }
 
        return dp[row-1][col-1];
    }
    int minPathSum(vector<vector<int> >& grid)
    {
        row=grid.size();
        if(row==0)
            return 0;
        col=grid[0].size();
        for(int i=0; i<row; i++)
        {
            vector<int>tmp;
            dp.push_back(tmp);
            for(int j=0; j<col; j++)
            {
                dp[i].push_back(0);
            }
        }
        return  DynamicProgramming(grid);
    }
};