动态规划

最新推荐文章于 2024-05-23 11:00:57 发布

风筝_

最新推荐文章于 2024-05-23 11:00:57 发布

阅读量279

点赞数

分类专栏：玩转算法面试-LeetCode真题分门别类讲解文章标签：动态规划

本文链接：https://blog.csdn.net/m0_38062470/article/details/114624780

版权

玩转算法面试-LeetCode真题分门别类讲解专栏收录该内容

28 篇文章 0 订阅

订阅专栏

剑指offer 10-I 斐波那契数列

方法1：动态规划自底向上

memo[i]表示总共有i个台阶时，共有多少中方法

class Solution {
public:
    int fib(int n) {
        vector<int > memo(n+1,-1);
        if(n==0)
            return 0;
        memo[0]=0;
        memo[1]=1;
        if(n==0)
            return 0;
        if(n==1)
            return 1;
        for(int i=2;i<=n;i++)
        {
            memo[i]=(memo[i-1]+memo[i-2])%1000000007;
        }
        return memo[n];

    }
};

方法2：递归，自顶向下 +记忆化搜索

class Solution {
public:
    vector<int> memo;
    int _fib(int n)
    {
        if(n==0)
            return 0;
        if(n==1)
            return 1;
        if(memo[n]==-1)
            memo[n]=(_fib(n-1)+_fib(n-2))%1000000007;
        return memo[n];
    }
    int fib(int n) {
        memo=vector<int> (n+1,-1);
        return _fib(n);
    }
};

方法3：循环用两个变量保存前两个结果

class Solution {
public:
    int fib(int n) {
        int f0=0;
        int f1=1;
        if(n==0) return f0;
        if(n==1) return f1;
        for(int i=2;i<=n;i++)
        {  //更新f0 f1
            int temp=(f0+f1)%1000000007;
            f0=f1;
            f1=temp;
        }
        return f1;
    }
};

力扣120 三角形最小路径和

方法1：使用二维数组

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size();
        vector<vector<int>> dp(n, vector<int>(n));
        // 初始化
        dp[0][0] = triangle[0][0];

        for (int i = 1; i < n; ++i) 
        {
            // 每一行最左侧的元素
            dp[i][0] = dp[i - 1][0] + triangle[i][0];
            for (int j = 1; j < i; ++j)
                dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j]) + triangle[i][j];
            // 每一行最右侧的元素
            dp[i][i] = dp[i - 1][i - 1] + triangle[i][i];
        }
        return *min_element(dp[n - 1].begin(), dp[n - 1].end());
    }
};

方法2：使用两个一维数组

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size();
        vector<vector<int>> dp(2,vector<int>(n));
        // 初始化
        dp[0][0]= triangle[0][0];

        for (int i = 1; i < n; ++i) 
        {
            int cur=i%2;
            int pre=1-cur;
            // 每一行最左侧的元素
            dp[cur][0] = dp[pre][0] + triangle[i][0];
            for (int j = 1; j <i; ++j)
                dp[cur][j] = min(dp[pre][j - 1], dp[pre][j]) + triangle[i][j];
            
            // 每一行最右侧的元素
            dp[cur][i] = dp[pre][i - 1] + triangle[i][i];
        }
        return *min_element(dp[(n-1)%2].begin(), dp[(n-1)%2].end());
    }
};

方法3：使用一个一维数组

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size();
        vector<int> dp(n,0);
        // 初始化
        dp[0]= triangle[0][0];

        for (int i = 1; i < n; ++i) 
        {
            // 每一行最右侧的元素
            dp[i] = dp[i - 1] + triangle[i][i];
            for (int j = i-1; j >0; --j)
                dp[j] = min(dp[j - 1], dp[j]) + triangle[i][j];
            // 每一行最左侧的元素
            dp[0] = dp[0] + triangle[i][0];
        }
        return *min_element(dp.begin(), dp.end());
    }
};

力扣64.最小路径和

方法1：动态规划，使用二维数组

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>> num(m,vector<int>(n));
        num[0][0]=grid[0][0];
        for(int i=1;i<n;i++)  //初始化第一行
        {
            num[0][i]=num[0][i-1]+grid[0][i];
        }
        for(int i=1;i<m;i++)  //初始化第1列
        {
            num[i][0]=num[i-1][0]+grid[i][0];
        }
        for(int i=1;i<m;i++)  //第i行
        {
            for(int j=1;j<n;j++) //第j列
            {
                num[i][j]=min(num[i-1][j],num[i][j-1])+grid[i][j];
            }
        }
        return num[m-1][n-1];
    }
};

方法2：使用一维数组

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