动态规划基础 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.确定dpi的含义：表示第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)

只维护dpi-2 dpi-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数组以及下标的含义

dpi： 爬到第i层楼梯，有dpi种方法

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

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

那么dpi就是 dpi - 1与dpi - 2之和！

所以dpi = dpi - 1 + dpi - 2 。

3.初始化dp数组

有人说：dp0 = 0；

也有人说：dp0 = 1（爬到第0层，也有一种方法，什么都不做也就是一种方法）

需要注意的是：题目中说了n是一个正整数，题目根本就没说n有为0的情况。

所以本题其实就不应该讨论dp0的初始化！
不考虑dp0如何初始化，只初始化dp1 = 1，dp2 = 2，然后从i = 3开始递推

4.确定遍历顺序

从递推公式dpi = dpi - 1 + dpi - 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;
    }
}

这就是斐波那契数列！

唯一的区别是，没有讨论dp0应该是什么，因为dp0在本题没有意义！

很多动规的题目其实都是当前状态依赖前两个，或者前三个状态，都可以做空间上的优化。