算法专辑2：动态规划

1.动态规划概述

自己学太慢，参考别人的归纳：
1）传送门1
2）

2.例题

2.1 爬楼梯

如下：

思路：考虑如何到达第N阶楼梯？必然从N-2阶楼梯迈上两步或者N-1阶楼梯迈上1步抵达；当然，N=2时，dp[2]=2;dp[1]=1;dp[3]=dp[1]+dp[2];依次类推，往后构成斐波拉契数列。即得方程dp[N]=dp[N-1]+dp[N-2]。
代码如下：

    int climbStairs(int n) {
        if(n<3 && n>=0){
            return n;
        }
        vector<int> dp(n+1,0);
        dp[0] = 0; dp[1]=1; dp[2]=2;
        for(int i=3;i<n+1;++i){
            dp[i]=dp[i-1]+dp[i-2];
        }
        
        return dp[n];
    }

2.2 最大子序和

思路：最大子序和
考虑最大子序和中的最后一个元素A[i]以及除该元素外的前面所有元素的最佳解sum[i-1]：若sum[i-1]为负数，则必然抛弃自身的负资产，而选择A[i]；若sum[i-1]为正数，则直接将A[i]相加，并且实时与最大的和sum进行比较。得：
sum[i] = max(sum[i-1]+A[i],A[i])；因此只要判断sum[i-1]的正负即可。

    int maxSubArray(vector<int>& nums) {
        int sum = nums[0]; //记录最大子序和
        int n = nums[0]; // 记录序列除当前数的和
        for(int i=1;i<nums.size();++i){
            if(n>0){
                n+=nums[i]; //加上当前数
            }else{
                n=nums[i];//舍去前面部分
            }
            if(sum<n){
                sum=n; //更新最大值
            }
        }
        
        return sum;
    }

2.3 打家劫舍

思路：考虑前i家能偷到的最高金额，则有：
dp[i]的产生可能来自：
1）不偷第i家，即与dp[i-1]相同
2）在偷了第i-2家时，再偷第i家；
因而有：dp[i] = max(dp[i-1],dp[i-2]+nums[i])

    int rob(vector<int>& nums) {
        if(nums.size()==0) return 0;
        if(nums.size()==1) return nums[0];
        int* dp = new int[nums.size()+1];
        dp[0]=0;
        dp[1]=nums[0];
        for(int i=2;i<=nums.size();++i){
            dp[i] = max(dp[i-1],dp[i-2]+nums[i-1]);
        }
        return dp[nums.size()];
    }

2.4 三步问题

class Solution {
public:
    int waysToStep(int n) {
        if(n==1)  return 1;
        if(n==2)  return 2;
        if(n==3)  return 4;
        long res = 0;
        long a = 1;
        long b = 2;
        long c = 4;

        for(int i=4;i<=n;++i){
            res = (a+b+c)%1000000007;
            a = b%1000000007;
            b= c%1000000007;
            c = res%1000000007;
        }

        return res;
    }
};

2.5 三角形最小路径和

解题思路：动态规划。
记输入数组为a[n][m]，第一层的解即为a[0][0]
设函数f[i][j]表示从顶部走到位置(i,j)的最小路径和，则可以推出以下状态转移方程。
f[i+1][j]=min(f[i][j],f[i][j-1])+a[i][j]
需要注意的是上述方程的边界条件，即对于第i行，0=<j && j<==n+1
官方题解

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size(); // 三角形高度为n
        // n*n的矩阵用来存储f[i][j]
        vector<vector<int>> f(n, vector<int>(n));
        f[0][0] = triangle[0][0];
        for (int i = 1; i < n; ++i) {
            f[i][0] = f[i - 1][0] + triangle[i][0];
            for (int j = 1; j < i; ++j) {
                f[i][j] = min(f[i - 1][j - 1], f[i - 1][j]) + triangle[i][j];
            }
            f[i][i] = f[i - 1][i - 1] + triangle[i][i];
        }
        return *min_element(f[n - 1].begin(), f[n - 1].end()); 
        //min_element返回 迭代器切片中最小元素的迭代器
    }
};

// 内存优化解法
class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size();
        vector<int> f(n);
        f[0] = triangle[0][0];
        for (int i = 1; i < n; ++i) {
        	// 注意，此处一定要从i往后改变f[]的数值，否则会出错
            f[i] = f[i - 1] + triangle[i][i];
            for (int j = i - 1; j > 0; --j) {
                f[j] = min(f[j - 1], f[j]) + triangle[i][j];
            }
            f[0] += triangle[i][0];
        }
        return *min_element(f.begin(), f.end());
    }
};