【算法】动态规划

最新推荐文章于 2023-12-26 19:54:50 发布
最新推荐文章于 2023-12-26 19:54:50 发布
阅读量312 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Protocols7/article/details/103934653
版权

动态规划

509.Fibonacci numbers

O ( 2 n ) O(2^n) O(2n)

int fib(int n){
	return n <= 1 ? n : fib(n - 1) + fib(n - 2);
}

O ( n ) O(n) O(n)

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

更好的方法：

class Solution {
public:
    int fib(int n) {
        if(n <= 1) return n;
        int a = 0, b = 1,c = 0;
        for(int i = 2; i <= n; ++i){
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
};

70. Climbing Stairs

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct wayscan you climb to the top?

Note: Given n will be a positive integer.
Input: 3
Output: 3
Explanation: There are three ways to climb to the top.

  1. 1 step + 1 step + 1 step
  2. 1 step + 2 steps
  3. 2 steps + 1 step

找出递推公式 f ( n ) = f ( n − 1 ) + f ( n − 2 ) f(n) = f(n-1)+f(n-2) f(n)=f(n−1)+f(n−2)，发现就是斐波那契数列，解法同上。

120. Triangle

Given a triangle, find the minimum path sum from top to bottom. Eachstep you may move to adjacent numbers on the row below.
在这里插入图片描述The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).

  • 暴力法（DFS） O ( 2 n ) O(2^n) O(2n)，在超大用例下会超内存。
#include <iostream>
#include <vector>
using namespace std;
class Solution
{
public:
    vector<vector<int>> ans;
    int minimumTotal(vector<vector<int>> &triangle){
        vector<int> path(triangle.size(),0);//初始化棋盘
        path[0] = {triangle[0][0]};
        helper(1,0,path,triangle);
        int min = INT32_MAX;
        for(auto i : ans){
            int sum = 0;
            for(auto j : i){
                sum += j;
            }
            if(sum < min){
                min = sum;
            }
        }
        return min;
    }
    void helper(int level,int pos,vector<int> &path,vector<vector<int>> &triangle){
        if(level == triangle.size()) {
            ans.push_back(path);
            return;
        }
        path[level] = triangle[level][pos];
        helper(level+1,pos,path,triangle);
        path[level] = triangle[level][pos+1];
        helper(level+1,pos+1,path,triangle);
    }
};
void outPut(vector<vector<int>> &triangle){
    for(auto i : triangle){
        for(auto j : i){
            cout<<j<<" ";
        }
        cout<<endl;
    }
}
int main()
{
    vector<vector<int>> tri;
    tri.push_back({2});
    tri.push_back({3,4});
    tri.push_back({6,5,7});
    tri.push_back({4,1,8,3});
    Solution s;
    cout<<s.minimumTotal(tri)<<endl;
    outPut(s.ans);
    getchar();
    return 0;
}

其实只需要记录路径和，不需要求所有路径，所以程序还能优化。

static int min=INT_MAX ;
int DFS(int** t,int row,int col,int cur,int RowSize){//深度优先来穷举，O(2的n次方)超时
     if(row==RowSize){
        min=cur<min?cur:min;
        return 1;
    }
    cur+=*(*(t+row)+col);
    DFS(t,row+1,col,cur,RowSize);
    DFS(t,row+1,col+1,cur,RowSize);
    return min;
}
  • DP O ( n ) O(n) O(n)
    • 定义状态：DP[i][j]表示从底部到tri[i][j]的最短距离，那么DP[0][0]为题解。
    • 写出方程： D P [ i ] [ j ] = m i n ( D P [ i + 1 ] [ j ] , D P [ i + 1 ] [ j + 1 ] ) + t r i [ i ] [ j ] DP[i][j]=min(DP[i+1][j],DP[i+1][j+1])+tri[i][j] DP[i][j]=min(DP[i+1][j],DP[i+1][j+1])+tri[i][j]

这里注意一定要给DP数组初始化，且其大小稍大于实际空间，不然会出bug:

