动态规划

动态规划是一种算法套路,通常用来求一些最优解什么的,它的最精髓的地方个人认为就是它是反过来推理的,有一些题目按照脑子别的正常思路来思考往往会很乱。


举个例子来说;

一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法

正常来思考:
跳一级台阶n = 1:就只有一种方式
跳两级台阶n = 2:两种方式:1+1;2;
跳三级台阶n = 3:三种方式:1+1+1;1+2;2+1;
跳四级台阶n = 4:五种方式:1+1+2;2+2;1+1+1+1;1+2+1;2+1+1;
。。。。。

像这样越往后越复杂,想着想着就乱了,感觉就像在脑子里面有棵树,然后不断的分叉,约分越多,根本理不清。

动态规划就是要倒过来思考,知识点啊::::

比如n=10,到达10级台阶只有两种方式:从第9级跨一步过来,或者从第8级跨两级过来。

那么我只要知道到达第9级的方式数+到达第8级的方式数就可以了。至于第9级和第8级的方式数到底是多少。那是它们自己的事,不是我第10级该管的。

以同样的方式,一直往前推,到第一级和第二级,n = 1和n = 2的情况是已知的。

public class Solution {
    public int JumpFloor(int target) {
        //dp数组存放到达每一级台阶可以有的方式数
        int dp[] = new int[target+1];
        for (int i = 0; i < dp.length; i++) {
            if (i==0){
                //0级台阶0种方式
                dp[i]=0;
            }else if (i==1){
                //1级台阶1种方式
                dp[i]=1;
            }else if (i==2){
                //2级台阶2种方式
                dp[i]=2;
            }else {
                //其他台阶都是从上一级台阶跨一步上来,或者上两级台阶跳2级上来
                dp[i] = dp[i-1]+dp[i-2]; 
            }
            
        }
        return dp[target];
    }
}

这种动态规划的重点在与从题目的一次可以跳一级或者两级台阶找到dp[i] = dp[i-1]+dp[i-2]这层关系,然后再找到特例的几个值就是n=1和n=2的情况。

然后再看一个例子:

1,3,5,9
8,1,3,4
5,0,6,1
8,8,4,0
这是一个二维数组,从左上角开始每次只能向右走或者向下走,最后达到右下角的位置,路径中所有数字累加起来就是路径和,返回所有路径的最小路径和。

从1开始走,到达0,有很多岔道,并且难以确定哪条路比较近,要把所有路径都列出来一个个求根本不靠谱。
按照动态规划倒着思考的思路,在本题中要根据“每次只能向右走或者向下走”推理出到达最后的0有两种:从1往下走,或者从4往右走,也就是说只要比较一下到达4的最短路径和+0和到达1的最短路径和+0谁比较小即可。
继续推理,到达4也有两种:从8往右走,或者从6往下走,比较一下到达8的最短路径和+4和到达6的最短路径和+4谁比较小即可。

其中第0行和第0列都是特殊的,最好拿出来特殊处理。


import java.util.ArrayList;
public class Solution {
    public int test(int [][] array) {
        int row = 0;
        int col = 0;
        //存放到达每个位置的最短路径和。
        int dp[][] = new int[array.length][array[0].length];
        //遍历二维数组,给dp赋初值。(用两个for遍历也是一样的)
        while(row<array.length){
            dp[row][col] = 9999;
            col++;
            if (col == array[row].length){
                row++;
                col = 0;
            }
        }
        
        
         row = 0;
         col = 0;
         
         //遍历数组,计算每个值的最短路径和放入dp数组中
        while(row<array.length){
            if (row == 0 && col == 0){
                //第一个就是它本身
                dp[row][col] = array[row][col];
            }else if (row == 0){
                //第一行的只能从它左边走过来
                dp[row][col] = array[row][col] + dp[row][col - 1];
            }else if (col == 0){
                //第一列的只能从它上边走过来
                dp[row][col] = array[row][col] + dp[row - 1][col];
            }else {
                //从左边或者上边过来,选择小的一个。
                dp[row][col] = array[row][col] + Math.min(dp[row-1][col], dp[row][col - 1]);
            }
            col++;
            if (col == array[row].length){
                row++;
                col = 0;
            }
        }
        
        //打印dp数组
        for (int[] is : dp) {
            for (int i : is) {
                System.out.print(i+" ");
            }
            System.out.println(" ");
        }

        return dp[dp.length-1][dp[0].length-1];
    }
}

推荐阅读更多精彩内容