动态规划算法

MysteryJack

简介

动态规划(英语:Dynamic programming,简称 DP)是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的,通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。

斐波那契数列

学习动态规划之前,我们先了解一下斐波那契数列是什么。

斐波那契数列又译为费波拿契数斐波那契数列费氏数列黄金分割数列

用文字来说,就是斐波那契数列由0和1开始,之后的斐波那契数就是由之前的两数相加而得出。首几个斐波那契数是:

0,1,1,2,3,5,8,13,21,34,55,89 ...
fib(n) = fib(n - 1) + fib(n - 2);

从中我们可以发现从第三个数开始的值是前两个值的和。

假设我在如下图中得到fib(7)的斐波那契数列,我们可以知道想获得7的斐波那契数列的话7就要获取fib(6) + fib(5) 的值,但fib(6) 又需要获取 fib(5) + fib(4)... 我们会发现有很多重复的计算,导致时间复杂度为O(2n)

我们发现左侧已经进行过fib(5)的计算,右侧又有一个fib(5),其实我们完全可以在左侧计算fib(5)的时候将值保存起来,这样我们在右侧直接使用这个值就可以了。

如果我们想算fib(6)的话,首先我们知道1 和 2 都等于1,依次相加得出如下:

数组        1 2 3 4 5 6
斐波那契数   1 1 2 3 5 8

我们从递归改为递推的话,时间复杂度就会变成O(n)

我们先用两个经典的问题来引出动态规划算法。

最优打工问题

如上图,我们一共有八个任务可以进行打工,对应的红色数字就是打工所赚取的钱,长度就是时间,在同一时间只能做一个任务,我们如何赚取最多的钱?

其实在面临一个选择的时候,只有两个选择,选 or 不选

我们需要找到一个最优解,如果选择opt(8)我们看看有什么结果。

图中我们可以看出来,我们选择第8号任务的话,我们可以赚取4块钱,但是我们就无法再做6、7号任务了,我们只考虑时间紧挨着的任务的最优解,我们就可以在前5个中再选取最优解即可。

如果我们不选,很简单,只要从前7个中获取最优解opt(7)。

然后我们就要在选和不选中选择赚钱最多的那个就ok了。

再举个例子,如果要做第7号任务,4、5、6、8都不能做,我们可以看到紧挨着的只有3号任务所以代码就是: prev(7) = 3

我们看一下prev函数是怎么计算出来的。

如果我们要做1号任务,由于我们只考虑前面的所以如果要做1号任务的话,我们前面就没有任务可以做,所以就是0,以此类推我直接把表格列出来

| i | prev(i) |
| --- | --- |
| 1 | 0 |
| 2 | 0 |
| 3 | 0 |
| 4 | 1 |
| 5 | 0 |
| 6 | 2 |
| 7 | 3 |
| 8 | 5 |

展开的树图如下:

我们在图中发现出现了我们之前所说的重叠的问题。

我们需要做的就是保存已经展开过的值,减少不必要的多次展开的问题,通过数组来保存已经有过的值。

| 任务编号 | 之前可做任务编号 | 当前任务最大收益 | 做 | 不做 | 所选任务 |
| --- | --- | --- | --- | --- | --- |
| i | prev(i) | opt(i) | opt(i) + opt(prev(i)) | opt(i-1) |[i] |
| 1 | 0 | 5 | 5 | 0 | [1] |
| 2 | 0 | 5 | 1 | 5 | [1] |
| 3 | 0 | 8 | 8 | 5 | [3] |
| 4 | 1 | 9 | 9 | 8 | [1,4] |
| 5 | 0 | 9 | 6 | 9 | [1,4] |
| 6 | 2 | 9 | 4 | 9 | [1,4] |
| 7 | 3 | 10 | 10 | 9 | [3,7] |
| 8 | 5 | 13 | 13 | 10 | [1,4,8] |

这样我们就可以很容易的到最大收益的任务编号。

背包问题

题目:现在有四个物品,背包总容量为8,背包最多能装下价值为多少的物品?
物品编号1234
物品体积2345
物品价值3456

我们用一个表格来展示我们的背包数据。

**我们第一行表示背包容量,第一列表示物品的编号。**

每个格子表示在当前背包容量的情况下,考虑前n个物品的最佳组合,所能装入的最大价值为多少,就填入方框中。

0123456789
0
1
2
3
4

首先我们开始填入背包编号和容量,第一行全部是0,因为第一行表示前0个物品的最佳组合,也就是没有物品,所以我们不需要管背包容量有多么大,我们没有物品,所以都是0。

第一列也全部是0,因为我们对应的背包容量是0,所以不管有多少物品,我们没有容量,所以都是0。

012345678
0000000000
10
20
30
40

我们继续往右填,物品编号为1,背包容量为1,我们考虑前1个物品在容量为1的情况下,所能装入的最大价值为多少。

在每次装入之前我们需要考虑当前物品是否能装入背包

通过我们的已知条件,我们知道物品编号为1的物品它的体积为2。他比我们的背包容量还要大,所以我们只有一个选择,就是不装入1号物品。所以我们填入 0 。

012345678
0000000000
100
20
30
40

我们继续往右填,物品编号为1,背包容量为2,我们的物品体积为2,现在我们就面临两个选择,装?or 不装?

我们一步步分析,如果我们选择不装,那我们就和前0号物品所对应最大价值是一样的,也就是 0 。

如果我们选择装入1号物品,物品编号为1,背包容量为2,物品的体积也是2,物品的价值为3。我们装入后背包容量 2-2=0,这时候我们的价值为3 。

