【LeetCode题解】动态规划：从新手到专家(一）
文章标题借用了Hawstein的译文《动态规划：从新手到专家》。
1. 概述
动态规划（ Dynamic Programming, DP）是最优化问题的一种解决方法，本质上状态空间的状态转移。所谓状态转移是指每个阶段的最优状态（对应于子问题的解）可以从之前的某一个或几个阶段的状态中得到，这个性质叫做最优子结构。而不管之前这个状态是如何得到的，这被称之为无后效性。
DP问题中最经典的莫过于01背包问题:
有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。
用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值；则其状态转移方程：
f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}“将前i件物品放入容量为v的背包中”这个子问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为一个只牵扯前i-1件物品的问题。如果不放第i件物品，那么问题就转化为“前i-1件物品放入容量为v的背包中”，价值为f[i-1][v]；如果放第i件物品，那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”，此时能获得的最大价值就是f[i-1][v-c[i]]再加上通过放入第i件物品获得的价值w[i]。
2. 题解
| LeetCode题目 | 归类 |
|---|---|
| 53. Maximum Subarray | 子数组最大和 |
| 121. Best Time to Buy and Sell Stock | 子数组最大和 |
| 122. Best Time to Buy and Sell Stock II | 子序列最大和 |
| 123. Best Time to Buy and Sell Stock III | |
| 188. Best Time to Buy and Sell Stock IV | |
| 55. Jump Game | |
| 70. Climbing Stairs | |
| 62. Unique Paths | |
| 63. Unique Paths II | |
| 64. Minimum Path Sum | 最短路径 |
| 91. Decode Ways |
以下代码既有Java，也有Go。
53. Maximum Subarray
子数组最大和问题，求解方法可用Kadane算法。
121. Best Time to Buy and Sell Stock
题目大意：给定数组a[..]a[..]，求解maxa[j]−a[i]j>imaxa[j]−a[i]j>i。
解决思路：将数组a的相邻值相减（右边减左边）变换成数组b，上述问题转变成了求数组b的子数组最大和问题.
// Kadane algorithm to solve Maximum subArray problem
public int maxProfit(int[] prices) {
int maxEndingHere = 0, maxSoFar = 0;
for (int i = 1; i < prices.length; i++) {
maxEndingHere += prices[i] - prices[i - 1];
maxEndingHere = Math.max(maxEndingHere, 0);
maxSoFar = Math.max(maxEndingHere, maxSoFar);
}
return maxSoFar;
}122. Best Time to Buy and Sell Stock II
之前问题Best Time to Buy and Sell Stock的升级版，对交易次数没有限制，相当于求解相邻相减后形成的子序列最大和——只要为正数，则应计算在子序列内。
public int maxProfit(int[] prices) {
int max = 0;
for (int i = 1; i < prices.length; i++) {
if (prices[i] > prices[i - 1]) {
max += (prices[i] - prices[i - 1]);
}
}
return max;
}123. Best Time to Buy and Sell Stock III
最多允许交易两次。
public int maxProfit(int[] prices) {
int sell1 = 0, sell2 = 0;
int buy1 = Integer.MIN_VALUE, buy2 = Integer.MIN_VALUE;
for (int price : prices) {
buy1 = Math.max(buy1, -price); // borrow
sell1 = Math.max(sell1, buy1 + price);
buy2 = Math.max(buy2, sell1 - price);
sell2 = Math.max(sell2, buy2 + price);
}
return sell2;
}188. Best Time to Buy and Sell Stock IV
最多允许交易k次。当k >= n/2时，在任意时刻都可以进行交易（一次交易包括买、卖），因此该问题退化为了问题122. Best Time to Buy and Sell Stock II。其他情况则有递推式：
ci,j=max(ci,j−1, max(ci−1,t−pt)+pj),0≤t<jci,j=max(ci,j−1, max(ci−1,t−pt)+pj),0≤t<j
其中，ci,jci,j表示在tt时刻共ii次交易产生的最大收益。
public int maxProfit(int k, int[] prices) {
int n = prices.length;
if (n <= 1) {
return 0;
}
// make transaction at any time
else if (k >= n / 2) {
return maxProfit122(prices);
}
int[][] c = new int[k + 1][n];
for (int i = 1; i <= k; i++) {
int localMax = -prices[0];
for (int j = 1; j < n; j++) {
c[i][j] = Math.max(c[i][j - 1], localMax + prices[j]);
localMax = Math.max(localMax, c[i - 1][j] - prices[j]);
}
}
return c[k][n - 1];
}
public int maxProfit122(int[] prices) {
int max = 0;
for (int i = 1; i < prices.length; i++) {
if (prices[i] > prices[i - 1]) {
max += (prices[i] - prices[i - 1]);
}
}
return max;
}55. Jump Game
限制当前最大跳跃数，问是否能到达最后一个index。需要反向往后推演。
public boolean canJump(int[] nums) {
int n = nums.length, index = n - 1;
for (int i = n - 2; i >= 0; i--) {
if (i + nums[i] >= index)
index = i;
}
return index <= 0;
}70. Climbing Stairs
题目大意：每一次可以加1或加2，那么从0加到n共有几种加法？
假定didi表示加到i的种数，那么就有递推式di=di−1+di−2di=di−1+di−2。
func climbStairs(n int) int {
if(n < 1) {
return 0;
}
d := make([]int, n+1)
d[1] = 1
if n >= 2 {
d[2] = 2
}
for i := 3; i<=n; i++ {
d[i] = d[i-1] + d[i-2]
}
return d[n]
}62. Unique Paths
题目大意：求解从左上角到右下角的路径数。
路径数递推式：ci,j=ci−1,j+ci,j−1ci,j=ci−1,j+ci,j−1。
func uniquePaths(m int, n int) int {
f := make([][]int, m)
for i := range f {
f[i] = make([]int, n)
}
// handle boundary condition: f[][0] and f[0][]
f[0][0] = 1
for i := 1; i < m; i++ {
f[i][0] = 1
}
for j := 1; j < n; j++ {
f[0][j] = 1
}
for i := 1; i < m; i++ {
for j := 1; j < n; j++ {
f[i][j] = f[i][j - 1] + f[i - 1][j]
}
}
return f[m-1][n-1]
}63. Unique Paths II
加了限制条件，有的点为obstacle——不允许通过。上面的递推式依然成立，只不过要加判断条件。另外，在实现过程中可以用一维数组代替二维数组，比如说按行或按列计算。
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int columnSize = obstacleGrid[0].length;
int[] c = new int[columnSize];
c[0] = 1;
for (int[] row : obstacleGrid) {
for (int j = 0; j < columnSize; j++) {
if (row[j] == 1)
c[j] = 0;
else if (j >= 1)
c[j] += c[j - 1];
}
}
return c[columnSize - 1];
}64. Minimum Path Sum
题目大意：从矩阵的左上角到右下角的最短路径。
加权路径值ci,j=max(ci−1,j,ci,j−1)+wi,jci,j=max(ci−1,j,ci,j−1)+wi,j，其中，wi,jwi,j为图中边的权值。
// the shortest path for complete directed graph
func minPathSum(grid [][]int) int {
var m, n = len(grid), len(grid[0])
f := make([][]int, m)
for i := range f {
f[i] = make([]int, n)
}
// handle boundary condition: f[][0] and f[0][]
f[0][0] = grid[0][0]
for i := 1; i < m; i++ {
f[i][0] = f[i - 1][0] + grid[i][0]
}
for j := 1; j < n; j++ {
f[0][j] = f[0][j-1] + grid[0][j]
}
for i :=1; i < m; i++ {
for j := 1; j<n; j++ {
if(f[i-1][j] < f[i][j-1]) {
f[i][j] = f[i-1][j] + grid[i][j]
} else {
f[i][j] = f[i][j-1] + grid[i][j]
}
}
}
return f[m-1][n-1]
}91. Decode Ways
求解共有多少种解码情况。
public int numDecodings(String s) {
int n = s.length();
if (n == 0 || (n == 1 && s.charAt(0) == '0'))
return 0;
int[] d = new int[n+1];
d[n] = 1;
d[n - 1] = s.charAt(n - 1) == '0' ? 0 : 1;
for (int i = n-2; i >= 0; i--) {
if(s.charAt(i) == '0')
continue;
else if(Integer.parseInt(s.substring(i, i+2)) <= 26)
d[i] += d[i + 2];
d[i] += d[i + 1];
}
return d[0];
}如需转载，请注明作者及出处.
作者：Treant