leetcode dp
53. Maximum Subarray
Given an integer array
nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.Example:
Input: [-2,1,-3,4,-1,2,1,-5,4], Output: 6 Explanation: [4,-1,2,1] has the largest sum = 6.
思路：当前的最大值怎没递归呢？就是取（前一个最大的值）和（前一个值加上当前值）的最大者
dp[i]=max(dp[i-1]+当前值nums[i] , 之前的最大值max)
class Solution { int maxSubArray(vector<int> &nums) { int n =nums.size(); vector<int> dp(n,0);//dp[i] means the maximum subarray ending with nums[i]; dp[0] = nums[0]; int max = dp[0]; for(int i = 1; i < n; i++){ dp[i] = nums[i] + (dp[i - 1] > 0 ? dp[i - 1] : 0); //前面的dp[i-1]小于0则清空重新从0开始计数 max = max(max, dp[i]); //当前的dp[i]和之前的最大的某个dp比较，取最大 } return max; } };
64. Minimum Path Sum
Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.
Note: You can only move either down or right at any point in time.
Example:
Input: [ [1,3,1], [1,5,1], [4,2,1] ] Output: 7 Explanation: Because the path 1→3→1→1→1 minimizes the sum.
思路：递归策略：当前的格子等于前一列格子加上一个格子。最左边只能加上一个格子，最上边的只能加做一个格子。
///不优化 class Solution { public: int minPathSum(vector<vector<int>>& grid) { int m = grid.size(); int n = grid[0].size(); vector<vector<int> > sum(m, vector<int>(n, grid[0][0])); for (int i = 1; i < m; i++) //左格子 sum[i][0] = sum[i - 1][0] + grid[i][0]; for (int j = 1; j < n; j++) //右格子 sum[0][j] = sum[0][j - 1] + grid[0][j]; for (int i = 1; i < m; i++) //既不是左格子也不是右格子，而是中间的格子 for (int j = 1; j < n; j++) sum[i][j] = min(sum[i - 1][j], sum[i][j - 1]) + grid[i][j]; return sum[m - 1][n - 1]; //返回最右下角的格子值 } }; ////两个一位数组的优化
//思路：当前的格子只和前一个格子和上一个格子有关，所以可以使用两个数组来保存。一个数组pre用来保存前一列的递归值，一个数组cur保存当前列的递归值
class Solution { public: int minPathSum(vector<vector<int>>& grid) { int m = grid.size(); int n = grid[0].size(); vector<int> pre(m, grid[0][0]); vector<int> cur(m, 0); for (int i = 1; i < m; i++) pre[i] = pre[i - 1] + grid[i][0]; for (int j = 1; j < n; j++) { cur[0] = pre[0] + grid[0][j]; for (int i = 1; i < m; i++) cur[i] = min(cur[i - 1], pre[i]) + grid[i][j]; swap(pre, cur); } return pre[m - 1]; } }; ///一个一维数组的优化
//从第二种方法知到，保留的pre数组其实也就是cur数组的前一次，所以可以直接使用一个数组cur就够了
class Solution { public: int minPathSum(vector<vector<int>>& grid) { int m = grid.size(); int n = grid[0].size(); vector<int> cur(m, grid[0][0]); for (int i = 1; i < m; i++) cur[i] = cur[i - 1] + grid[i][0]; for (int j = 1; j < n; j++) { cur[0] += grid[0][j]; for (int i = 1; i < m; i++) cur[i] = min(cur[i - 1], cur[i]) + grid[i][j]; } return cur[m - 1]; } };
第二种方法图解：
pre代表当前格子的前一个格子，cur代表当前格子+上一个格子+前一个格子，迭代完当前列后，后面的列重复前面的动作。
120. Triangle
Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.
For example, given the following triangle
[ [2], [3,4], [6,5,7], [4,1,8,3] ]The minimum path sum from top to bottom is
11(i.e., 2 + 3 + 5 + 1 = 11).
思路：第一时间会想到动态规划，那么自顶向下还是自底向上？自顶向下要保存每次计算的和，所以要消耗一定的空间，而自底向上则简单点，本身的值即为路径和。
int minimumTotal(vector<vector<int> > &triangle) { int n = triangle.size(); vector<int> minlen(triangle.back()); for (int layer = n-2; layer >= 0; layer--) // 迭代每层 { for (int i = 0; i <= layer; i++) // Check its every 'node' { // Find the lesser of its two children, and sum the current value in the triangle with it. minlen[i] = min(minlen[i], minlen[i+1]) + triangle[layer][i]; } } return minlen[0]; }
对照上图其实就是先从底下开始，当n=4时，外循环此时是第三层（index=2），然后在内循环里面遍历当前层对应的子节点，如4和1取最小6，保存为minlen[]数组供下一次迭代。
