【算法】动态规划

动态规划注意以下几点：

• 核心：当前状态可以由前面的状态得到
  1、dp[i][j]或者dp[i]表示的具体意义
  2、初始的值是多少
  3、状态转移方程
  4、返回值是什么

---

Leetcode 64

解析：

• 定义：利用二维数组动态规划来做，dp[i][j]表示从左上角到当前位置(i, j)的最小路径和，grid表示输入的二维数组。
• 初始化：dp[0][0] = grid[0][0]，左上角到左上角的最小路径和就是本身，对于第一行的数据只能通过左上角逐步向右移动得到 dp[0][i] = dp[0][i-1] + grid[0][i]，对于第一列的数据只能通过左上角逐步向下移动得到 dp[i][0] = dp[i-1][0] + grid[i][0]，
• 状态转移方程：其余数据，只能通过当前位置的左边或者上边数据移动得到：dp[i][j] = grid[i][j] + min(dp[i - 1][j], dp[i][j - 1])
• 返回值：dp[m-1][n-1]，表示从左上角到右下角的最小路径和

解法1：

public class test {
	public static int minPathSum(int [][] grid) {
		int m = grid.length, n = grid[0].length;
		int [][] dp = new int [m][n];
		dp[0][0] = grid[0][0];
		//第一列只有由数字向下移动得到
		for (int i = 1; i < m; i++) dp[i][0] = grid[i][0] + dp[i-1][0];
		//第一行只能有数字向右移动得到
		for (int j = 1; j < n; j++) dp[0][j] = grid[0][j] + dp[0][j-1];
		//循环从1开始，不包括第一行和第一列
		for (int i = 1; i < m; i++) {
			for (int j = 1; j < n; j++) {
				dp[i][j] = grid[i][j] + Math.min(dp[i-1][j], dp[i][j-1]);
			}
		}
		//dp[i][j]表示从左上角到当前位置的最小路径和，目前为右下角位置
		return dp[m-1][n-1];
	}
	public static void main(String[] args) {
		int [][] grid = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
		int result = minPathSum(grid);
		System.out.println(result);
	}
}

解法2：
或者使用下面的这种方式，一模一样的,

public class test {
	public static int minPathSum(int [][] grid) {
		int m = grid.length, n = grid[0].length;
		int [][] dp = new int [m][n];
		for (int i =0; i < m; i++) {
			for (int j =0; j < n; j++) {
				if (i == 0) {
					//初始值grid[0][0]
					if (j == 0) {
						dp[i][j] = grid[i][j];
					}
					//第一行，数字只能向右移动
					else {
						dp[i][j] = dp[i][j-1] + grid[i][j];
					}
				}
				//第一列，数据只能向下移动
				else if (j == 0) {
					dp[i][j] = dp[i-1][j] + grid[i][j];
				}
				//一般情况
				else {
					dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
				}
			}
		}
		return dp[m-1][n-1];
	}
	public static void main(String[] args) {
		int [][] grid = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
		int result = minPathSum(grid);
		System.out.println(result);
	}
}

解法3：
空间优化，使用一维数组，不停的覆盖原有的值即可
ps：在解法2的基础上，直接将【i】那一项去掉即可

public class test {
	public static int minPathSum(int [][] grid) {
		int m = grid.length, n = grid[0].length;
		int [] dp = new int [n];
		for (int i =0; i < m; i++) {
			for (int j =0; j < n; j++) {
				if (i == 0) {
					//初始值grid[0][0]
					if (j == 0) {
						dp[j] = grid[i][j];
					}
					//第一行，数字只能向右移动
					else {
						dp[j] = dp[j-1] + grid[i][j];
					}
				}
				//第一列，数据只能向下移动
				else if (j == 0) {
					dp[j] = dp[j] + grid[i][j];
				}
				//一般情况
				else {
					dp[j] = Math.min(dp[j], dp[j-1]) + grid[i][j];
				}
			}
		}
		return dp[n-1];
	}
	public static void main(String[] args) {
		int [][] grid = {{1, 3, 1}, {1, 5, 1}, {4, 2, 1}};
		int result = minPathSum(grid);
		System.out.println(result);
	}
}

---

Leetcode 53

解析：

• 定义：dp[i]表示以nums[i]结尾的最大子数组的和
• 初始化：dp[0] = nums[0]
• 状态转移方程：dp[i]对应的连续子数组中如果不包含nums[i-1]，那么dp[i] = nums[i]；如果包含了nums[i-1]，那么就包含了以nums[i-1]结尾的最大子数组的和dp[i-1]，即dp[i] = dp[i-1] + nums[i]，综上得到状态转移方程dp[i] = dp[i-1]+nums[i]
• 返回值：dp[0]、dp[1]、…dp[n-1]中的最大值，其中n = nums.length

解法1、

public class test {
	public static int maxSubArray(int[] nums) {
		int n = nums.length;
		int [] dp = new int[n];
		//初始化
		dp[0] = nums[0];
		int res = dp[0];
		for (int i = 1; i < n; i++) {
			//状态转移，注意从i = 1开始循环
			dp[i] = Math.max(dp[i-1] + nums[i], nums[i]);
			//返回所有dp[i]中的最大值
			res = Math.max(dp[i], res);
		}
		return res;
	}
	public static void main(String[] args) {
		int [] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 5};
		int result = maxSubArray(nums);
		System.out.println(result); 
	}
}

解法2、
空间优化，在解法1的基础上使用常数代替dp一维数组
ps：因为算法中dp[i]的值只与dp[i-1]有关，我们并不需要把每个dp[i]的值存储下来

public class test {
	public static int maxSubArray(int[] nums) {
		int n = nums.length;
		int endHere = nums[0];
		int res = nums[0];
		for (int i = 1; i < n; i++) {
			//状态转移，注意从i = 1开始循环
			endHere = Math.max(endHere + nums[i], nums[i]);
			//返回所有dp[i]中的最大值
			res = Math.max(endHere, res);
		}
		return res;
	}
	public static void main(String[] args) {
		int [] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 5};
		int result = maxSubArray(nums);
		System.out.println(result);
	}
}