动态规划经典习题

动态规划

简介

动态规划是一种将一个复杂问题分解为多个简单的子问题求解的方法。将子问题的答案存储在记忆数据结构中，当子问题再次需要解决时，只需查表查看结果，而不需要再次重复计算，因此节约了计算时间。

动态规划算法与分治法类似，其基本思想也是将待求解的问题分解成若干个子问题，先求解子问题，然后从这些子问题的解中 得到原有问题的解。与分治法不同的是，动态规划经分解后得到的子问题往往不是相互独立的。

动态规划做题的思路是找到解题的状态转移方程，根据状态转移方程写出相应的代码。接下来我们先通过对于斐波那切数列的解题方法来引出动态规划的解法，再介绍一些比较典型的动态规划算法题，比如：01背包、完全背包等。

斐波那切数列

普通解法

n：第 n 个斐波那切数

public int Fibonacci(int n) {
	if (n < 0) {
		return -1;
	}
	if (n == 1 || n == 2) {
		return 1;
	}
	return Fibonacci(n - 1) + Fibonacci(n - 2);
}

记忆法 - 自顶向下

n：第 n 个斐波那切数

public int Fibonacci(int n) {
	if (n < 0) {
		return -1;
	}
	int[] nums = new int[n + 1];
	return dps(nums, n);
}

public int dps(int[] nums, int n) {
	if (n == 1 || n == 2) {
		return 1;
	}
	if (nums[n] != 0) {
		return nums[n];
	}
	nums[i] = dps(nums, n - 1) + dps(nums, n - 2);
	return nums[i];
}

记忆法 - 自下而上

n：第 n 个斐波那切数

public int Fibonacci(int n) {
	if (n < 0) {
		return -1;
	}
	if (n == 1 || n == 2) {
		return 1;
	}
	int[] nums = new int[n + 1];
	nums[1] = 1;
	nums[2] = 1;
	for (int i = 3; i <= n; i++) {
		nums[i] = nums[i - 1] + nums[i - 2];
	}
	return nums[n];
}

动态规划

n：第 n 个斐波那切数

public int Fibonacci(int n) {
	if (n < 0) {
		return -1;
	}
	if (n == 1 || n == 2) {
		return 1;
	}
	int f1 = 1, f2 = 1, f3 = 0;
	for (int i = 3; i <= n; i++) {
		f3 = f1 + f2;
		f1 = f2;
		f2 = f3;
	}
	return f3;
}

01背包

01背包问题 - 二维数组

n：物品数量
w：背包容量
value：物品价值数组
weight：物品重量数组

	public int PackExtend(int n, int w, int[] value, int[] weight) {
		int[][] dp = new int[n + 1][w + 1];
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= w; j++) {
				if (j < weight[i - 1]) {
					// 如果装不下
					dp[i][j] = dp[i - 1][j];
				} else {
					//如果可以装下，则比较放入和不放入的价值
					dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]);
				}
			}
		}
		return dp[n][w];
	}

01背包问题 - 一维数组

n：物品数量
w：背包容量
value：物品价值数组
weight：物品重量数组

	public int PackExtend(int n, int w, int[] value, int[] weight) {
		int n = 4; // 物品数量
		int w = 5; // 背包容量
		int[] value = new int[] { 3, 4, 5, 6 }; // 物品价值
		int[] weight = new int[] { 2, 3, 4, 5 }; // 物品重量

		int[] dp = new int[w + 1];
		for (int i = 0; i < n; i++) {
			for (int j = w; j >= weight[i]; j--) {
				if (j >= weight[i]){
					//如果可以装下，则比较放入和不放入的价值
					dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
				}
			}
		}
		return dp[w];
	}

完全背包

完全背包 - 二维数组

n：物品数量
w：背包容量
value：物品价值数组
weight：物品重量数组

public int CompletePackExtend(int n, int w, int[] value, int[] weight) {
	int dp[][] = new int[n + 1][w + 1];
	for (int i = 1; i <= n; i++) {
		for (int j = 0; j <= w; j++) {
			for (int k = 0; k <= w / weight[i - 1]; k++) {
				if (j >= k * weight[i - 1]) {
					dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - k * weight[i - 1]] + k * value[i - 1]);
				}
			}
		}
	}
	return dp[n][w];
}

完全背包 - 一维数组

n：物品数量
w：背包容量
value：物品价值数组
weight：物品重量数组

public int CompletePackExtend(int n, int w, int[] value, int[] weight) {
	int dp[] = new int[w + 1];
	for (int i = 1; i <= n; i++) {
		for (int j = w; j >= 0; j--) {
			for (int k = 1; k <= w / weight[i - 1]; k++) {
				if (j >= k * weight[i - 1]) {
					dp[j] = Math.max(dp[j], dp[j - k * weight[i - 1]] + k * value[i - 1]);
				}
			}
		}
	}
	return dp[w];
}

最大连续子数组之和

最大连续子数组和

public int FindGreatestSumOfSubArray(int[] nums) {
	int ans = nums[0];
	int max = nums[0];
	for (int i = 1; i < nums.length; i++) {
		ans = Math.max(nums[i], ans + nums[i]);
		max = Math.max(max, ans);
	}
	return max;
}

跳台阶

普通青蛙

有n个台阶，一次只能跳1或2个台阶，求有多少中跳法

public int jumpFloor(int n) {
	if (n == 1 || n == 2) {
		return n;
	}
	int f1 = 1, f2 = 2, f3;
	for (int i = 2; i < n; i++) {
		f3 = f1 + f2;
		f1 = f2;
		f2 = f3;
	}
	return f3;
}

疯狂青蛙

有n个台阶，一次可以跳1到n次，求有多少种跳法

public int jumpFloor(int n) {
	if (n == 1) {
		return 1;
	}
	int f1 = 1, f2;
	for (int i = 1; i < n; i++) {
		f2 = 2 * f1;
		f1 = f2;
	}
	return f2;
}

零钱兑换

零钱兑换

求通过coins数组凑出amount元的最小硬币数

public static int coinChange(int[] coins, int amount) {
	if (amount < 0) {
		return -1;
	}
	int[] dp = new int[amount + 1];
	for (int i = 1; i <= amount; i++) {
		//赋初值
		dp[i] = amount + 1;
	}
	dp[0] = 0;
	for (int i = 1; i <= amount; i++) {
		for (int j = 0; j < coins.length; j++) {
			if (i - coins[j] < 0) {
				// 不能减去时，进入下一个循环
				continue;
			}
			//在自身和自身减去一个面额的数值之间选择
			dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
		}
	}
	return dp[amount] == amount + 1 ? -1 : dp[amount];
}