    int minimumTotal(vector<vector<int>> &triangle)
    {
        int last = triangle.size() - 1;
        //记住下面的初始化方法
        vector<vector<int>> DP(last+1,vector<int>(last+1,0));
        DP[last] = triangle[last];
        for(int i = last - 1;i >= 0;i--){
            for(int j = 0;j < triangle[i].size();j++){
                DP[i][j] = min(DP[i+1][j],DP[i+1][j+1]) + triangle[i][j];
            }
        }
        return DP[0][0];
    }

53. 最大子序和（经典题）

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
状态方程如下（将就看看。。）

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

在这里插入图片描述
又由于dp备忘录数据不需要保存，只会用到最后一个值，所以可以将dp数组变为一个变量。优化很大。

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

在这里插入图片描述

152.乘积最大子序列

在这里插入图片描述

  • 暴力，求出所有子序列，再算出他们的值。
  • DP
    • 定义状态：DP[0][i]表示第i个元素为子序列末尾元素时，的最大正乘积。DP[1][i]表示第i个元素为子序列末尾元素时，的最大负乘积。所以题解为DP数组中所有元素最值
    • 写出方程：
      • A[i]大于0时，DP[0][i] = DP[0][i-1]*A[i]、DP[1][i] = DP[1][i-1]*A[i]
      • A[i]小于0时，DP[0][i] = DP[1][i-1]*A[i] 、DP[1][i] = DP[0][i-1]*A[i]
      • A[I]等于0时，不知道怎么办了。看了下评论区知道用max、min函数是坠吼的
    • 重新写方程：

D P [ 0 ] [ i ] = m y M a x ( D P [ 0 ] [ i − 1 ] ∗ n u m s [ i ] , D P [ 1 ] [ i − 1 ] ∗ n u m s [ i ] , n u m s [ i ] ) ; D P [ 1 ] [ i ] = m y M i n ( D P [ 0 ] [ i − 1 ] ∗ n u m s [ i ] , D P [ 1 ] [ i − 1 ] ∗ n u m s [ i ] , n u m s [ i ] ) ; DP[0][i] = myMax(DP[0][i-1]*nums[i],DP[1][i-1]*nums[i],nums[i]);\\ DP[1][i] = myMin(DP[0][i-1]*nums[i],DP[1][i-1]*nums[i],nums[i]); DP[0][i]=myMax(DP[0][i−1]∗nums[i],DP[1][i−1]∗nums[i],nums[i]);DP[1][i]=myMin(DP[0][i−1]∗nums[i],DP[1][i−1]∗nums[i],nums[i]);

class Solution {
public:
    int myMax(int a,int b,int c){
        return max(max(a,b),c);
    }
    int myMin(int a,int b,int c){
        return min(min(a,b),c);
    }
    int maxProduct(vector<int>& nums) {
        int max = INT32_MIN;
        vector<vector<int>> DP(2,vector<int>(nums.size(),0));
        DP[1][0] = DP[0][0] = nums[0];    
        for(int i = 1;i<nums.size();i++){
            DP[0][i] = myMax(DP[0][i-1]*nums[i],DP[1][i-1]*nums[i],nums[i]);
            DP[1][i] = myMin(DP[0][i-1]*nums[i],DP[1][i-1]*nums[i],nums[i]);
        }
        for(auto i : DP[0]){
            max = max>i?max:i;
        }
        return max;
    }
};

买卖股票系列

题号买卖次数
122无数次
1211次
1232次
188k次
309买卖之间有cd
714每次买卖收手续费

无数次

  • 定义状态
    max_profit二维数组作为DP数组。MP[i][j]表示到第i天结束时已经赚取的最大利润，此时j=0表示未持股，j=1表示持股。
  • 写出状态转移方程
    • MP[i][0] = max(MP[i-1][0],MP[i-1][1]+nums[i])
    • MP[i][1] = max(MP[i-1][1],MP[i-1][0]-nums[i])

执行用时 :8 ms, 在所有 C++ 提交中击败了72.96%的用户
内存消耗 :11.9 MB, 在所有 C++ 提交中击败了5.03%的用户

