• 动规基础
• 509斐波那契数列
• 746使用最小花费爬楼梯
• 62不同路径

写在前面，第二次刷动规，上次就有点没弄懂这次一定拿下了

动规基础

铭记动规五部曲：

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

509斐波那契数列

class Solution {
public:
    //动规解法
    int slnA(int n)
    {
        if(n<=1)
            return n;
        vector<int> dp(n+1);
        dp[0]=0;
        dp[1]=1;
        for(int i=2;i<=n;i++)
        {
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
    //动规解法2
    int slnB(int n)
    {
        if(n<=1)
            return n;
        vector<int> dp(2);
        dp[0]=0;
        dp[1]=1;
        for(int i=2;i<=n;i++)
        {
            int sum=dp[0]+dp[1];
            dp[0]=dp[1];
            dp[1]=sum;
        }
        return dp[1];
    }
    int fib(int n) {
        return slnB(n);
    }
};

746使用最小花费爬楼梯

class Solution {
public:
    //动规思路
    /*
    dp[i]爬上第i层需要的最小体力
    递推公式：
    dp[i]=cost[i]+min(dp[i-1],dp[i])
    初始化
    dp[0]=cost[0],dp[1]=cost[1]
    返回值dp[n-1],dp[n-2]

    */
    int minCostClimbingStairs(vector<int>& cost) {
        int n=cost.size();
        vector<int> dp(n);
        dp[0]=cost[0];
        dp[1]=cost[1];
        for(int i=2;i<n;i++)
        {
            dp[i]=cost[i]+min(dp[i-1],dp[i-2]);

        }
        return min(dp[n-1],dp[n-2]);
    }
};

62不同路径

class Solution {
public:
    /*
    dp[i][j]，到达grid[i][j]有多少种方法
    dp[i][j]=dp[i-1][j]+dp[i][j-1]
    dp[0][i]=dp[j][0]=1
    */
    int slnA(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];
    }
    //只用On/Om的空间复杂度
    int slnB(int m,int n)
    {
        vector<int> dp(n,1);
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[j]=dp[j-1]+dp[j];
            }
        }
        return dp[n-1];
    }
    int uniquePaths(int m, int n) {
        return slnB(m,n);
    }
};