动态规划一定要去尝试！

题目一：

1）题目描述

一共有N个位置，机器人从当前位置cur走到目标位置aim，有res步可以走，问一共有多少种方法。
题目示例：

1 2 3 4 5 6
N=6|cur=2|aim=3|res=3
结果：1
分析：2-3-4-3

2）代码

public class demo01 {

    public static void main(String[] args) {
        int res = 13;
        int cur = 2;
        int aim = 3;
        int N = 7;

        int result = 0;

        result = process1(cur, aim, res, N);
        System.out.println(result);
        
        int[][] dp = new int[N + 1][res + 1];
        for (int i = 0; i <= N; i++) {
            for (int j = 0; j <= res; j++) {
                dp[i][j] = -1;
            }
        }
        int result2=process2(cur, aim, res, N,dp);
        System.out.println(result2);
    }

    public static int process1(int cur, int aim, int res, int N) {
        /*
        cur:当前位置
        aim:目标位置
        res:剩余步数
        N：共有哪些位置
         */
        if (res == 0) {
            return cur == aim ? 1 : 0;
        }
        if (cur == 1) {
            return process1(2, aim, res - 1, N);
        } else if (cur == N) {
            return process1(N - 1, aim, res - 1, N);
        } else {
            return process1(cur - 1, aim, res - 1, N) + process1(cur + 1, aim, res - 1, N);
        }

    }
    }

3）代码优化

当暴力递归使总是出现重复解，可以通过空间换时间的方法来进行优化。

但当一个暴力递归中不存在重复解，那么它本身就是不可以优化的。

我们总说动态规划的dp表，我觉得最好的理解就是缓存表。

我们可以发现，结果是由cur与res唯一决定的（此时我认为是由状态唯一决定的）。

如果你之前计算过cur还剩res步的时候，此时又要计算，那为什么不用一个二元组把数据记录下来呢？记为dp[cur][res]。

cur的范围为：1~N
res的范围为：0~K
所以对二元状态表进行初始化：
-1为没计算过；
!=-1为计算过；—有缓存先走缓存

优化代码如下：

package com.sq.demo72DynamicPlan;

public class demo01 {
    static int res = 3;
    static int cur = 2;
    static int aim = 3;
    static int N = 7;

    public static void main(String[] args) {

        long start = System.nanoTime();
        int[][] dp = new int[N + 1][res + 1];
        for (int i = 0; i <= N; i++) {
            for (int j = 0; j <= res; j++) {
                dp[i][j] = -1;
            }
        }
        int result2 = process2(cur, aim, res, N, dp);
        long end = System.nanoTime();
        System.out.println(result2);
        System.out.println(end - start);


    }

    public static int process2(int cur, int aim, int res, int N, int[][] dp) {
        /*
        cur:当前位置
        aim:目标位置
        res:剩余步数
        N：共有哪些位置
         */

        if (dp[cur][res] != -1) {
            return dp[cur][res];
        }

        int ans = 0;
        if (res == 0) {
            ans = (cur == aim ? 1 : 0);
        } else if (cur == 1) {
            ans = process2(2, aim, res - 1, N, dp);
        } else if (cur == N) {
            ans = process2(N - 1, aim, res - 1, N, dp);
        } else {
            ans = process2(cur - 1, aim, res - 1, N, dp) + process2(cur + 1, aim, res - 1, N, dp);
        }
        dp[cur][res] = ans;
        return ans;

    }
	}

这种动态规划就是傻缓存，我并不关心你之前的状态，你只要给我当前的状态我就会给你个输出。就像是你只需要输入银行卡号和密码，银行就给你钱，他不关心你跟这个银行卡号和密码的故事。

这种方法的学名叫做：从顶向下的动态规划。 或者缓存法搜索。

4）代码优化2

上面这张图虽然画的很乱，但是很明了。
根据分析何以知道，如果

	1 2 3 4 5 
	N=5|cur=2|aim=4|res=6

在这种情况下，在res=0，cur=aim=4的时候方法才为1.

所以第4行第0列=1，即dp[4][0]=1；第0列的其余值均为0，即dp[i][0]=0,i≠4。

此处就相当于一个初始条件，也是我们之前学递归时候说的递归结束条件。

那我们就不需要递归调用了，只需要根据表格的初始情况以及一些规律，把整张表格填写好了，就可以得出我们想要的结果了。

话不多说，上代码：

public class demo03 {

    static int res = 23;
    static int cur = 2;
    static int aim = 3;
    static int N = 7;

    public static void main(String[] args) {
        ways3(cur, aim, res, N);

    }

    public static void ways3(int cur, int aim, int res, int N) {

        System.out.println("第三种方式");
        long start = System.nanoTime();
        int[][] dp = new int[N + 1][res + 1];

        //第0列是初始条件
        dp[aim][0] = 1;//第0列其余的位置都是0

        for (int i = 1; i <= res; i++) {
            dp[1][i] = dp[2][i - 1];
            for (int j = 2; j < N; j++) {
                dp[j][i] = dp[j - 1][i - 1] + dp[j + 1][i - 1];
            }
            dp[N][i] = dp[N - 1][i - 1];
        }
        long end = System.nanoTime();
        System.out.println("共有方式："+dp[cur][res]+"种");
        System.out.println("耗时为(ns):"+(end-start));
    }
}

初步入门动态规划就是这些了，我们接下来都要从初始的暴力动态规划，一步步推到这种状态转移过程，加油！！！