动态规划算法

动态规划算法

动态规划算法是通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推（或者说分治）的方式去解决。
动态规划题目特点：
1.计数
有多少种方式走到右下角
有多少种方法选出K个数使得和是Sum
2.求最大最小值
从左上角走到右下角路径的最大数字和
最长上升子序列长度
3.求存在性
取石子游戏，先手是否必胜
能不能选出k个数使得和是Sum
做题思路：
1.确定状态 研究最优策略的最后一步 化为子问题
2.转移方程 根据子问题定义直接得到
3.初始条件和边界情况
4.计算顺序（利用之前计算的结果）

接下来我会拿三道题来进行解释
第一道
思路：

1. 首先我们确定状态（简单的来说解动态规划的时候需要开一个数组，数组的每个元素f[i]或者f[i][j]代表什么），在确定状态我们需要两个意识：最后一步是什么，子问题
   比如这题最后一步是刚好付清27，最少的硬币组合
   子问题呢我们可以这样想
   我们不关心前面的k-1硬币数是怎么拼出27-Ak的，而且我们不知道ak和K，但是我们确定前面的硬币拼出了27-Ak，这样是不是我们只要考虑前面的27-ak的硬币数加一就是结果了，问题规模是不是更小了，这个就是子问题通过解决子问题最后得到最后的答案

2. 转移方程：设置状态f[x]=最少用多少枚硬币拼出X 对于任意的X，我们有

3. 初始条件和边界情况
   X-2,X-5,X-7小于0怎么办？我们怎么停下来？我们可以定义拼不出来X就为无穷大f[X]=正无穷，例如f[-1]=f[-2]=…=正无穷
   f[1]=min{f[-1]+1,f[-4]+1,f[-6]+1}=正无穷，初始条件f[0]=0

4. 计算顺序：我们要得到f[27]，所以我们直接来一个for循环，从1到27

public static int coinChange(int[] coins, int amount) {
        int n=coins.length;
        int[] f=new int[amount+1];
        f[0]=0;int i,j;
        for (i = 1; i <=amount ; i++) {
            f[i]=Integer.MAX_VALUE;
            for (j = 0; j <n ; j++) {
                if (i>=coins[j]&&f[i-coins[j]]!=Integer.MAX_VALUE){
                    f[i]=Math.min(f[i-coins[j]]+1,f[i]);
                }
            }
        }
        if (f[amount]==Integer.MAX_VALUE){
            f[amount]=-1;
        }
        return f[amount];
    }

第二道

思路：

1. 确定状态最后一步，无论机器人用何种方式到达右下角，总有最后挪动的一步：-向右或者向下。右下角的坐标设为（m-1,n-1）那么前一步机器人一定是在（m-2，n-1）或者（m-1，n-2）
   子问题机器人有X种方式从左上角走到（m-2，n-1），有Y种方式从左上角走到（m-1，n-2），则机器人有X+Y种方式走到（m-1,n-1）。
   状态：设f[i][j]为机器人有多少种方式从左上角走到（i，j）

2. 转移方程：

3. 初始条件和边界情况，f[0][0]=1，因为机器人只有一种方式到达左上角，边界情况，当i=0或者j=0时候，只有一个方向过来->f[i][j]=1
4. 计算顺序，先计算第一行，。。。第m-1行

public static int uniquePaths(int m, int n) {
        int[][] f=new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i==0||j==0){
                    f[i][j]=1;
                }
                else {
                    f[i][j]=f[i-1][j]+f[i][j-1];
                }
            }
        }
        return f[m-1][n-1];
    }

第三道
思路：

1. 确定状态：最后一步：如果能跳到n-1，我们就考虑跳的最后一步，这一步是从i跳过来的，i<n-1。这时候两个条件要满足：可以跳到i，最后一步不超过跳跃的最大距离 n-1-i<=ai
   子问题：我们能不能跳到i（i<n-1），而我们原来是要求能不能跳到n-1
   状态：设f[j]表示能不能跳到j

2. 转移方程：
   

3. 初始条件和边界情况：f[0]=true,因为一开始就在0

4. 计算顺序：计算f[1],f[2]…f[n-1]时间复杂度O(N*2)

 public static boolean canJump(int[] nums) {
        int n=nums.length;
        boolean[] f=new boolean[n];
        f[0]=true;
        for (int j = 1; j <n ; j++) {
            f[j]=false;
            for (int i = 0; i <j ; i++) {
                if (f[i]&&i+nums[i]>=j){
                    f[j]=true;
                    break;
                }
            }
        }
        return f[n-1];
    }

这道题用动态规划时间复杂度有点大，这里还有贪心算法的解法可以了解一下
贪心算法代码它这里就是遍历的时候去比较最远的跳跃距离是多少，如果在某一下标的时候发现longmax比n-1大，则返回true，时间复杂度是O(n)

public static boolean canJump2(int[] nums) {
        int n=nums.length;
        int longmax=0;
        for (int i = 0; i <n ; i++) {
            if (i<=longmax){
                longmax=Math.max(longmax,i+nums[i]);
                if(longmax>=n-1)
                    return true;
            }
        }
        return false;
    }

动态规划算法大致就是这样了，主要按照四个步骤来做就比较简单了