Leetcode T198 T55 动态规划方法对比-优快云博客

本文链接：https://blog.youkuaiyun.com/IRONFISHER/article/details/122049411

这几天在备考，对着《算法导论》复习，同时在leetcode上找了一些动态规划的题做。有一些感想。
题目描述：

打家劫舍
难度
中等

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 400

我的题解：

class Solution {
public:
    int rob2(int pos,vector<int>&nums ,vector<int>&hashtable){
        if (hashtable[pos]!=0)return hashtable[pos];
        if (nums.size()-1==pos)return nums[pos];
        if(nums.size()-1==pos+1)return max(nums[pos],nums[pos+1]);
        int num1;
        num1=max(nums[pos]+rob2(pos+2,nums,hashtable),rob2(pos+1,nums,hashtable));
        hashtable[pos]=num1;
        return num1;
    }
    //只能说带记忆化搜索的动态规划方法。。。。害不太给力啊
    int rob(vector<int>& nums) {
        vector<int>hashtable(nums.size(),0);
        if (nums.size()==1){return nums[0];}
        else if(nums.size()==2) {return max(nums[0],nums[1]);}
        else return rob2(0,nums,hashtable);
        }

这种记忆化搜索的方法利用了一个哈希表hashtable记录每一次遍历时候该结点的值，若本次已经完成计算，那么再一次就不会再计算了，最后增加了一点边界值条件的判断，本来应该是很合理的。但是这样的问题仍然出在时间复杂度不是O(n)。
因为在每一次递归调用rob2的时候，程序仍然会进入下一个堆栈，同时开始判断。还是容易stackoverflow.

动态规划的方法通常只要一次正序遍历就可以完成，不需要递归调用，后面的代码的确十分的漂亮。

    int rob(vector<int>& nums) {
        int money_now=0;int i=0;
        int money_pre=0;int money_pre_pre=0;
        for (i=0;i<nums.size();i++){
            money_now=max(money_pre_pre+nums[i],money_pre);
            money_pre_pre=money_pre;
            money_pre=money_now;
        }
        return money_pre;
    }

我本来大致也是这么想的，但是是从第一个结点开始，求的是该结点和后面的结点是否选择。但是这里是计算了该结点和前面的结点是否选择。因为前面的结点已经求解出来了，而且步长只有2.所以说只要money_pre,money_pre_pre即可。一个很简单的遍历方法就可以求解问题。

对于T55同样的道理。

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int can_reach=0;
        for (int i=0;i<nums.size();i++){
            if(i>can_reach)return false;
            can_reach=max(can_reach,i+nums[i]);
            if(can_reach>=nums.size()-1)return true;
        }
        return true;
    }
};

这里的关键点就在于i>can_reach的判断，同样一轮正序遍历，在can_reach=max(can_reach,i+nums[i])就可以判断出可以到达的最远结点的大小，如果当i当值大于can_reach，就说明这个结点到不了，就直接return false，也是一个很巧妙的方法。相比之下，自己的方法显得就不是很聪明。

class Solution {
public:
    bool canjump2(int num1,int num2,vector<int> nums,vector<bool>& hashtable){
        if(!hashtable[num1])return false;
        if ((num1+num2)>=nums.size()-1)return true;
        else {
            if (num2==0){
                hashtable[num1]=false;
                return false;
            }
            for (int i=1;i<=num2;i++){
                if(canjump2(num1+i,nums[num1+i],nums,hashtable))return true;    
            }
            hashtable[num1]=false;
            return false;
        }
    }
    bool canJump(vector<int>& nums) {
        vector<bool>hashtable(nums.size(),true);
        return canjump2(0,nums[0],nums,hashtable);
    }
};

同样是利用了hashtable储存遍历递归的方法，最后也是RunTimeError了。这里的问题就是在进行了太多无谓的递归查表开销，个人是这么理解的。