动态规划

修改过程

注意：动态规划就是暴力尝试减少重复计算的技巧，是一个大套路。

先尝试写出来递归的版本（最难）
再改成利用缓存得出的记忆化搜索的版本（某些问题时间复杂度和3.中是一样的）
最后改成严格表结构的动态规划
1. 分析可变参数的变化范围，几个可变参数就是几维表
2. 标出计算的终止位置
3. 依据暴力尝试版本的base case,标记出不用计算就可以得出的位置。
4. 看依赖，推其他的位置。
5. 确定依次计算的顺序。
进一步优化

相关题目一

假设有排成一行的 N 个位置，记为 1 ~ N，N一定大于或等于2。开始时机器人在其中的 M 位置上(M 一定是 1~N 中的一个)

机器人可以往左走或者往右走，如果机器人来到 1 位置，那么下一步只能往右来到 2 位置;如果机器人来到 N 位置，那么下一步只能往左来到 N-1 位置。规定机器人必须走 K 步，最终能来到 P 位置(P 也一定是 1~N 中的一个)的方法有多少种。给定四个参数 N、M、K、P，返回方法数。

举例： N=5,M=2,K=3,P=3

上面的参数代表所有位置为 1 2 3 4 5。机器人最开始在 2 位置上，必须经过 3 步，最后到达 3 位置。走的方法只有如下 3 种:

1)从2到1，从1到2，从2到3

2)从2到3，从3到2，从2到3

3)从2到3，从3到4，从4到3

所以返回方法数 3。

暴力尝试版本

	// N表示一共几步，M表示当前的位置， K表示一共需要走多少步，P是最终需要到达的位置
	public static int ways1(int N, int M, int K, int P){
		// 参数无效直接返回0
		if(N < 2 || K < 1 || M < 1 || M > N || P < 1 || P > N){
			return 0;
		}
		// 总共N个位置，从M点出发，还剩K步，返回最终能达到P的方法数
		return walk(N, M, K, P);
	}

	// N : 位置为1 ~ N，固定参数
	// cur : 当前在cur位置，可变参数
	// rest : 还剩res步没有走，可变参数
	// P : 最终目标位置是P，固定参数
	// 该函数的含义：只能在1~N这些位置上移动，当前在cur位置，走完rest步之后，停在P位置的方法数作为返回值返回
	public static int walk(int N, int cur, int rest, int P) {
		// base case
		// 如果没有剩余步数了，当前的cur位置就是最后的位置
		// 如果最后的位置停在P上，那么之前做的移动是有效的
		// 如果最后的位置没在P上，那么之前做的移动是无效的
		if(rest == 0){
			return cur == P ? 1 : 0;
		}
		// 如果还有rest步要走，而当前的cur位置在1位置上，那么当前这步只能从1走向2
		// 后续的过程就是，来到2位置上，还剩rest-1步要走
		if(cur == 1){
			return walk(N, 2, rest - 1, P);
		}
		// 如果还有rest步要走，而当前的cur位置在N位置上，那么当前这步只能从N走向N-1
		// 后续的过程就是，来到N-1位置上，还剩rest-1步要走
		if (cur == N){
			return walk(N, N - 1, rest - 1, P);
		}
		// 如果还有rest步要走，而当前的cur位置在中间位置上，那么当前这步可以走向左，也可以走向右
		// 走向左之后，后续的过程就是，来到cur-1位置上，还剩rest-1步要走
		// 走向右之后，后续的过程就是，来到cur+1位置上，还剩rest-1步要走
		// 走向左、走向右是截然不同的方法，所以总方法数要都算上
		return walk(N, cur + 1, rest -1, P) + walk(N, cur - 1, rest - 1, P);
	}

复杂度分析：因为整个过程相当于树，树的深度是K，所以时间复杂度是O(2^K)。

记忆化搜索版本

当写出来暴力尝试的版本之后，之后就都是套路了。因为在依次递归的过程中，会出现重复的算之前已经由另一个递归操作已经算过的一部分。所以可以对计算的过程进行缓存。

	public static int ways2(int N, int M, int K, int P) {
		//参数无效直接返回0
		if (N < 2 || K < 1 || M < 1 || M > N || P < 1 || P > N) {
			return 0;
		}
		//保证一个足够大的空间，这里其实[K][N]就已经足够，但是还是加了多余的一个空间
		//横行表示的是剩余的步数，列行表示的是cur当前的位置
		int[][] dp = new int[K + 1][N + 1];
		//将所有位置都标记成-1，表示之前没有到达过
		for (int i = 0; i <= K; i++){
			for (int j = 0; j < N; j++){
				dp[i][j] = -1;
			}
		}
		// 总共N个位置，从M点出发，还剩K步，返回最终能达到P的方法数
		return walk2(N, M, K, P, dp);
	}

	public static int walk2(int N, int cur, int rest, int P, int[][] dp) {
		//之前算过，直接返回之前算过的值
		if(dp[rest][cur] != -1){
			return dp[rest][cur];
		}
		//缓存没命中的情况，建立缓存
		if(rest == 0){
			dp[rest][cur] =  cur == P ? 1 : 0;
			return dp[rest][cur];
		}
                
		if(cur == 1){
			dp[rest][cur] = walk(N, 2, rest - 1, P);
			return dp[rest][cur];
		}
                
		if (cur == N){
			dp[rest][cur] = walk(N, N - 1, rest - 1, P);
			return dp[rest][cur];
		}
                
		dp[rest][cur] = walk(N, cur + 1, rest -1, P) + walk(N, cur - 1, rest - 1, P);
		return dp[rest][cur];
	}

时间复杂度：因为最多每个位置会算一次，所以是O(N * M)。

严格表结构的动态规划版本

这一步需要整理位置依赖。

	public static int ways3(int N, int M, int K, int P) {
		//参数无效直接返回0
		if (N < 2 || K < 1 || M < 1 || M > N || P < 1 || P > N) {
			return 0;
		}
		//保证一个足够大的空间，这里其实[K][N]就已经足够，但是还是加了多余的一个空间
		//横行表示的是剩余的步数，列行表示的是cur当前的位置
		int[][] dp = new int[K + 1][N + 1];
		dp[0][P] = 1;
		for (int i = 1; i <= K; i++){
			//从1开始是因为有效位就是从1开始的
			for (int j = 1; j <= N; j++){
				if(j == 1){
					dp[i][j] = dp[i - 1][2];
				}else if(j == N){
					dp[i][j] = dp[i - 1][N - 1];
				}else{
					dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j + 1];
				}
			}
		}
		return dp[K][M];
	}

时间复杂度：O(K * N)。

修改过程

相关题目一

暴力尝试版本

记忆化搜索版本

严格表结构的动态规划版本

相关题目二

暴力尝试版本

严格表结构的动态规划版本

相关题目三

暴力尝试版本

严格表结构的动态规划版本

相关题目四（三维表）

暴力尝试版本

严格表结构的动态规划版本

相关题目五

暴力尝试版本

严格表结构的动态规划版本

严格表结构优化版本

总结