Lintcode-烦人的机器人🤖️

Lintcode:785. 最大权值和路径

问题描述:

有一个机器人位于一个 m × n 个网格的右上角。机器人每一时刻只能向下或者向左移动一步。机器人试图达到网格的左下角。每个网格上有一个数字权值,机器人希望它走到左下角的路径权值和最大。问这个最大路径权值和是多少?
《Lintcode-烦人的机器人🤖️》 屏幕快照 2018-02-04 下午7.39.34.png

问题分析:

拿到这道题目,首先想到的是“暴力破解”,也就是枚举。因为这个问题可以分解为一个小问题,如下图所示:

《Lintcode-烦人的机器人🤖️》 屏幕快照 2018-02-04 下午7.52.05.png

当🤖️在右上角(绿色叉叉标志的地方)时,他可以有两种选择:一种是往左走,走到红线标出的区域;一种是往下走,走到蓝线标出的区域。到底往那边走,就是需要考察哪一条路径返回的值大。

我们假定走到红色区域,即现在🤖️在4这个点上,这时候🤖️要做的事情就像他在最开始的地方(绿色叉叉标志的地方)一样,面临着两个选择。

通过以上的分析,我们可以大概得出,这个问题,可以用
递归的方法解决。就是原问题可以分解为规模小一点的子问题。

于是,我就哐哧哐哧地写了下面这段代码:

示例代码:

class Solution {
public:
    /**
    * @param nums: the n x m grid
    * @return: the maximum weighted sum
    */
    int dfs(vector<vector<int>> &nums, int row, int col) {
        int end_row = nums.size() - 1;
        int end_col = 0;

        //end
        if (row == end_row && col == end_col) {
            return nums[row][col];
        }

        //到了最下面的一行
        if (row == end_row) {
            int ret = 0;
            for (int i = 0; i <= col; i++) {
                ret += nums[row][I];
            }
            return ret;
        }

        //到了最左边的一列
        if (col == end_col) {
            int ret = 0;
            for (int i = row; i <= end_row; i++) {
                ret += nums[i][0];
            }
            return ret;
        }

        //进入下一波递归
        return   max(nums[row][col]+ dfs(nums, row + 1, col), nums[row][col]+ dfs(nums, row, col - 1) );
    }


    int maxWeight(vector<vector<int>> &nums) {
        // write your code here
        int begin_row = 0;
        int begin_col = nums[0].size() - 1;
        return dfs(nums, begin_row, begin_col);
    }
};

但是提交运行的时候,没有通过,原因是:

《Lintcode-烦人的机器人🤖️》 image.png

这说明上面的采用
递归这种暴力方法是行不通的。于是有良人为我指点迷津说:

你去看看动态规划吧,会有意想不到的事情哦~

动态规划

  • 本质:递归
  • 原问题(N)->子问题(N-1)->原问题(N)
  • 最优子结构

• 子问题最优决策可导出原问题最优决策
• 无后效性

  • 重叠子问题

• 去冗余
• 空间换时间(注意分析时空复杂度)

基本步骤
四个步骤
  • 设计暴力算法,找到冗余
  • 设计并存储状态(一维,二维,三维数组,甚至用Map)
  • 递归式(状态转移方程)
  • 自底向上计算最优解(编程方式)

根据上面说的四个步骤,我们现在走到了第一步,考虑一下为什么我们的代码不能pass,就是那一段代码存在太多的冗余。就是说,我们每一次计算一个子问题的最优解,都要计算一遍某些位置的最优子结构,这个过程每次被反复地计算,但是却没有保存,所以下一次计算的时候又需要再算一遍。这样是很消耗计算机资源的。所以,正如第二步说的,需要设计一个存储状态的数据结构,来记录每一次算出来的子问题的最优解,这样在下一次计算的时候就可以直接拿来用了。
针对我们这个问题,我们设计一个和表格一样大的二维矩阵用来保存结果。

vector<vector<int>> table;
         //初始化
         for(int i=0;i<rows;i++){
             vector<int> r;
             for(int j=0;j<cols;j++){
                r.push_back(-1);
             }
             table.push_back(r);
         }

这个table初始化为-1。table[m][n]表示的是,🤖️在第m行第n列到终点的最长路径。
其实有了这个存储结构,上面的代码只要稍微改动一下,就可以pass了。

if(table[row][col]>0){
            return table[row][col];
         }
            //end
            if (row == end_row && col == end_col) {
                return table[row][col]=nums[row][col];
            }
    
            //到了最下面的一行
            if (row == end_row) {
                return table[row][col]=nums[row][col]+ dfs(nums,table, row, col - 1);
            }

            //到了最左边的一列
            if (col == end_col) {
                return table[row][col]=nums[row][col]+ dfs(nums,table, row + 1, col);
            }
    
            //进入下一波递归
            table[row][col]=max(nums[row][col]+ dfs(nums,table, row + 1, col), nums[row][col]+ dfs(nums,table, row, col - 1) );
    
    return table[row][col];

可以看出,与暴力破解的方法不同之处就是在于每次求解的过程都把中间过程保存下来。所以这是一个用空间换时间的方案。
而动态规划的想法是,自底向上,有点像递推的感觉。这部分的代码还没有写。但是思路就是从小到大的想法。后续会补充这一部分的代码。
完整代码请戳我的GitHub

    原文作者:爱秋刀鱼的猫
    原文地址: https://www.jianshu.com/p/f5f67c23a766
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注