动态规划快速入门

时间 2019-11-12

标签动态规划快速入门繁體版

原文原文链接

更多内容，欢迎关注微信公众号：全菜工程师小辉。公众号回复关键词，领取免费学习资料。程序员

动态规划算法一直是面试手撕算法中比较有挑战的一种类型。不少的分配问题或者调度问题实际上均可能用动态规划进行解决。（固然，若是问题的规模较大，有时候会抽象模型使用动归来解决，有时候则能够经过不断迭代的几率算法解决查找次优解）面试

因此，动归很重要，至少算法思想很重要。算法

什么是动态规划？

经过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划经常适用于有重叠子问题和最优子结构性质的问题。 > 最优子结构：当问题的最优解包含了其子问题的最优解时，称该问题具备最优子结构性质。微信

> 重叠子问题：在用递归算法自顶向下解问题时，每次产生的子问题并不老是新问题，有些子问题被反复计算屡次。动态规划算法正是利用了这种子问题的重叠性质，对每个子问题只解一次，然后将其解保存在一个表格中，在之后尽量多地利用这些子问题的解。学习

不理解不用怕，结合后面题目来理解这些概念。这些概念彻底是已经会动归的人来总结出来的，因此先理解动归，而后再来看这些文绉绉的归纳。code

分治与动态规划

共同点：
两者都要求原问题具备最优子结构性质，都是将原问题分而治之，分解成若干个规模较小（小到很容易解决）的子问题。而后将子问题的解合并，造成原问题的解。递归

不一样点：ip

分治法将分解后的子问题当作相互独立的，经过用递归来作。
动态规划将分解后的子问题理解为相互间有联系，有重叠部分，须要记忆，一般用迭代来作。

动态规划的步骤

问题建模

根据问题，找到【最优子结构】。把原问题从大化小的第一步，找到比当前问题要小一号的最好的结果，而通常状况下当前问题能够由最优子结构进行表示。
肯定问题的【边界】。根据上述的最优子结构，一步一步从大化小，最终能够获得最小的，能够一眼看出答案的最优子结构，也就是边界。
经过上述两步，经过分析最优子结构与最终问题之间的关系，咱们能够获得【状态转移方程】。

问题求解的各个方法

暴力枚举：

全部的动态规划问题均可以经过多层嵌套循环遍历全部的可能，将符合条件的个数统计起来。只是时间复杂度是指数级的，因此不推荐。leetcode

递归：

递归的时间复杂度是由递归层数和最优子结构的个数决定的。
在爬阶梯问题，最少找零钱问题中，递归的时间复杂度和空间复杂度都比动归方法的差，可是在国王与金矿的问题中，不一样的数据规模，动归方法的时间复杂度和空间复杂度不必定比递归的要好。因此具体问题具体分析。

> 上面提到的三个问题是动态规划里很常见的题目，题目内容能够百度查看一下。篇幅缘由，本文后边只讲解前两道题get

备忘录算法：

在阶梯数N比较多的时候，递归算法的缺点就显露出来了：时间复杂度很高。若是画出递归图（像二叉树同样），会发现有不少不少重复的节点。然而传统的递归算法并不能识别节点是否是重复的，只要不到终止条件，它就会一直递归下去。
为了不上述状况，使递归算法可以不重复递归，就把已经获得的节点都存起来，下次再遇到的时候，直接用存起来的结果就好了。这就是备忘录算法。
备忘录算法的时间复杂度和空间复杂度都获得了简化。

动态规划算法：

上述的备忘录算法，尽管已经不错了，可是依然仍是从原问题，遍历获得全部的最小子问题，空间复杂度是O(N)。
为了再次缩小空间复杂度，咱们能够自底向上的构造递归问题，经过分析最优子结构与最终问题之间的关系，咱们能够获得【状态转移方程】。而后从最小的问题不断往上迭代，即便一直迭代到最大的原问题，也是只依赖于前面的几个最优子结构。这样，空间复杂度就大大简化。也就获得了动归算法算法。

例题

例1: Climbing Stairs(爬楼梯问题)
leetcode原题：你正在爬一个有n个台阶的楼梯，每次只能上1个或者2个台阶，那么到达顶端共有多少种不一样的方法？

创建模型：

最终问题F(N)：假设从0到达第N个台阶的方法共有F(N)个。
最优子结构F(N-1)，F(N-2)：到达N个台阶，有两种可能，第一种多是从第 N-1 个台阶上1个台阶到达终点，第二种多是从第 N-2 个台阶上2个台阶到达终点。
最优子结构与最终问题之间的关系：按照上述表达，那么能够概括出F(N) = F(N-1) + F(N-2) (n>=3)
边界:F(1) = 1,F(2) = 2

问题求解：

