动态规划基础 18Day

动态规划基础

类型

1. 基础题
2. 背包问题
3. 打家劫舍
4. 股票问题
5. 子序列

方法论：五部曲

1. dp数组以及下标的含义
2. 推导递推公式
3. dp数组初始化
4. 确定遍历顺序
5. 打印dp数组 （打印出来看看是不是按照递推公式逐步求得的）

斐波那契数

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。

0 1 1 2 3 5 8

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。

1.确定dp[i]的含义：表示第i个斐波那契数的值；
2.递推公式：F(n) = F(n -1) + F(n - 2)；
3.dp数组的初始化：F(0) = 1,F(2) = 1;
4.确定遍历顺序：从前先后；
5.打印dp数组debug；

维护dp数组

class Solution {
    public int fib(int n) {
         if (n <= 1) return n;//默认大于0， 此时返回两种情况：0 ，1
        int dp[] = new int[n + 1];//这里是n+1：求F(2): 0 ,1 ,2 ;F(n):F(0)...F(n)就有n+1
        dp[0] = 0; dp[1] = 1;
        for(int i = 2; i <= n ;i ++){//从2开始，到n
            dp[i] = dp[i - 2] + dp[i-1];
        }
        return dp[n];
    }
}

• 时间复杂度：O(n)
• 空间复杂度：O(n)

只维护dp[i-2] dp[i-1]

F(n)只和前两项有关，所以只需要记录前两项的值就行

class Solution {
    public int fib(int n) {
         if (n <= 1) return n;//默认大于0， 此时返回两种情况：0 ，1
        int a = 0,b = 1,c =0;
        for(int i = 2; i <= n ;i ++){//从2开始，到n
            c = a + b;//
            a = b;//更新 i-2
            b = c;//更新 i-1
        }
        return c;
    }
}

• 时间复杂度：O(n)
• 空间复杂度：O(n)

递归解法

class Solution {
    public int fib(int n) {
        // if(n == 0) return 0;
        // if(n == 1) return 1;
         if (n <= 1) return n;//默认大于0， 此时返回两种情况：0 ，1
        return fib(n - 1) + fib(n - 2);//递归解法
    }
}

• 时间复杂度：O(2^n)
• 空间复杂度：O(n)

爬楼梯

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

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

注意：1 <= n <= 45

思路：F(0) = 0; F(1) = 1; F(2) = 2; F(3) = 3; F(4) = 5;
1.确定dp数组以及下标的含义
dp[i]： 爬到第i层楼梯，有dp[i]种方法

2.确定递推公式
根据最后一步是1，还是2个台阶。从后向前推断。

首先是dp[i - 1]，上i-1层楼梯，有dp[i - 1]种方法，那么再一步跳一个台阶不就是dp[i]了么。
还有就是dp[i - 2]，上i-2层楼梯，有dp[i - 2]种方法，那么再一步跳两个台阶不就是dp[i]了么。

那么dp[i]就是 dp[i - 1]与dp[i - 2]之和！
所以dp[i] = dp[i - 1] + dp[i - 2] 。

3.初始化dp数组
有人说：dp[0] = 0；
也有人说：dp[0] = 1（爬到第0层，也有一种方法，什么都不做也就是一种方法）
需要注意的是：题目中说了n是一个正整数，题目根本就没说n有为0的情况。
所以本题其实就不应该讨论dp[0]的初始化！
不考虑dp[0]如何初始化，只初始化dp[1] = 1，dp[2] = 2，然后从i = 3开始递推

4.确定遍历顺序
从递推公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，遍历顺序一定是从前向后遍历的

//维护dp数组
class Solution {
    public int climbStairs(int n) {
        if(n < 3) return n;
        //虽然没有对dp[0]初始化，还是需要n+1，因为数组的索引是0开始的，到n之间有n+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];
    }
}

//压缩版
class Solution {
    public int climbStairs(int n) {
        if(n < 3) return n;
        int a = 1, b = 2, c = 0;
        for(int i = 3;i <= n;i++){
            c = a + b;
            a = b;//更新i-2
            b = c;//更新i-1
        }
        return c;
    }
}

这就是斐波那契数列！
唯一的区别是，没有讨论dp[0]应该是什么，因为dp[0]在本题没有意义！
很多动规的题目其实都是当前状态依赖前两个，或者前三个状态，都可以做空间上的优化。