【LeetCode刷题笔记】动态规划

最新推荐文章于 2024-08-06 00:07:27 发布

呆呆的小鸭

最新推荐文章于 2024-08-06 00:07:27 发布

阅读量1.3k

点赞数 42

分类专栏：刷题文章标签： leetcode 笔记动态规划

本文链接：https://blog.csdn.net/baidu_41623370/article/details/138283613

版权

刷题专栏收录该内容

1 篇文章 0 订阅

订阅专栏

【LeetCode刷题笔记】动态规划

动态规划

动态规划的三个性质：

最优化原理（最优子结构性质）：一个最优化策略具有这样的性质，不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。简而言之，一个最优化策略的子策略总是最优的。一个问题满足最优化原理又称其具有最优子结构性质。
无后效性：将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态，它以前各阶段的状态无法直接影响它未来的决策，而只能通过当前的这个状态。换句话说，每个状态都是过去历史的一个完整总结。这就是无后向性，又称为无后效性。
子问题的重叠性：如果有大量的重叠子问题，我们可以用空间将这些子问题的解存储下来，避免重复求解相同的子问题，从而提升效率。本质上，动态规划是一种以空间换时间的技术。

总结：动态规划是一种解决最优化问题的分治思想，将复杂的问题分解成若干个子问题，最优策略的子策略一定是最优的，之后的决策只与当前状态有关，通过记录重复子问题的解达到空间换时间的目的。

1 爬楼梯(70)

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
1 <= n <= 45

1.1 分析

设n阶楼梯的爬楼梯方法有f(n)种，
n=1,f(1)=1
n=2,f(2)=2
n=k,f(k)=f(k-1)+f(k-2) (k>=3)
这是一个斐波那契数列。

1.2 代码

1.2.1 暴力递归

纯递归的方法很简单：

class Solution {
public:
    int climbStairs(int n) {
        if(n==1||n==2)
            return n;
        else
            return climbStairs(n-1)+climbStairs(n-2);
    }
};

没有逻辑错误，但时间复杂度是O(2^n)，当n足够大时，会产生栈溢出。

1.2.2 动态规划

记录每个f(k)的值：

class Solution {
public:
    int climbStairs(int n) {
        if(n==1)
        return 1;
        std::vector<int> resolution(n, 0);
        resolution[0] = 1;
        resolution[1] = 2;
        for(int i=2; i<n; i++){
            resolution[i] = resolution[i-1]+resolution[i-2];
        }
        return resolution[n-1];
    }
};

时间复杂度O(n)，空间复杂度O(n)。
记录f(k-1)和f(k-2)的值：

class Solution {
public:
    int climbStairs(int n) {
        if(n==1||n==2)
            return n;
        else{
            int f1 = 1;
            int f2 = 2;
            int result;
            for(int i=3;i<=n;i++){
                result = f1+f2;
                f1 = f2;
                f2 = result;
            }
            return result;
        }
    }
};

时间复杂度O(n)，空间复杂度O(1)。

1.2.3 排列组合

若n为偶数，最少步数的爬楼梯方法为n/2，若n为奇数，最少步数的爬楼梯方法为(n+1)/2，最多步数的爬楼梯方法都是n。
设步数为m的爬楼梯方法中，其中x步是走二阶的，则(m-x)步是走一阶的步数，2x+m-x = m+x=n，x = n-m。
计算组合数C(m, n-m)，其中最小步数<=m<=n。

组合数计算实现：
组合数计算公式：
C(a,b)=a!/(b!(a-b)!)
组合恒等式：
C(a,b)=C(a-1,b)+C(a-1,b-1)
原代码：

class Solution {
public:
    int combination(int a, int b){
        long long c[a+1][a+1];
        for(int i=0;i<=a;i++)
        {
            for(int j=0;j<=i;j++){
                if(j==0||j==i){
                    c[i][j]=1;
                }
                else{
                    c[i][j]=c[i-1][j-1]+c[i-1][j];
                }
            }
        }
        return c[a][b];
    }
    int climbStairs(int n) {
        int min;
        if(n%2==1){
            min = (n+1)/2;
        }
        else{
            min = n/2;
        }
        int result = 0;
        for(int i=min; i<=n; i++){
            result += combination(i,n-i);
        }
        return result;
    }
};