刷题学习—算法思想（动态规划上）

算法思想

动态规划

1.动态规划算法介绍

1. 动态规划(Dynamic Programming)算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法
2. 动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
3. 与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。 ( 即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解 )
4. 动态规划可以通过填表的方式来逐步推进，得到最优解

2.面试常考五大动态规划问题

2.1基础题目

2.2背包问题

2.3打家劫舍

2.4股票问题

2.5子序列问题

刷题参照：leetcode好题

3.五大方面剖析动态规划问题

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

注意：先做一些简单的问题巩固方法论，要先确定递推公式，然后在考虑初始化，因为⼀些情况是递推公式决定了dp数组要如何初始化

4.理解背包问题

4.1二维数组实现背包问题

	public static void main(String[] args) {
   
        int w = 3;//物品（行）
        int V = 4;//包的体积（列）

        int[] weight = {
   1,3,4};//物品重量数组
        int[] value = {
   15,20,30};//物品价值数组

        System.out.println(bag(w, V, weight, value));
    }

    public static int bag(int w,int v,int[] weight,int[] value){
   
        int[][] dp = new int[w][v + 1];//动态规划数组有物品三个，背包的状态5种，即V+1

        for(int i = 0;i<dp.length;i++){
   //根据表格，填充第一列为0
            dp[i][0] = 0;
        }

        for (int x = 1; x <= v; x++) {
   //根据表格，填充第一行为15
            dp[0][x] = 15;
        }

        //使用动态规划
        for (int i = 1; i < w; i++) {
   //遍历物品，物品一共3个，第一行已经被填充，也就是只剩两个物品填充最大价值
            for (int j = 1; j <= v; j++) {
   //遍历背包(当前的体积)，背包当前体积有01234这5种状态，第一列已经被填充，所以只讨论1234列
                if(weight[i]>j){
   //如果当前物品的体积大于当前背包的容量
                    dp[i][j] = dp[i-1][j];//则取上一行最大价值，因为这种情况属于没放东西，所以最大价值参照之前的不变
                }else {
   //如果当前物品的体积小于等于当前背包的容量
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);
                    //此时要看当前物品不放进去的最大价值高，还是放进去的高
                    //如果不放进去，就还是dp[i-1][j]
                    //如果放进去了，则要考虑不算当前物品且背包容量减去当前物品重量的最大价值，加上当前物品的单价
                }
            }
        }
		for(int[] row : dp){
   //推导dp数组(检查)
            System.out.println(Arrays.toString(row));
        }
        return dp[w-1][v];//填充完表格后，最大数在右下角，因为物品w有123个，而索引是012，则w-1
    }

结果：

4.2一维数组实现背包问题

	public static int bag2(int w,int v,int[] weight,int[] value){
   
        int[] dp = new int[v+1];//定义一维数组表示背包的容量，背包容量有5种状态，所以是v+1
        dp[0] = 0;//背包当前容量为0时，什么都不能放，所以最大价值肯定为0

        for (int i = 0; i < w; i++) {
   //遍历物品，分别用物品012向下遍历背包（当前的容量）
            for (int j = v; j >= weight[i]; j--) {
   //倒叙的原因如下，每次遍历要保证背包当前容量能接受（大于等于）当前物品
                dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);//直接找最大价值
            }
        }

        for(int i : dp){
   //推导dp数组(检查)
            System.out.print(i + " ");
        }

        System.out.println();
        return dp[v];
    }

结果：

5.完全背包

• 完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。
• 完全背包的物品是可以添加多次的，所以要从小到大去遍历
• 01背包中二维dp数组的两个for遍历的先后顺序可以颠倒，一维dp数组的两个for循环先后顺序一定是先遍历物品，再遍历背包容量。在完全背包中，对于一维dp数组来说，其实两个for循环嵌套顺序同样无所谓
• 先遍历背包再遍历物品：

for(int j = 0; j <= bagWeight; j++) {
    // 遍历背包容量
    for(int i = 0; i < weight.size(); i++) {
    // 遍历物品
        if (j - weight[i] >= 0) dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
    cout << endl;
}

———————————————————————————————————————————————————
以下是动态规划练习题：

6.斐波那契数

该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。

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

思路：

1. 确定dp数组中的含义：第i个数的斐波那契数值是dp[i]
2. 确定递推公式：dp[i] = dp[i - 1] + dp[i - 2];即第i个数的斐波那契数，是从它之前的两个和推出来的
3. dp数组初始化：题目中给了 dp[0] = 0; dp[1] = 1;
4. 确定遍历顺序：dp[i]是依赖 dp[i - 1] 和 dp[i - 2]，那么遍历的顺序一定是从前到后遍历的
5. 打印推导dp数组：n = 10时
   

7.爬楼梯

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

class Solution {
   
    public int climbStairs(int n) {
   
        if(n < 3)return n;
        int[] dp = new int[n + 1];
        dp[2] = 2;
        dp[1] = 1;
        for (int i = 3; i < dp.length; i++) {
   
            dp[i] = dp[i - 1] + dp[i - 2];
            System.out.print(dp[i] + " "