    int maxProfit(vector<int>& prices) {
        if(prices.size()<=1) return 0;
        int len = prices.size();
        vector<vector<int>> MP(len,vector<int>(2,0));
        MP[0][1] =-prices[0];//这里注意下初值
        MP[0][0] = 0;
        for(int i = 1;i < len;i++){
            MP[i][0] = max(MP[i-1][0],MP[i-1][1]+prices[i]);
            MP[i][1] = max(MP[i-1][1],MP[i-1][0]-prices[i]);
        }
        return MP[len-1][0];
    }

有限次

用DP解问题时，如果发现很难写出状态方程， 那么尝试加一个状态。本题用MP[i][j][k]中的k表示已经买卖了k次。注意只有买入时才算一次交易，卖出时不算交易次数。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int K=2;//或K=2解决121题
        if(prices.size()<=1) return 0;
        int len = prices.size();
        vector<vector<vector<int>>> MP(len,vector<vector<int>>(K+1,vector<int>(2,0)));
        for(int k = K;k>0;k--){
            MP[0][k][1] =-prices[0];
            MP[0][k][0] = 0;
        }
        for(int i = 1;i < len;i++){
            for(int k = K;k > 0;k--){
                MP[i][k][0] = max(MP[i-1][k][0],MP[i-1][k][1]+prices[i]);
                MP[i][k][1] = max(MP[i-1][k][1],MP[i-1][k-1][0]-prices[i]);    
            }
        }
        return MP[len-1][K][0];
    }
};

现在已经解决了一次、两次、无数次的题。K次的出bug，还有其他的题挖坑，需要学习这篇文章。

376 摆动序列

由于情况特殊，可以用贪心做：

int wiggleMaxLength(vector<int> &nums)
 {
     if (nums.size() < 2)
         return nums.size();
     int p = 0;
     //去除重复元素
     while (p < nums.size() - 1 and nums[p + 1] == nums[p])
     {
         p++;
     }
     if (p == nums.size() - 1)
         return 1;
     int res;
     bool f = nums[p + 1] > nums[p]; //求初始方向
     p++;
     int cnt = 2;
     while (p < nums.size() - 1)
     {
         res = nums[p + 1] - nums[p];
         if (f)
         {
             if (res < 0)
             {
                 cnt++;
                 f = !f;
             }
         }
         else
         {
             if (res > 0)
             {
                 cnt++;
                 f = !f;
             }
         }
         p++;
     }
     return cnt;
 }

这题是贪心的题，用DP做思维上麻烦了，代码上却有种对称的美。参见我做的最长公共子序列这道题，定义应该是这样：

  • dp[i][0]表示以第i个元素结尾且期望匹配比尾值大的值时的最大值
  • dp[i][1]表示以第i个元素结尾且期望匹配比尾值小的值时的最大值
  • dp值为0表示不可能有这种情况。比如1 2这个序列，dp[1][1]应该为0

解释：

  1. 分析题意，结果必然是将第一个元素作为子序列开头元素，所以无需额外维度保存起始位置。
  2. 但由于状态方程向后递推，必须知道此时尾节点是哪个才能推出下一个的值，所以需要一个维度记录尾节点位置。
  3. 由于本题的特殊性，需要一个维度记录当前欲匹配元素类型。

方程应该这样写：(有点难写啊。。写了几个小时)

int wiggleMaxLength(vector<int> &nums)
{
    if (nums.size() == 0)
        return 0;
    vector<vector<int>> dp(nums.size(), vector<int>(2, 0));
    dp[0][0] = dp[0][1] = 1;
    for (int i = 1; i < nums.size(); i++)
    {
        dp[i][0] = nums[i - 1] > nums[i] ? max(dp[i - 1][1] + 1, dp[i - 1][0]) : 0;
        dp[i][1] = nums[i - 1] < nums[i] ? max(dp[i - 1][0] + 1, dp[i - 1][1]) : 0;
        if (nums[i - 1] == nums[i])
        {
            dp[i][0] = dp[i - 1][0];
            dp[i][1] = dp[i - 1][1];
        }
    }
    return max(dp[nums.size() - 1][0], dp[nums.size() - 1][1]);
}

