JAVA算法-动态规划

一、什么是动态规划？

动态规划其实是运筹学的一种最优化方法，只不过在计算机问题上应用比较多，比如说让你求最长递增子序列呀，最小编辑距离呀等等。

既然是要求最值，核心问题是什么呢？求解动态规划的核心问题是穷举。因为要求最值，肯定要把所有可行的答案穷举出来，然后在其中找最值呗。

二、动态规划有什么技巧？

动态规划就是穷举就完事了？那肯定不是。动态规划的问题有些特别，他们会出现重叠子问题，如果暴力穷举，效率会极其低下！所以需要「备忘录」来优化穷举过程，即计算过的数据不需要再次计算。

三、举例
        leetcode题509、斐波那契数列 和题322、零钱兑换 都是动态规划的经典题型

1> 斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fibonacci-number
 

1、思路一：暴力解题：题中已经给予了方程式，只需要将方程式带入代码中即可。

@Test
public void testfib(){
   int n= 30;
   System.out.println(fib(n));
}

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

这样写代码虽然简洁易懂，但是十分低效，低效在哪里？求fib(30)需要求fib(29),fib(28),求fib(29)，需要fib(28),fib(27),由此递推，一直求到f(1)f(0),为已知才结束。这样递归树的时间复杂度为O(2^n),这就是在前面提到的重叠子问题。

2、思路二：为了拒绝重复查询相同的数据如fib(28)，我们可以做一个字典，将n对应的fib(n)，存起来，计算时每个节点只计算一次。那同样的想法，我们使用递推的方式向上进行计算从fib(0)一直计算到fib(29)也可以算出fib(30)的值，这样时间复杂度为O(n)。

public static int fib3(int n) {
   if (n == 0) return 0;
   int[] dp = new int[n + 1];
   dp[0] = 0; dp[1] = 1;//字典存值
   for (int i = 2; i <= n; i++) {
      dp[i] = dp[i - 1] + dp[i - 2];
   }
   return dp[n];
}

public static int fib(int n) {
   if (n<=1){
      return n;
   }
   //计算f(n) 需要f(n-1) 和f(n-2) 设定f(n-1)为p f(n-2)为q f(n)为r 因为从2开始循环所以r=2
   int p=1,q=0,r=1;
   for (int i = 2; i < n ; ++i) {
      q=p;
      p=r;
      r=p+q;
   }
   return r;
}

3、思路三：使用高数和线代的思想，简化方程式(需要一定的数学基础)

    public static int fib(int n) {
        double sqrt5 = Math.sqrt(5);
        double fibN = Math.pow((1 + sqrt5) / 2, n) - Math.pow((1 - sqrt5) / 2, n);
        return (int) Math.round(fibN / sqrt5);
    }

这样求得的结果时间复杂度就是O(1)了。

2> 零钱兑换

题目：给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/coin-change

有了上一题的经验，我们理解到如果数组coins为{1,2,5},目标金额为11，设定dp[amount]为金额为amount的情况下最少需要的硬币数量,现在我们需要计算dp[11],那我们就需要计算11的子集，那么11的子集有哪些？dp[10],dp[9],dp[6],相当于消耗一次硬币的情况。我们只需要计算出min[dp[10],dp[9],dp[6]]+1自然就是dp[11]的结果。又由上一题的经验，我们可以自下而上的去获取答案，从而避免重复计算。由此代码如下：

public int coinChange(int[] coins, int amount) {
        //先判断金额为异常的情况
        if (amount==0){
            return 0;
        }else if(amount<0) {
            return -1;
        }
        //设定一个dp数组，记录需要记录完成金额目标的最小硬币数量 数组长度应该是金额+1
        int[] dp = new int[amount+1];
        Arrays.fill(dp,amount+1);//我们需要求目标金额需要硬币的最小值，所以给定一个默认最大值
        dp[0]=0;//金额为0，返回0
        //循环金额目标，从1开始计算到amount的所需硬币最小值
        for (int i = 0; i < amount+1; i++) {
            for (int coin:coins){
                //目标金额大于等于硬币面额的情况下才有计算价值
                if (i>=coin){
                    //循环coins的面值，进行获取子集的最小值
                    dp[i]= Math.min(dp[i],dp[i-coin]+1);
                }
            }
        }
        //当dp[amount]<amount时，有解返回答案，无解返回-1
        return dp[amount]>amount? -1:dp[amount];
    }

由上面2个题目，我们知道，动归题目的思路，1、找到规律，既找到所求目标和其子集的关系

2、通过dp自下而上的递归或者通过字典的方式 避免重复查找子集提高效率。

这也是我们做动归的核心思想，先穷举，再优化。