算法之动态规划（二）爬楼梯与抢房子_python 动态规划抢房子-CSDN博客

本文链接：https://blog.csdn.net/MustangJy/article/details/86619432

爬楼梯问题

假设你正在爬楼梯。需要爬n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶？

思路分析：从动态规划的角度，这个问题的关键在于找出能够推出结果的一个“状态”，每一步的“状态”都可以由之前的“状态”锁推出。由于每一步可以爬1或2个台阶，那么，我到达第n(n>2)阶，第一种可能就是我从第n-2阶爬了两层到的，第二种可能就是我从n-1阶爬了一层到的——也就是说，到达第n阶的方法可以拆分为到达第n-1阶的方法数加上到达第n-2阶的方法数，即

P(n) = P(n-1) + P(n-2)

从而就提取出了当前“状态”与之前“状态”的一个关系式，那么求解的过程就很简单了。

public class Solution {
    public int climbStairs(int n) {
        if (n == 1) {
            return 1;
        }
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

以上的时间复杂度和空间复杂度分别为O(n)、O(n)。

我们发现，由于当前的结果只与上一步和上两步的结果有关，那么我们便不需要保存更加之前的状态值了，从而可以减少空间复杂度：

public class Solution {
    public int climbStairs(int n) {
        if (n == 1) {
            return 1;
        }
        int first = 1;
        int second = 2;
        for (int i = 3; i <= n; i++) {
            int third = first + second;
            first = second;
            second = third;
        }
        return second;
    }
}

此时时间复杂度不变仍然为O(n)，而空间复杂度降低到了O(1)，因为只用到了三个变量。

抢房子问题

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

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

思路分析：可以把这个问题抽象成数学问题：在一个非负整数数组中拿取元素，要求不可以拿相邻的元素，求能取得元素的和的最大值。考虑当进行到第i个元素时，能够获得的钱数有两f种可能：第一就是我抢了第i-1个，于是不能再抢第i个了，设此时获得的钱是P(i-1);第二个可能就是我并没有抢第i-1个房子，所以我可以抢第i个房子，那么这个方法获得的钱最多为P(i-2) + m(i)，P(i-2)和m(i)分别为进行到第i-2个房子时能获得的最大钱数（注意，进行到第i-2个房子，不一定是抢了第i-2个房子）和第i个房中存在的钱数。以上的两种可能，我们要取较大的那个，即

P(i) = max(P(i-1),P(i-2)+m(i))

从而我们得到了当前状态与之前状态的一个关系式，从而进行求解。

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if(n==0) return 0;
        if(n==1) return nums[0];
        int[] best = new int[n];
        best[0]=nums[0];
        best[1]=Math.max(nums[0],nums[1]);
        for(int i=2;i<nums.length;i++)
        {
            if(nums[i]+best[i-2]>=best[i-1])
                best[i]=nums[i]+best[i-2];
            else
                best[i]=best[i-1];
        }
        return best[n-1];
    }
}

在循环迭代的时候，可以使用与爬楼梯解法类似的优化方案对空间复杂度进行优化。