递归：

class Solution {
    int climbStairs(int n) {
        if (n &lt;= 2) {
            return n;
        } else {
            return climbStairs(n - 1) + climbStairs(n - 2);
        }
    }
}

> 递归的时间复杂度是由递归层数和最优子结构的个数决定的。这里的阶梯数是 N ，最优子结构个数是2。若是想象成一个二叉树，那么就能够认为是一个高度为N-1，节点个数接近2的N-1次方的树，所以此方法的时间复杂度能够近似的看做是O(2<sup>N</sup>) 。

备忘录算法：
这里咱们想到了把重复的参数存储起来，下次递归遇到时就直接返回该参数的结果，也就是备忘录算法了，最简单的备忘录就是哈希表。

class Solution {
    private Map<integer, integer> map = new HashMap&lt;&gt;();

    int climbStairs(int n) {
        if (n &lt;= 2) {
            return n;
        } else if (map.containsKey(n)) {
            return map.get(n);
        } else {
            int value = climbStairs(n - 1) + climbStairs(n - 2);
            map.put(n, value);
            return value;
        }
    }
}

动态规划：
以前都是自顶向下的求解，考虑一下自底向上的求解过程。从F(1)和F(2)边界条件求，可知F(3) = F(1)+F(2)。不断向上，可知F(N)只依赖于前两个状态F(N-1)和F(N-2)。因而咱们只须要保留前两个状态，就能够求得F(N)。相比于备忘录算法，咱们再一次简化了空间复杂度。

class Solution {
    int climbStairs(int n) {
        if (n &lt;= 2) {
            return n;
        }
        // 边界条件
        int a = 1;
        int b = 2;
        int result = 0;
        // 最优子结构与最终问题之间的关系
        for (int i = 3; i &lt;= n; i++) {
            result = a + b;
            a = b;
            b = result;
        }
        return result;
    }
}

> 空间复杂度O(1), 时间复杂度O(N)

例2: Making change using the fewest coins(最少找零钱问题)
Google面试题：假设你是一家自动售货机制造商的程序员。你的公司正设法在每一笔交易找零时都能提供最少数目的硬币以便工做能更加简单。已知硬币有四种（1美分，5美分，10美分，25美分）。假设一个顾客投了1美圆来购买37美分的物品，你用来找零的硬币的最小数量是多少？

创建模型：

最优子结构：回想找到最优子结构的方法，就是日后退一步，可以获得的最好的结果。这里有四个选择，1 + mincoins(63-1)，1 + mincoins(63-5)，1 + mincoins(63-10) 或者 1 + mincoins(63-25)，这四个选择能够认为是63的最优子结构。
状态转移方程：按照上述的最优子结构，mincoins(63)也就等于上述四个最优子结构的最小值。
边界: 当须要找零的面额正好等于手中单枚硬币的金额时，返回1便可。

问题求解：

递归：

class Solution {
    Set<integer> coinSet = new HashSet<integer>() {
        {
            add(1);
            add(5);
            add(10);
            add(25);
        }
    };

    int getFewestCoins(int n) {
        if (n &lt; 1) {
            return 0;
        }
        if (coinSet.contains(n)) {
            return 1;
        }
        int minCoins = n;
        int numCoins = Integer.MAX_VALUE;

        for (int coin : coinSet) {
            if (n &gt;= coin) {
                // 若是要计算的n小于单个硬币金额，则不能出如今状态转移方程中
                numCoins = 1 + getFewestCoins(n - coin);
            }
            // 更新最小值
            if (numCoins &lt; minCoins) {
                minCoins = numCoins;
            }
        }
        return minCoins;
    }
}

备忘录算法：
就是将递归里计算的中间变量都保存在一个哈希表，代码略。
动态规划：
自底向上，从找零数等于1开始往上迭代，参考最优子结构，记录下来最少硬币数。一直迭代到实际要求。

class Solution {
    Set<integer> coinSet = new HashSet<integer>() {
        {
            add(1);
            add(5);
            add(10);
            add(25);
        }
    };

    int getFewestCoins(int n) {
        int[] list = new int[n + 1];
        List<integer> subCal = new ArrayList&lt;&gt;();
        for (int i = 0; i &lt;= n; i++) {
            // 边界
            if (i &lt;= 1) {
                list[i] = i;
                continue;
            }
            for (int cent : coinSet) {
                if (i &gt;= cent) {
                    subCal.add(list[i - cent] + 1);
                }
            }
            list[i] = Collections.min(subCal);
            subCal.clear();
        }
        return list[n];
    }
}

更多内容，欢迎关注微信公众号：全菜工程师小辉。公众号回复关键词，领取免费学习资料。

</integer></integer></integer></integer></integer></integer,>