由此我们可以知道,装 = 价值为3 or 不装 = 价值为 0,这时候我们选取最大的那个,也就是装。我们填入值为3。(后续填法一致,就不过多赘述)

012345678
0000000000
1003333333
2003
30
40

我们继续填,现在来到物品编号为2,背包容量为3这个位置,我们发现物品编号为2的体积为3,装入后背包容量 3-3=0,这时候我们的价值为4 。所以我们现在又来到了 装 or 不装 问题,装的话就是4,不装的话就选取前n个物品在此背包的最大价值也就是3,4>3所以我们选择装入。

当我们按照此方法以此类推我们可以得到如下表格:

012345678
0000000000
1003333333
2003447777
3003457899
40034578910

总结:

  1. 如果装不下当前物品,那么前n个物品的最佳组合和前n-1个物品的最佳组合是一样的。
  2. 如果装得下当前物品则有两种情况:

    假设1: 装入当前物品,在给当前物品预留了相应空间的情况下,前n-1个物品的最佳组合加上当前物品的价值就是总价值。

    假设2:不装当前物品,那么前n个物品的最佳价值组合,和前n-1个物品的最佳价值组合是一样的。

    然后我们选取假设1和假设2中较大的价值,为当前组合的最大价值。

背包问题回溯

问题进阶:在背包内总价值最大的情况下,背包内装了哪些物品呢?

我们知道背包内最大总价值为10,我们需要查看当前物品编号为4是否放入了背包,进行n-1我们发现物品编号为3 容量为8时价值为9,9 != 10 由此可以知道物品编号4的确放入了背包,物品编号4对应的体积为5,我们找到n-1也就是物品编号为3且背包容量8-5=3的位置,如下图:

首先需要知道当前物品有没有放进去,进行n-1发现最大价值是一样的,所以可以知道当前物品没有放进去,进行往上移动,来到背包2的位置,我们还是需要知道当前物品有没有放进去,进行n-1发现最大价值为3 当前最大价值为4,所以知道物品2放入了背包。

然后我们进行当前容量减去物品2的容量就是3-3=0,找到物品编号为1,背包容量为0的位置进行判断。而背包容量为0肯定没有放任何东西,所以继续回溯就到了物品编号为0,背包容量为0,回溯结束。

题目练习

现在有这么一道题 数组如下:

arr[1,2,4,1,7,8,3]

我们在选择某个数的时候不能选择相邻的两个数,选择1就不能选择2,选择7就不能选择1和8,如何得出选择的是最大的和呢?

假设我们选择下标为6的,arr[6]会是怎样的呢?我把流程画出来。

这个时候很明显,我们又遇见了之前说的重叠问题。

直接上代码

第一种递归写法(不推荐)

    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 4, 1, 7, 8, 3};
        System.out.println(resOpt(arr, 6));
    }

    private static int resOpt(int[] arr, int i) {
        if (i == 0) {
            return arr[0];
        } else if (i == 1) {
            return Math.max(arr[1], arr[0]);
        } else {
            int case1 = resOpt(arr, i - 2) + arr[i];
            int case2 = resOpt(arr, i - 1);
            return Math.max(case1, case2);
        }
    }
结果为:15

但是这种写法有个很严重的问题,就是我们没有考虑重叠的问题!效率非常低,时间复杂度为O(2n)

第二种:动态规划

    public static void main(String[] args) {
        int[] arr = new int[]{1,2,4,1,7,8,3};
        System.out.println(dpOpt(arr));
    }

    private static int dpOpt(int[] arr) {
        int[] opt = new int[arr.length];
        opt[0] = arr[0];
        opt[1] = Math.max(arr[1], arr[0]);
        for (int i = 2; i < arr.length; i++) {
            int case1 = opt[i - 2] + arr[i];
            int case2 = opt[i - 1];
            opt[i] = Math.max(case1, case2);
        }
        return opt[opt.length - 1];
    }

题目练习

给定一个整数数组 arr 和一个目标值 target,请是否有一组数字加起来等于target,找到返回true,未找到返回false。

给定 arr = [3,34,4,12,5,2], target = 9

因为 nums[2] + nums[5] = 4 + 5 = 9
所以返回 true

如果我们先选择了 arr[5],我们还是面临两种情况,选 or 不选。

选择了arr[5] 也就是之前要有数组加起来是7,7+2=9 , 如果不选,也就是arr[4]之前要等于9。

具体还是和背包问题一样,填入表格即可。最终获取最右下角的值,就是是否有匹配到的结果。

    public static void main(String[] args) {
        int[] arr = {3, 34, 4, 12, 5, 2};
        System.out.println(dpSubSet(arr, 9));
    }

    public static boolean dpSubSet(int[] arr, int target) {
        boolean[][] dp = new boolean[arr.length + 1][target + 1];
        for (int k = 1; k <= target; k++) {
            //为第一行赋初值
            dp[0][k] = false;
        }
        for (int k = 1; k <= arr.length; k++) {
            //为第一列赋初值
            dp[k][0] = true;
        }
        dp[0][0] = true;

        for (int i = 1; i <= arr.length; i++) {
            for (int j = 1; j <= target; j++) {
                if (arr[i - 1] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - arr[i - 1]];
                }
            }
        }
        return dp[arr.length][target];
    }
结果:true
阅读 373

codeing.....

552 声望
304 粉丝
0 条评论
你知道吗?

codeing.....

552 声望
304 粉丝
宣传栏