动态规划快速入门

jiezi

5 年前

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

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

所以，动归很重要，至少算法思想很重要。

通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。

最优子结构：当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。

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

不理解不用怕，结合后面题目来理解这些概念。这些概念完全是已经会动归的人来总结出来的，所以先理解动归，然后再来看这些文绉绉的概括。

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

不同点：

分治法将分解后的子问题看成相互独立的，通过用递归来做。
动态规划将分解后的子问题理解为相互间有联系，有重叠部分，需要记忆，通常用迭代来做。

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

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

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

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

在阶梯数 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 <= 2) {return n;} else {return climbStairs(n - 1) + climbStairs(n - 2);
        }
    }
}

递归的时间复杂度是由递归层数和最优子结构的个数决定的。这里的阶梯数是 N，最优子结构个数是 2。如果想象成一个二叉树，那么就可以认为是一个高度为 N -1，节点个数接近 2 的 N - 1 次方的树，因此此方法的时间复杂度可以近似的看作是 O(2^N)。

备忘录算法：

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

class Solution {private Map<Integer, Integer> map = new HashMap<>();

    int climbStairs(int n) {if (n <= 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 <= 2) {return n;}
        // 边界条件
        int a = 1;
        int b = 2;
        int result = 0;
        // 最优子结构与最终问题之间的关系
        for (int i = 3; i <= 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 < 1) {return 0;}
        if (coinSet.contains(n)) {return 1;}
        int minCoins = n;
        int numCoins = Integer.MAX_VALUE;

        for (int coin : coinSet) {if (n >= coin) {
                // 如果要计算的 n 小于单个硬币金额，则不能出现在状态转移方程中
                numCoins = 1 + getFewestCoins(n - coin);
            }
            // 更新最小值
            if (numCoins < 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<>();
        for (int i = 0; i <= n; i++) {
            // 边界
            if (i <= 1) {list[i] = i;
                continue;
            }
            for (int cent : coinSet) {if (i >= cent) {subCal.add(list[i - cent] + 1);
                }
            }
            list[i] = Collections.min(subCal);
            subCal.clear();}
        return list[n];
    }
}

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

动态规划快速入门

什么是动态规划？

分治与动态规划

动态规划的步骤

问题建模

问题求解的各个方法

暴力枚举：

递归：

备忘录算法：

动态规划算法：

例题