算法之动态规划

动态规划&递归

摘自网上的一段对动态规划的定义：

动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。动态规划程序设计是对解最优化问题的一种途径、一种方法，而不是一种特殊算法。

遇题分析：

• 一般对于求最优解的，都可以想到动态规划去解决
• 很多问题既可以使用自顶向下的递归去解，也可以使用自底向上的动态规划去解决

leetcode的一些题目：

leetcode 70. 爬楼梯问题，描述如下：

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？注意：给定 n 是一个正整数。示例：输入2 返回2，有2种方法； 输入3 返回3，有3种方法。

这道题思路很多，分析如下：

• 思路一：暴力递归去解决，有n个阶梯，每次是1个台阶或者2个台阶，那么n逐个去减1、减2，只要最终n为0了就是符合要求的，不为0而为-1是不符合要求的，不纳入记录。（为-1的情况，是只剩下最后一个台阶了，还跨两步） 代码如下：

    int count = 0;
    public int climbStairs(int n) {
        dfs(n);
        return count;
    }
    public void dfs(int n) {
        if (n < 0) {
            return;
        }
        if (n == 0) {
            count++;
            return;
        }
        dfs(n - 1);
        dfs(n - 2);
    }

备注：这种解法太耗时了，时间复杂度太高。n=44时，就明显感觉很慢了，要3s多的样子

• 思路二：可以想象一下，当有n个阶梯的时候，可以先跨上一个台阶也就是剩下n-1个阶梯问题，有f(n-1)种方法；也可以先跨上两个台阶也就是剩下n-2个阶梯问题，有f(n-2)种方法。只有这两种情况，所以f(n) = f(n-1)+f(n-2)，也就是斐波那契数列问题了。自顶向下递归，代码如下：

 public int f(int n) {
       if (n <= 2) return n;
        return f(n-1) + f(n - 2);
    }

这种写法跟第一种差不多，同样时间复杂度很高，太多项被重复计算，可以使用备忘录的方式避免重复计算，代码如下：

   Map<Integer, Integer> hashMap = new HashMap<>();
    public int f(int n) {
        if (n <= 2) return n;
        if (!hashMap.containsKey(n - 1)) {
            hashMap.put(n - 1, f(n - 1));
        }
        if (!hashMap.containsKey(n - 2)) {
            hashMap.put(n - 2, f(n - 2));
        }
        return hashMap.get(n - 1) + hashMap.get(n - 2);
    }

借助Map将已经计算过的数据，保存起来，下次直接拿过来用

• 思路三：看到这种关系式，可以想到用动态规划了。与思路二的方法很相似，可以采用自底向上，使用dp表来记录

 public int fun(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }

这里效率很快了，空间换时间。 但是可以考虑进一步优化，明明只跟前两个数据有关系，为啥要开辟这么长的数组呢。代码如下：

public int fun(int n) {
        if (n <= 2) return n;
        int beforeLast = 1;
        int last = 2;
        int current = -1;
        for (int i = 3; i <= n; i++) {
           current = beforeLast + last;
           beforeLast = last;
           last = current;
        }
        return current;
    }

使用滚动数组的方式，逐个更新beforeLast（上上一个），last（上一个）的值，从而获取当前结果。到此为止，该题就结束了～

leetcode 198. 打家劫舍，描述如下：

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

分析一下：

• 计算一夜之内能够偷窃到的最高金额，求最值，可以想到动态规划去解
• 其实就是01背包问题，路过第i个房间选择偷还是不偷？偷的话，i-1就不能选了，就是f（i-2）+ currentValue；不偷的话，还是上个金额数目 f（i-1）。这样瞬间就明朗了，f（i）不就是这两者的最大值嘛！即 f(i) = Max(f(i-1), f(i-2) + currentValue)

动态规划解法，代码如下：

    public int rob(int[] nums) {
        if (nums.length == 0) return 0;
        if (nums.length == 1) return nums[0];
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for (int i = 2; i < nums.length; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[dp.length - 1];
    }

这样结果就出来了，但是可以对空间进行优化一下，跟爬楼梯问题解法思路一样。 除此之外还可以用递归的方式，自顶向下求解：

递归自顶向下求解，代码如下：

    public int rob(int[] nums) {
        return dfs(nums, nums.length - 1);
    }
    public int dfs(int[] nums, int index) {
        if (nums.length == 0) return 0;
        if (index == 0) return nums[0];
        if (index == 1) return Math.max(nums[0], nums[1]);
        return Math.max(dfs(nums, index - 1), dfs(nums, index - 2) + nums[index]);
    }
    //===============分界线===============//
    // 暴力递归，时间复杂太高，使用备忘录的方式优化：
    
    Map<Integer, Integer> map = new HashMap<>();
    public int dfs(int[] nums, int index) {
        if (nums.length == 0) return 0;
        if (index == 0) return nums[0];
        if (index == 1) return Math.max(nums[0], nums[1]);
        if (!map.containsKey(index - 1)) {
            map.put(index - 1, dfs(nums, index - 1));
        }
        if (!map.containsKey(index - 2)) {
            map.put(index - 2, dfs(nums, index - 2));
        }
        return Math.max(map.get(index - 1), map.get(index - 2)+ nums[index]);
    }