递推算法及解题套路

递推算法及解题套路

递推基础算法讲解：

斐波那却数列的递推公式：F(n) = F(n-1) + F(n-2)
例题：leetcode-70.爬楼梯

class Solution {
public:
    int climbStairs(int n) {
        // if(n == 1){return 1;}
        // if(n == 2){return 2;}
        // int a = 1, b = 2, temp;
        // for(int i = 3; i <= n; i++){
        //     temp = a;
        //     a = b;
        //     b = temp + b;
        // }
        // return b;   
        vector<int> f(n+1);
        f[0] = 1;//f[0]表示走到第0层的方法总数
        f[1] = 1;
        for(int i=2;i<=n;i++)f[i] = f[i-1]+f[i-2];
        return f[n];
    }
};

数学归纳法：

Step1:验证K0成立
Step2:证明如果Ki成立,那么Ki+1也成立
Step3:联合Step1与Step2，证明由K0->Kn成立

递推程序和数学归纳法的关联
1.这里f[0]和f[1]就相当于K0,
2.从2开始到n结束相当于验证Ki-1到Ki成立
3.因为如果Step1和Step2同时成立那么最后出来的这个结果f[n]一定成立

如何求解递推问题

1、确定递推状态（学习重点）
一个函数符号f(x)，外加这个函数符号的含义描述
一般函数所对应的值，就是要求解的值
2、确定递推公式（Ki->Ki+1）
	确定f(x)究竟依赖于哪些f(y)的值
3、分析边界条件（K0）
4、程序实现 递归 || 循环

递推与动归：关系：
动归就是求解最优化问题的递推问题 它们之间的差距就是决策过程

leetcode-256. 粉刷房子

class Solution {
public:
    int minCost(vector<vector<int>>& costs) {
        int n = costs.size();
        vector<vector<int>> dp;
        for(int i=0;i<2;i++)dp.push_back(vector<int>(3));

        //初始化第一间房间花费的成本
        for(int i=0;i<3;i++)dp[0][i] = costs[0][i];

        //从第二个房子开始求最小花费
        for(int i=1;i<n;i++){
            int ind = i%2;
            int pre_ind = !ind;
            dp[ind][0] = min(dp[pre_ind][1],dp[pre_ind][2])+costs[i][0];
            dp[ind][1] = min(dp[pre_ind][0],dp[pre_ind][2])+costs[i][1];
            dp[ind][2] = min(dp[pre_ind][0],dp[pre_ind][1])+costs[i][2];
        }    
        int ind = (n-1)%2;
    return min(dp[ind][0],min(dp[ind][1],dp[ind][2]));
    }
};

leetcode-120. 三角形最小路径和

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n=triangle.size();
        vector<vector<int>> dp;
        //创建两列长度为n的数组
        for(int i=0;i<2;i++)dp.push_back(vector<int>(n));
        //因为是从下往上初始化 先最后一行每一个元素的值
        for(int i=0;i<n;i++)dp[(n-1)%2][i] = triangle[n-1][i];
        for(int i=n-2;i>=0;--i){
            //滚动数组技巧
            int ind = i%2;
            int next_ind = !ind;
            for(int j=0;j<=i;j++){
                dp[ind][j]=min(dp[next_ind][j],dp[next_ind][j+1])+triangle[i][j];
            }
        }
        return dp[0][0];
    }
};

leetcode-119. 杨辉三角 II

class Solution {
public:
    vector<int> getRow(int rowIndex) {
//存储两行数组即可
    int n=rowIndex+1;
    vector<vector<int>> f;
    for(int i=0;i<2;i++)f.push_back(vector<int>(n));
    for(int i=0;i<n;i++){
        int ind = i%2;
        int pre_ind = !ind;
        f[ind][0] = 1;
        for(int j=1;j<=i;j++){
            f[ind][j] = f[pre_ind][j-1]+f[pre_ind][j];
        }
    }
    return f[(n-1)%2];

    }
};

leetcode-53. 最大子序和

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        for(int i=1;i<nums.size();i++)nums[i]+=nums[i-1];
        int pre = 0, ans = INT_MIN;
        for(auto num:nums){
            ans = max(ans,num-pre);
            pre = min(pre,num);
        }
        return ans;
    }
};

leetcode-122. 买卖股票的最佳时机 II

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int ans = 0;
        for(int i=1;i<prices.size();i++){
            if(prices[i]>prices[i-1])ans += prices[i]-prices[i-1];
        }
        return ans;
    }
};

leetcode-198. 打家劫舍

class Solution {
public:
//dp[n][1/0]表示第n家偷或不偷的最大收益
//dp[n][0] = max(dp[n-1][1],dp[n-1][0])
//dp[n][1] = dp[n-1][0]+nums[n]
    int rob(vector<int>& nums) {
        vector<vector<int>>dp;
        int n=nums.size();
        for(int i=0;i<n;i++)dp.push_back(vector<int>(2));
        dp[0][0] = 0,dp[0][1] = nums[0];
        for(int i=1;i<n;i++){
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]);
            dp[i][1] = dp[i-1][0]+nums[i];
        }
        return max(dp[n-1][0],dp[n-1][1]);//返回的最后一个值就是最后一家到底偷还是不偷
    }
};

leetcode-152. 乘积最大子数组

class Solution {
public:
//dp[n] = max(nums[n],dp[n-1]*nums[n])
    int maxProduct(vector<int>& nums) {
        int ans = INT_MIN,max_num=1,min_num=1;
        for(auto x:nums){
            if(x<0) swap(max_num,min_num);
            max_num = max(x*max_num,x);
            min_num = min(x*min_num,x);
            ans = max(ans,max_num);
        }
        return ans;
        
    }
};

leetcode-322. 零钱兑换

class Solution {
public:
//dp[n]=p 表示拼凑n大小的面额最少所需要的的面额数
//也就是dp[n] = min(dp[n-Vi]+1) ,Vi表示第i种钱币的面额 ,但要确保dp(Vi)状态可达
    int coinChange(vector<int>& coins, int amount) {
        vector<int>dp(amount+1);
        dp[0] = 0;
        //设定不可达的值为-1
        for(int i=1;i<=amount;i++)dp[i] = -1;
        for(int i=1;i<=amount;i++){
            for(auto x:coins){
                if(i<x)continue;
                if(dp[i-x]==-1)continue;
                if(dp[i] == -1 || dp[i]>dp[i-x]+1)dp[i]=dp[i-x]+1;
            }
        }
        return dp[amount];
    }
};

leetcode-300. 最长递增子序列

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
//dp[n]代表以n作为结尾，最长递增子序列的长度
        vector<int>dp(nums.size());
        int ans=0;
        for(int i=0;i<nums.size();i++){
            dp[i] = 1;
            for(int j=0;j<i;j++){
                if(nums[i]<=nums[j]) continue;//因为要求的是严格的递增所以数组中不能出现等于的现象
                dp[i] = max(dp[i],dp[j]+1);
            }
            ans = max(dp[i],ans);
        }
        return ans;
    }
};

企业永远是用人所长，学习永远是补己之短
写在最后
1.正确的行动之前，是正确的价值判断
2.价值提升最主要的关注点放在【提升单位时间价值】
3.打造自己的第二专用技能，形成技能上的稀缺壁垒