LeetCode中的动态规划题目解答(2)

动态规划是一种非常重要的算法设计思想。历史上有很多著名的算法都是基于这种思想设计而来的,例如:Needleman–Wunsch算法、CYK算法、FFT算法、维特比算法等等。动态规划的核心思想有两个:首先是将一个大问题拆解为若干子问题;其次是将曾经计算过的结果储存起来以备多次使用。


我们在之前的博文中已经介绍了动态规划问题的一般“套路”。并采用这种套路解决了Unique Paths 和Unique Paths II这两个问题。本文将以LeetCode中的 #64题(Min Path Sum)为例,继续运用之前介绍的套路来设计动态规划算法。问题的描述如下:


这个问题基本属于之前讨论的Unique Paths 和Unique Paths II这两个问题的变种。根据之前一样的思路,我们首先还是写出递归求解的实现(非动规版):

class Solution {
public:
    
    int recursivePath(int x, int y, vector<vector<int>>& grid){
        
        if(x==0 && y==0)
            return grid[0][0];
        
        if(x==0)
            return recursivePath(x, y-1, grid)+grid[x][y];
        
        if(y==0)
            return recursivePath(x-1, y, grid)+grid[x][y];
        
        int min_value = recursivePath(x-1, y, grid)<recursivePath(x, y-1, grid)?
                        recursivePath(x-1, y, grid):recursivePath(x, y-1, grid);
       
        return min_value+grid[x][y];
        
    }
    
    int minPathSum(vector<vector<int>>& grid) {
        
        int m = grid.size();
        if(m==0) return 0;
        int n = grid[0].size();
        if(n==0) return 0;
        
        return recursivePath(m-1, n-1, grid);
    }
};

易见,上面的实现跟之前讨论的例题唯一不同的地方仅仅在于返回值的部分,我们在这里是求了一个min计算,所以理解起来应该没有障碍。但是,上面这个版本直接提交LeetCode,会显示超时!因为其中会存在大量的重复计算。为此,需要使用解决动态规划问题的套路中之第二个步骤:定义一个数组或矩阵来存储已经得到的结果。当再次需要使用它们时,直接查表,而不用重新计算。所以,最终的实现代码如下:

class Solution {
public:
    
    int ** matrix;
    
    int recursivePath(int x, int y, vector<vector<int>>& grid){
        
        if (matrix[x][y] != -1)
            return matrix[x][y];
        
        if(x==0)
        {
            matrix[x][y] = recursivePath(x, y-1, grid)+grid[x][y];
            return matrix[x][y];
        }
        
        if(y==0)
        {
            matrix[x][y] = recursivePath(x-1, y, grid)+grid[x][y];
            return matrix[x][y];
        }
        
        matrix[x][y] = (recursivePath(x-1, y, grid)<recursivePath(x, y-1, grid)?
                        recursivePath(x-1, y, grid):recursivePath(x, y-1, grid))+grid[x][y];
        
        return matrix[x][y];
        
    }
    
    int minPathSum(vector<vector<int>>& grid) {
        
        int m = grid.size();
        if(m==0) return 0;
        int n = grid[0].size();
        if(n==0) return 0;
        
        matrix = new int*[m];
        
        for(int i = 0; i < m; i++)
        {
            matrix[i] = new int[n];
            for(int j = 0; j < n; j++)
            {
                matrix[i][j] = -1;
            } 
        }
        
        matrix[0][0] = grid[0][0];
        
        return recursivePath(m-1, n-1, grid);
    }
};

上述代码可以满足题目要求。另外注意到,上述实现中我们略去了“内存回收”的部分代码。当然,由于为了演示“动态规划”的套路,这里所采用的是一种非常朴素的实现方式、并为对其进行优化,你还可以改进它,以实现更高的效率。


(本文完)


本博客中已经讨论过的LeetCode题目列表


发布了358 篇原创文章 · 获赞 4283 · 访问量 419万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 精致技术 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览