动态规划一定要去尝试！
题目一：
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));
}
}
初步入门动态规划就是这些了，我们接下来都要从初始的暴力动态规划，一步步推到这种状态转移过程，加油！！！
