leetcode 2.28

动态规划

1.最大子数组和

最大子数组和
动态规划：
按照四个步骤求解：
1）确定状态：以n代表第n个元素为末尾的最大子序列和
最后一步：加不加nums[n]子问题：pre(n-1)+nums[n] 与 nums[n] 的最大值，也就是说，已经求出前n项的最大子序列值A了，此时A>0则相加，若A<0则不相加；
2）转移方程：

	//pre是全局变量，这是最关键的部分，有点类似于最大前缀和，如果说加了当前 nums[i] 
	//还小于不加，那么就把之前的前缀都扔掉，从当前的数重新累加 
	pre(n) = max(pre(n-1)+nums[n] , nums[n]);
	ans = max(ans, pre);

3）初始和边界条件：pre(0)=nums[0]；
4）计算顺序：pre(0)、pre(1)…

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int pre = 0, maxAns = nums[0];
        for (auto x: nums) {
            pre = max(pre + x, x);
            maxAns = max(maxAns, pre);
        }
        return maxAns;
    }
};

2.不同路径

不同路径
1）确定状态：dp[i][j]代表走到[i][j]网格的路径数目；
2）转移方程：d[i][j]=d[i-1][j]+d[i][j-1]；
3）边界条件：最左一列和最上一行只能为1，因为只能一步步往下或者一步步往右；
4）计算顺序：先一行，再列。

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 1));
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]; 
            }
        }
        return dp[m - 1][n - 1];
    }
};

3.最小路径和

最小路径和
1）确定状态：dp[i][j]代表走到[i][j]网格的最小和；
2）转移方程：dp[i][j] = nums[i][j] + min(d[i-1][j],d[i][j-1])；
3）边界条件：dp[0][0] = grid[i][j] 、最左一列，dp[i][0]=dp[i-1][0]+grid[i][0]、最右一列，dp[0][j]=dp[0]d[j-1]+grid[0][j]、正常列，dp[i][j]=dp[i-1][j]+grid[i][j-1]；最主要的就是考虑到最左只能往下走，最上一行只能往右走；
4）计算顺序：先一行，再列。

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<vector<int>> minAns(n, vector<int>(m, 1));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (i ==  0 && j == 0) minAns[i][j] = grid[0][0];
                else if(i == 0 && j != 0) minAns[i][j] = minAns[i][j-1] + grid[i][j];
                else if(j == 0 && i != 0) minAns[i][j] = minAns[i-1][j] + grid[i][j];
                else minAns[i][j] = grid[i][j] + min(minAns[i - 1][j], minAns[i][j - 1]);
            }
        }
        return minAns[n - 1][m - 1];
    }
};

4. 爬楼梯

爬楼梯
1）确定状态：dp[i] 为爬到第 i 个台阶可以有多少种方法；
2）转移方程：dp[i] = dp[i - 1] + dp[i - 2]；
3）边界条件：dp[1] = 1, dp[2] = 2；
4）计算顺序：dp[1], dp[2]…

class Solution {
public:
    int climbStairs(int n) {
        vector<int> dp(n + 1, 0);
        for (int i = 1; i <= n; i++) {
            if (i == 1) dp[1] = 1;
            else if (i == 2) dp[2] = 2;
            else dp[i] = dp[i -1] + dp[i -2];
        }
        return dp[n];
    }
};

5. 杨辉三角

杨辉三角
1）确定状态：dp[i][j] 为[i][j] 位置上的数字和；
2）转移方程：dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]；
3）边界条件：dp[0][0] = 1; 并且每一行的第一个和最后一个元素都为1，dp[i][0] = 1, dp[i][row] = 1
4）计算顺序：先行后列
注意：如果dp已经在初始化确定大小，那么可以利用dp[i][j]直接赋值，否则，只能push_back
resize用法：C++ std::vector::resize() 方法解析

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> dp(numRows);
        for (int i = 0; i < numRows; i++) {
            dp[i].resize(i + 1);
            for (int j = 0; j <= i; j++) {
                if (j == 0) dp[i][j] = 1;
                else if (j == i) dp[i][j] = 1;
                else dp[i][j] = dp[i -1][j - 1] + dp[i - 1][j];
            }
        }
        return dp;
    }
};

6.打家劫舍

打家劫舍
1）确定状态：dp[i] 为 i 位置上能抢到的最大钱数；
2）转移方程：dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
3）边界条件：dp[0] = nums[0], dp[1] = max(nums[0], nums[1])
4）计算顺序：dp[0], dp[1]…

刚开始完全理解错误，以为必须是隔一个偷，这样只需计算dp[0]和dp[1]，输出max

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 1) return nums[0];
        if (nums.size() == 2) return nums[0] > nums[1] ? nums[0] : nums[1];
        long ans1 = 0, ans2 = 0;
        for (int i = 0; i < nums.size(); i = i+2) {
            ans1 += nums[i];
        }
        for (int i = 1; i < nums.size(); i = i+2) {
            ans2 += nums[i];
        }
        return max(ans1, ans2);
    }
};

发现这个测试用例失败：
[2,1,1,2]

输出
3
预期结果
4

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 1) return nums[0];
        if (nums.size() == 2) return nums[0] > nums[1] ? nums[0] : nums[1];
        vector<int> dp(nums.size() + 1);
        dp[0] = nums[0];
        for (int i = 1; i < nums.size(); i++) {
            if (i == 1) dp[i] = max(nums[0], nums[1]);
            else dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[nums.size() - 1];
    }
};