为什么状态方程中有个max？想想1212123这个序列，匹配到3时有两种选择

  1. 放弃之前的结果，选择将2和3放进结果中，加1：dp[i - 1][1] + 1 = 2
  2. 保留之前的结果，放弃3：dp[i - 1][0] = 6

肯定是选择2赚。那如果是12322呢，就应该放弃之前的结果，选择232这个序列也就是方法一。所以要max函数求最大值。

如果是最长子串（连续子序列）的话，b[i]=b[i-1]时等于1即可。

海边的西西弗斯
关注
专栏目录
[C++从入门到放弃] 通过使用auto完成类型自动推导以及Range-Based for来更便捷的编程
AliceZyxw的博客
04-14 432
以auto完成类型自动推导 1、auto的使用场景 在C++11中允许声明一个变量或者对象（object）而不需要指明其类型，只需要使用auto ✅auto i = 42; //i has type int int x = 520; ✅auto p = &x; ✅auto* p = &x; ❌声明引用类型时要加& ✅auto& q = x; ...
最短路径Floyd算法动态规划问题及其程序设计样本.doc
08-03
"Floyd算法动态规划问题及其程序设计样本" 本文通过对Floyd算法的研究，设计了一种动态规划问题的解决方案，并提供了相应的程序设计样本。Floyd算法是一种常用的最短路径算法，对于给定的有向图，可以求解出每一对...
leetcode刷题之递归，回溯和分治
m0_37327467的博客
03-15 400
78. 子集 给定一组不含重复元素的整数数组nums，返回该数组所有可能的子集（幂集）。 说明：解集不能包含重复的子集。 示例: 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ] python解答： 思路一：利用递归和回溯的思想。 ...
leetcode解题思路分析（十八）120 - 126题
ty的博客
03-28 257
三角形最小路径和 给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。 采用动态规划求解，可以自顶向下也可以自底向上 方法一 递归&&备忘录递归 超时 递归 class Solution { public: int minimumTotal(vector<vector<int>>& triangle) { ...
算法-动态规划 Dynamic Programming--从菜鸟到老鸟
热门推荐
有图有真相
07-15 46万+
前言最近在牛客网上做了几套公司的真题，发现有关动态规划（Dynamic Programming）算法的题目很多。相对于我来说，算法里面遇到的问题里面感觉最难的也就是动态规划（Dynamic Programming）算法了，于是花了好长时间，查找了相关的文献和资料准备彻底的理解动态规划（Dynamic Programming）算法。一是帮助自己总结知识点，二是也能够帮助他人更好的理解这个算法。后面的参
算法之动态规划
一名在校大三学习JAVA
07-14 9337
目录什么是动态规划 概念动态规划的特点动态规划的写法适用的场景何时使用动态规划核心套路区别 斐波那契理解动态规划 换零钱问题 区别 分治和动态规划 贪心和动态规划
动态规划算法
Allence的博客
04-08 2万+
一、动态规划算法思想 动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，
【动态规划】动态规划算法基本概念，原理应用和示例代码
qq_35831906的博客
11-12 1万+
动态规划（Dynamic Programming，简称DP）是一种解决多阶段决策问题的数学优化方法。它将原问题分解成若干个子问题，通过解决子问题只需解决一次并将结果保存下来，从而避免了重复计算，提高了算法效率。通俗来讲，动态规划算法是解决一类具有重叠子问题和最优子结构性质的问题的有效方法。其基本原理是将大问题分解为小问题，通过保存中间结果来避免重复计算，从而提高算法的效率。动态规划主要包括两个要素：最优子结构和重叠子问题。
动态规划算法思想讲解
总裁余（余登武）博客
12-26 1497
动态规划（Dynamic Programming，简称DP）是一种解决问题的算法思想，它将一个大问题拆分成多个相互重叠的子问题，并且通过解决这些子问题来求解原始问题。
动态规划和贪心算法
dzy521的博客
04-02 1万+
动态规划问题的第二个性质是子问题空间必须足够“小”，也就是说，问题的递归算法会求解相同的子问题，而不是一直生成新的子问题（分治法求解的问题在每一步递归都生成全新的子问题），由于子问题的求解依赖于更小的子问题的求解，我们将子问题的规模按大小排序，按由小至大的顺序进行求解，这样在求解某一个子问题时会依赖于上一个求解的子问题。两个问题都用到了子问题，而最长简单子路径的子问题是相关的，而最短路径的子问题是无关的，这里无关是指：同一个原问题的一个子问题不影响另一个子问题的解。
贪心算法及动态规划法_贪心算法动态规划法_
10-03
贪心算法与动态规划是计算机科学中解决优化问题的两种重要策略，它们在解决复杂问题时各有优势。本文将深入探讨这两种方法的原理、应用场景及其相互关系。 **贪心算法** 是一种解决问题的方法，它每次做出当前状态...
九章算法动态规划学习课件
最新发布
08-25
九章算法动态规划学习课件 九章动态规划3序列型pdf 九章动态规划5背包型8区间 型pdf 九章动态规划6双序列型Pdf
【数据结构】贪心算法和动态规划 贪心算法和动态规划.pdf
04-08
贪心算法和动态规划是两种常用的算法设计方法，它们都可以用来解决优化问题，但它们的解决思路和应用场景不同。 贪心算法是一种解决优化问题的算法，通过在每一步都做出当前看起来最优的选择，来获取全局最优解。...
tbd算法动态规划实现
01-30
用动态规划算法实现检测前跟踪。其中包含了仿真场景的设置，主要参考了D.J.Samlond的a partilce filter for track-before-detect文章中的仿真场景和目标量测模型，动态规划算法的实现主要参照了电子科技大学易伟博士...
【算法】贪心&BFS&DFS
日拱一卒，功不唐捐。
02-27 1793
贪心算法是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。BFS广度优先，DFS深度优先。
Leetcode c++ 加速代码
日拱一卒，功不唐捐。
01-14 1746
static int n=[](){ std::ios::sync_with_stdio(false); std::cin.tie(nullptr); return 0; }(); 在一位大佬的朋友圈看到的，把这段代码放在开头，试了下真的有用。 原因不知道，好像是异步io减少了阻塞的时间。。。...
约瑟夫环问题
日拱一卒，功不唐捐。
02-09 571
约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3，1。
最大子数组问题算法比较
日拱一卒，功不唐捐。
02-08 533
title: 最大子数组问题算法比较 date: 2019-02-08 17:23:34 tags: Algorithms 《算导》4.1-3。将暴力法和分治法进行比较。 首先定义结构体： typedef struct { int left; int right; int max; }ans; 产生随机数组以供测试 #include &lt;time.h&gt; #define ran...
Warshall算法动态规划
05-16
Warshall算法是一种动态规划算法，用于求解有向图的传递闭包。传递闭包是指对于有向图中的任意两个顶点，如果存在一条路径从其中一个顶点到达另一个顶点，则称这两个顶点具有传递性关系。而传递闭包则是指将所有具有传递性关系的顶点对进行连接所形成的有向图。 Warshall算法的基本思想是通过迭代的方式，不断更新传递闭包的矩阵。具体来说，对于每一个矩阵元素a[i][j]，如果存在一个中间顶点k，使得a[i][k]和a[k][j]均为1，则将a[i][j]更新为1。这个过程可以用动态规划的思想来解释，即利用之前的计算结果来推导出新的结果。 Warshall算法的时间复杂度为O(n^3)，其中n为有向图中顶点的数量。在实际应用中，Warshall算法常被用于路由算法、可达性分析等领域。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值