五月集训（第28天）——动态规划题解

一、前言

     一转眼大一学年马上就要结束，但受到疫情影响以及自己的自律性，对算法的学习一直止步不前。五月中旬加入星球以来跟着大家一起学习算法，有很多自己之前会的，也有很多之前没领悟透彻的，今天起决定开始写每日题解，帮助自己在 $AC$ 后深入理解知识。

二、今日题解

1）、爬楼梯

     这道题是一道非常简单的入门题，很早以前就已经做过，但是受限于当时对动态规划的理解不够透彻，今天再做这道题又感觉磕磕绊绊的，所以决定重温一下。

题目：假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
 
示例：
输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

开始忘记状态转移方程怎么写了，写个$DFS$吧。

class Solution {
public:
int sum=0;
    void dfs(int n,int step){
        if(step==n){
            sum++;
            return;
        }else if(step>n){
            return;
        }

        for(int i=1;i<=2;i++){
            dfs(n,step+i);
        }
    }
    int climbStairs(int n) {
            dfs(n,0);
        return sum;
    }
};

这种方法会造成大量的无用搜索，导致时间超限……

好吧，所以我用动态规划写个正确的。

class Solution {
public:
    int f[46];
    int dp(int n){
        if(n<=2){
            return n;
        }
        if(f[n]==0){
            f[n]=dp(n-1)+dp(n-2);
         
        }
        return f[n];
    }
    int climbStairs(int n) {
        return dp(n);
    }
};

    要求$n$阶楼梯的方法，所以传入函数$dp$中，然后通过if(f[n]==0)不断压入栈中，直到n=1或n=2就返回，如此不断得到f(n)这样每一次都是由上一次结果得到，不会出现$DFS$里的无用递归。

2）、最大子数和

题目：给你一个整数数组 nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。
 
示例：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

方法一 —— 贪心

#define maxn 100002
#define ll long long
class Solution {
public:

    int ans ;
    ll fsum[maxn];
     int max=-100000;
    int maxSubArray(vector<int>& nums) {
        
        for(int i=0;i<nums.size();i++){
         
         if(i>0&&fsum[i-1]>0){
             fsum[i]+=nums[i]+fsum[i-1];
         }else{
             fsum[i]+=nums[i];
         }
         if(max<fsum[i]){
             max=fsum[i];
         }
            cout<<fsum[i]<<" ";
         }
         return max>fsum[0]?max:fsum[0];
        }
        
};

方法二 —— 动态规划

#define maxn 100002
#define ll long long
class Solution {
public:

    int ans ;
     
     int max=-100000;
    int maxSubArray(vector<int>& nums) {
        
        for(int i=1;i<nums.size();i++){
            nums[i-1]>0?nums[i]+=nums[i-1]:nums[i]+=0;
            max>nums[i]?max:max=nums[i];
        } 
        return max>nums[0]?max:nums[0];
    }

};

总结：其实这题 动态规划和贪心从本质来讲都是一样的过程。

3）、球会落何处

题目：     用一个大小为 m x n 的二维网格 grid 表示一个箱子。你有 n 颗球。箱子的顶部和底部都是开着的。
箱子中的每个单元格都有一个对角线挡板，跨过单元格的两个角，可以将球导向左侧或者右侧。
将球导向右侧的挡板跨过左上角和右下角，在网格中用 1 表示。
将球导向左侧的挡板跨过右上角和左下角，在网格中用 -1 表示。
在箱子每一列的顶端各放一颗球。每颗球都可能卡在箱子里或从底部掉出来。如果球恰好卡在两块挡板之间的 “V” 形图案，或者被一块挡导向到箱子的任意一侧边上，就会卡住。
返回一个大小为 n 的数组 answer ，其中 answer[i] 是球放在顶部的第 i 列后从底部掉出来的那一列对应的下标，如果球卡在盒子里，则返回 -1 。

输入：grid = [[1,1,1,-1,-1],[1,1,1,-1,-1],[-1,-1,-1,1,1],[1,1,1,1,-1],[-1,-1,-1,-1,-1]]
输出：[1,-1,-1,-1,-1]
解释：示例如图：
b0 球开始放在第 0 列上，最终从箱子底部第 1 列掉出。
b1 球开始放在第 1 列上，会卡在第 2、3 列和第 1 行之间的 “V” 形里。
b2 球开始放在第 2 列上，会卡在第 2、3 列和第 0 行之间的 “V” 形里。
b3 球开始放在第 3 列上，会卡在第 2、3 列和第 0 行之间的 “V” 形里。
b4 球开始放在第 4 列上，会卡在第 2、3 列和第 1 行之间的 “V” 形里。

写了好久写不出来，参考知识星球的知友秋刀鱼的题解写出来的，不得不说这道题他的代码简单易懂效率高！

class Solution {
public:
    int Row,Col;
    vector<int >ans;
    int dfs(vector<vector<int>>& grid,int row,int col){
        while(row<Row&&col<Col){
            int dir=grid[row][col];
            if((dir==-1&&col==0)||(dir==1&&col==Col-1)||dir!=grid[row][col+dir])
            return -1;
            row++;
            col+=dir;
        }
        return col;
       
    }
    vector<int> findBall(vector<vector<int>>& grid) {
        Row=grid.size();
        Col=grid[0].size();
        for(int i=0;i<Col;i++){
            ans.push_back(dfs(grid,0,i));
        }
        return ans;
    }
};

以下是一段有疑问的代码，稍后有时间再纠正

class Solution {
public:
    int Row,Col;
    vector<int >ans;
    int dfs(vector<vector<int>>& grid,int row,int col){
            int dir=grid[row][col];
        if((dir==-1&&col==0)||(dir==1&&col==Col-1)||dir!=grid[row][col+dir])
            return -1;
        else dfs(grid,row+1,col+dir);
          return col;
    }
    vector<int> findBall(vector<vector<int>>& grid) {
        Row=grid.size();
        Col=grid[0].size();
        for(int i=0;i<Col;i++){
            ans.push_back(dfs(grid,0,i));
        }
        return ans;
    }
};

4)、生成数组

这道题比较难，而且没时间了，挖个坑日后再补上！