【算法与实现】动态规划(基本思想)

最新推荐文章于 2023-11-12 18:19:24 发布
最新推荐文章于 2023-11-12 18:19:24 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： 算法与实现 文章标签： 学习笔记 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fyfmfof/article/details/41606781
版权

动态规划(基本思想)

一、动归的基本思路

 

案例：数字三角形 POJ1163


在上面的数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或右下走。只需要求出这个最大和即可，不必给出具体路径。

 

思路：如果简单的用递归的方法来实现效率，在提交时会超时，应为不做任何处理的递归中进行了太多的重复计算，解决方法有2个，一个是记忆型递归，就是将递归中计算的值都用一个数组存起来再次计算就直接读取即可，如下：

#include <cstdio>
#include <iostream>
using namespace std;
 
#define MAX 102
 
int num[MAX][MAX];
int MaxNum[MAX][MAX];
int n;
 
int maxNum(int i,int j)
{
       if(MaxNum[i][j]!=-1)
              returnMaxNum[i][j];
       if(i==n)
              return num[i][j];
       MaxNum[i+1][j]=maxNum(i+1,j);
       MaxNum[i+1][j+1]=maxNum(i+1,j+1);
       if(MaxNum[i+1][j]>MaxNum[i+1][j+1])
              return MaxNum[i+1][j]+num[i][j];
       else
              returnMaxNum[i+1][j+1]+num[i][j];
}
 
int main()
{
       inti,j;
       scanf("%d",&n);
       for(i=1;i<=n;i++)
              for(j=1;j<=i;j++)
              {
                     scanf("%d",&num[i][j]);
                     MaxNum[i][j]=-1;
              }
       printf("%d\n",maxNum(1,1));
       return 0;
}

还有一种就是用循环的方式进行递归，而且可以在空间上做到一定的优化，如下：

#include <iostream>
#include <cstdio>
using namespace std;
 
#define MAX 101
 
int num[MAX][MAX];
int n;
int MaxNum[MAX];//使用一维数组循环递推
 
void maxNum()
{
       inti,j;
       for(j=1;j<=n;j++)
              MaxNum[j]=num[n][j];
       for(i=n;i>1;i--)
              for(j=1;j<n;j++)
              {
                     if(MaxNum[j]>MaxNum[j+1])
                            MaxNum[j]=MaxNum[j]+num[i-1][j];
                     else
                            MaxNum[j]=MaxNum[j+1]+num[i-1][j];
              }
}
 
int main()
{
       scanf("%d",&n);
       inti,j;
       for(i=1;i<=n;i++)
              for(j=1;j<=i;j++)
                     scanf("%d",&num[i][j]);
       maxNum();
       printf("%d\n",MaxNum[1]);
       return 0;
}

以上面的例子可以列出来动态规划解题的一般思路，如下：

 

1. 将原问题分解为子问题

把原问题分解为若干个子问题，子问题和原问题形式相同或类似，只不过规模变小了。子问题都解决，原问题即解决(数字三角形例）。

子问题的解一旦求出就会被保存，所以每个子问题只需求解一次。

 

2. 确定状态

所有“状态”的集合，构成问题的“状态空间”。“状态空间”的大小，与用动态规划解决问题的时间复杂度直接相关。在数字三角形的例子里，一共有N×(N+1)/2个数字，所以这个问题的状态空间里一共就有N×(N+1)/2个状态。整个问题的时间复杂度是状态数目乘以计算每个状态所需时间。在数字三角形里每个“状态”只需要经过一次，且在每个状态上作计算所花的时间都是和N无关的常数。

 

用动态规划解题，经常碰到的情况是，K个整型变量能构成一个状态（如数字三角形中的行号和列号这两个变量构成“状态”）。如果这K个整型变量的取值范围分别是N1, N2, ……Nk，那么，我们就可以用一个K维的数组array[N1][N2]……[Nk]来存储各个状态的“值”。这个“值”未必就是一个整数或浮点数，可能是需要一个结构才能表示的，那么array就可以是一个结构数组。一个“状态”下的“值”通常会是一个或多个子问题的解。

 

3. 确定一些初始状态（边界状态）的值

以“数字三角形”为例，初始状态就是底边数字，值 就是底边数字值。

 

4. 确定状态转移方程

定义出什么是“状态”，以及在该 “状态”下的“值”后，就要找出不同的状态之间如何迁移――即如何从一个或多个“值”已知的“状态”，求出另一个“状态”的“值”(“人人为我”递推型)。状态的迁移可以用递推公式表示，此递推公式也可被称作“状态转移方

程”。

 

数字三角形的状态转移方程：


 

※能用动规解决的问题的特点：

1)   问题具有最优子结构性质。如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构性质。

2)  无后效性。当前的若干个状态值一旦确定，则此后过程的演变就只和这若干个状态的值有关，和之前是采取哪种手段或经过哪条路径演变到当前的这若干个状态，没有关系。

 

 

二、动归的三种基本形式

 

1）记忆递归型

优点：只经过有用的状态，没有浪费。递推型会查看一些没用的状态，有浪费

缺点：可能会因递归层数太深导致爆栈，函数调用带来额外时间开销。无法使用滚动数组节省空间。总体来说，比递推型慢。

 

案例：最长公共子序列 POJ1458

给出两个字符串，求出这样的一个最长的公共子序列的长度：子序列中的每个字符都能在两个原串中找到，而且每个字符的先后顺序和原串中的先后顺序一致。

记忆递归形式如下：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
 
#define MAX 1000
 
char str1[MAX+2];
char str2[MAX+2];
int MaxLen[MAX+2][MAX+2];
 
int max(int x,int y)
{
       if(x>y)
              returnx;
       else
              returny;
}
 
int maxLen(int i,int j)
{
       if(MaxLen[i][j]!=-1)
              returnMaxLen[i][j];
       if(i==0||j==0)
       {
              MaxLen[i][j]=0;
              return0;
       }
       if(str1[i-1]==str2[j-1])
              MaxLen[i][j]=maxLen(i-1,j-1)+1;
       else
              MaxLen[i][j]=max(maxLen(i-1,j),maxLen(i,j-1));
       returnMaxLen[i][j];
}
 
int main()
{
       inti,j,len1,len2;
       while(scanf("%s%s",str1,str2)!=EOF)
       {
              len1=strlen(str1);
              len2=strlen(str2);
              for(i=0;i<=len1;++i)
                     for(j=0;j<=len2;++j)
                            MaxLen[i][j]=-1;
              printf("%d\n",maxLen(len1,len2));
       }
       return0;
}


2)“我为人人”递推型


没有什么明显的优势，有时比较符合思考的习惯。个别特殊题目中会比“人人为我”型节省空间。

 

3)“人人为我”递推型


在选取最优备选状态的值Fm,Fn,…Fy时，有可能有好的算法或数据结构可以用来显著降低时间复杂度。

 

案例：最长上升子序列 百练2757

一个数的序列bi，当b1 < b2 < ... < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2,..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 <= i1 < i2 < ... < iK <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4，比如子序列(1, 3, 5, 8).你的任务，就是对于给定的序列，求出最长上升子序列的长度。

两种形式如下：


 

三、案例集锦&一些相关技巧

 

案例一：神奇的口袋 百练2755

有一个神奇的口袋，总的容积是40，用这个口袋可以变出一些物品，这些物品的总体积必须是40。John现在有n个想要得到的物品，每个物品的体积分别是a1，a2……an。John可以从这些物品中选择一些，如果选出的物体的总体积是40，那么利用这个神奇的口袋，John就可以得到这些物品。现在的问题是，John有多少种不同的选择物品的方式。

递归：


循环：




案例二：0-1背包问题 POJ3624

循环形式，代码如下：

#include <cstdio>
#include <iostream>
using namespace std;
 
#define Max_N 3500
#define Max_M 13000
//Max_M太大，2维数组会超内存，记忆递归不能使用
int W[Max_N];
int D[Max_N];
int V[Max_M];
int m,n;
 
int max(int x,int y)
{
       if(x>y)
              returnx;
       else
              returny;
}
 
void maxV()
{
       inti,j;
       for(i=0;i<n;++i)
              for(j=m;j>=1;--j)//方向很重要
              {
                     if(i==0)//初始化边界条件
                     {
                            if(W[i]>j)
                                   V[j]=0;
                            else
                                   V[j]=D[i];
                     }
                     elseif(j-W[i]>=0)
                     {//滚动循环递推
                            V[j]=max(V[j],V[j-W[i]]+D[i]);
                     }
              }
}
 
int main()
{
       inti;
       scanf("%d%d",&n,&m);
       for(i=0;i<n;++i)
              scanf("%d%d",&W[i],&D[i]);
       maxV();
       printf("%d\n",V[m]);
       return 0;
}


案例三：滑雪 百练1088

Michael喜欢滑雪百这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子

 1  2 3  4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9


一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

递归形式，代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <climits>
using namespace std;
 
#define MAX 100
 
int H[MAX+2][MAX+2];
int MaxLen[MAX+2][MAX+2];
int r,c;
 
int max(int x,int y)
{
       if(x>y)
              returnx;
       else
              returny;
}
 
int maxLen(int i,int j)
{
       if(MaxLen[i][j]!=-1)
              returnMaxLen[i][j];
       if(H[i][j]>H[i-1][j])
              MaxLen[i][j]=max(MaxLen[i][j],maxLen(i-1,j)+1);
       if(H[i][j]>H[i][j-1])
              MaxLen[i][j]=max(MaxLen[i][j],maxLen(i,j-1)+1);
       if(H[i][j]>H[i+1][j])
              MaxLen[i][j]=max(MaxLen[i][j],maxLen(i+1,j)+1);
       if(H[i][j]>H[i][j+1])
              MaxLen[i][j]=max(MaxLen[i][j],maxLen(i,j+1)+1);
       if(H[i][j]<=H[i-1][j]&&H[i][j]<=H[i][j-1]&&H[i][j]<=H[i+1][j]&&H[i][j]<=H[i][j+1])
              MaxLen[i][j]=1;
       returnMaxLen[i][j];
}
 
int main()
{
       inti,j,MAX_L=-1;
       scanf("%d%d",&r,&c);
       for(i=0;i<=r+1;++i)
       {
              H[i][0]=INT_MAX;
              H[i][c+1]=INT_MAX;
       }
       for(j=0;j<=c+1;++j)
       {
              H[0][j]=INT_MAX;
              H[r+1][j]=INT_MAX;
       }
       for(i=1;i<=r;++i)
              for(j=1;j<=c;++j)
              {
                     scanf("%d",&H[i][j]);
                     MaxLen[i][j]=-1;
              }
       for(i=1;i<=r;++i)
              for(j=1;j<=c;++j)
                     MAX_L=max(MAX_L,maxLen(i,j));
       printf("%d\n",MAX_L);
       return 0;
}
//如果用循环递推的话需要按照高度的顺序排列进行操作


案例四：一个美妙的栅栏 POJ1037


这里用到了计数的技巧+循环动归，代码如下：

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
 
#define MAX 20
#define DOWN 0
#define UP 1
 
__int64 C[MAX+2][MAX+2][2];
int seq[MAX+2];
bool used[MAX+2];
 
//C[i][j][DOWN]表示i根木棒中第j小打头的DOWN方案数
void init(int n)
{
       inti,j,k;
       memset(C,0,sizeof(C));
       C[1][1][DOWN]=C[1][1][UP]=1;
       for(i=2;i<=n;++i)
              for(j=1;j<=i;++j)
              {
                     for(k=1;k<j;++k)
                            C[i][j][DOWN]+=C[i-1][k][UP];
                     for(k=j;k<i;++k)
                            C[i][j][UP]+=C[i-1][k][DOWN];
              }
}
 
//计数输出
void Print(int n,__int64 x)
{
       __int64oldVal,skipped=0;
       memset(seq,0,sizeof(seq));
       memset(used,0,sizeof(used));
       inti;
       for(i=1;i<=n;++i)//依次找出第i个木棒长度
       {
              intk,No=0;
              for(k=1;k<=n;++k)
              {
                     oldVal=skipped;
                     if(!used[k])
                     {
                            ++No;
                            if(i==1)
                                   skipped+=C[n][No][DOWN]+C[n][No][UP];
                            else
                            {
                                   if(seq[i-1]<k&&(i<=2||seq[i-2]>seq[i-1]))
                                          skipped+=C[n-i+1][No][DOWN];
                                   elseif(seq[i-1]>k&&(i<=2||seq[i-2]<seq[i-1]))
                                          skipped+=C[n-i+1][No][UP];
                            }
                            if(skipped>=x)
                                   break;
                     }
              }
              used[k]=true;
              seq[i]=k;
              skipped=oldVal;
       }
       for(i=1;i<n;++i)
              printf("%d ",seq[i]);
       printf("%d\n",seq[i]);
}
 
int main()
{
       intm,n;
       __int64x;
       init(20);//先初始化表可以提高速度
       scanf("%d",&m);
       while(m--)
       {
              scanf("%d%I64d",&n,&x);
              Print(n,x);
       }
       return0;
}
//当选取的状态，难以进行递推时（分解出的子问题和原问题形式不一样，
//或不具有无后效性），考虑将状态增加限制条件后分类细化，
//即增加维度，然后在新的状态上尝试递推


案例五：方盒游戏 POJ1390


求可以获得的最高分，代码如下：

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
 
struct box_segment
{
       intcolor;
       intlen;
};
 
struct box_segment segment[200];
int score[200][200][200];
 
int click_box(int start, int end, int extra_len)
{
       inti, result, temp;   
       if( score[start][end][extra_len]>0 )
              returnscore[start][end][extra_len];
       result= segment[end].len+ extra_len;
       result= result*result;
       if(start==end)//递归边界
       {
              score[start][end][extra_len]=result; 
              returnscore[start][end][extra_len];
       }
       result+= click_box(start, end-1, 0);
       i= end - 1;
       for( i = end - 1; i >= start; i-- )
       {
              if(segment[i].color!=segment[end].color) continue;
              //递推关系式
              temp= click_box(start, i, segment[end].len+ extra_len) + click_box(i+1, end-1, 0);
              if( temp<=result ) continue;
              result= temp;
              break;
       }
       score[start][end][extra_len]= result;
       returnscore[start][end][extra_len];
}
int main()
{
       intt, n, i, j, end, color;       
       scanf("%d",&t);
       for(i=0;i<t;i++)
       {
              scanf("%d",&n);
              end= 0;//输入时按颜色分段
              scanf("%d",&segment[end].color);
              segment[end].len= 1;
              for(j=1;j<n;j++) {
                     scanf("%d",&color);
                     if( color==segment[end].color )
                            segment[end].len++;
                     else{
                            end++;
                            segment[end].color= color;
                            segment[end].len= 1;
                     }
              }
              memset(score,0,sizeof(score));
              printf("Case%d: %d\n",i+1,click_box(0,end,0));
       }
       return0;
}


四、小结

动态规划的关键点在于找到最优子结构和列出状态转移方程，而且题目中很多时候会伴随着大量其他的解题技巧，所以如果要做好这一类题目就需要大量的练习作为经验，这次作为基本思想的总结就先列举这么多，之后估计还会加补充篇进行扩充。




注：以上总结部分类容来自于北京大学ACM暑期课程资料，总结只是为了方便自己查阅&和大家交流=.=

本文固定连接：http://blog.csdn.net/fyfmfof/article/details/41606781

F_Guardian
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【算法基础】动态规划的理解
Bing's Blog
11-22 710
本章是个很有趣的问题，也是难倒很多人的问题，同时这又是个会而不难的问题。 动态规划的核心逻辑是：将问题分解为子问题。在《算法图解》这本书里，深入浅出得讲了递推公式的推演逻辑，但是在关键部分，递推公式部分，并没给出逻辑。 整个过程好像是，前面一段道路很平缓，走起来很舒适，但是突然一个大台阶挡住了去路，本篇将试图为这个台阶做一下铺垫，让这个过程更加容易理解一些。 主体仍然以书上的例子作为演示素材。 —...
初识动态规划(dynamic programming)算法基本思想
china_2014的博客
11-12 425
初识动态规划(dynamic programming)算法基本思想 ​ 目录 一、常见算法： 二、动态规划描述： 三、斐波那契数列 四、给定一个数组，求任意不相邻数字的最大值 五、解决动态规划问题的一般步骤 六、课后小练习 ​ 一、常见算法： 1、动态规划算法；2、分治法；3、贪心算法，一种对某些求最优解问题的更简单、更迅速的方法，4、回溯法，一种选优搜索法；5、分支限界法。 二、动态规划描述： 来自百度词条的介绍：是运筹学的一个分支，是求解决策过程最优化的过程。20世纪50年代初，美国数学家贝尔曼（R.B
动态规划算法的基本思想-求解步骤-基本要素和一些经典的动态规划问题【干货】
热门推荐
t18438605018的博客
10-27 4万+
文章目录1.序2.动态规划的基本概念[^1]3.动态规划算法的基本思想[^2]4.动态规划的求解步骤[^2]5.动态规划算法的基本要素[^2]5.1 最优子结构5.2 重叠子问题6.一些经典的动态规划问题 1.序 近期笔者会写一些博客，与大家共同讨论一些经典的算法思想。这篇文章主要介绍动态规划算法的基本思想、使用动态规划算法求解问题的基本步骤、动态规划算法的两个基本要素以及一些经典的动态规划问题。...
动态规划 --- 算法思想介绍
PG13okc的博客
10-28 4436
一.动态规划的基本概念 动态规划在五种算法设计方法中难度最大，它建立在最优原则的基础上.采用动态规划方法，可以高效地解决许多用贪婪算法或分治法无法解决的问题.动态规划(dynamic programming)属运筹学中的规划论分支，是求解决策过程最优化的数学方法.20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程的优化问题时，提出了著名的最优化原理(principle of optimality)，把多阶段过程转化为一系列单阶段问题，逐个求解，创立了解决这类过程优化问题的新方法——动
动态规划算法思想和应用
qq_41721746的博客
03-28 6127
一. 动态规划算法 1. 动态规划算法思想 2. 动态规划求解问题的基本步骤 二. 动态规划算法问题案例 1. 硬币选择问题 2. 斐波那契数列 3. 最大子段和问题 4. 最长非降子序列LIS问题 5. LCS最长公共子序列 6. 0-1背包问题 7. 三角数组求和
动态规划的基本思想是什么
AlgorithmHero的博客
08-23 962
其基本思想可以总结为“将一个问题拆解成更小的子问题，然后通过求解子问题的最优解来推导出原问题的解”。优化和存储： 动态规划算法的核心在于避免重复计算，通常使用数组、矩阵或哈希表等数据结构来存储中间状态和子问题的解，以避免重复计算，提高效率。通过状态转移方程求解： 使用状态转移方程逐步求解问题，通常通过迭代、递推或递归等方式，将问题从初始状态逐步扩展到最终的目标状态。总之，动态规划的基本思想是通过将复杂问题分解成多个重叠的子问题，并根据子问题的最优解来求解整体问题，以达到高效地解决问题的目的。
算法设计思想——动态规划
weixin_45563167的博客
05-24 3066
虽然这道题的实质是斐波那契数列，但理解到动态规划的程序设计思路其实没那么轻松，关键是能够迅速捕捉到这以概念，进行建模，按照动态规划五部曲的递推公式，逐步推导得到结果。O%28n%29。
动态规划算法-动态规划算法的基本思想.zip
最新发布
05-23
动态规划算法的基本思想可以概括为以下四个步骤： 1. **定义状态**：首先，我们需要确定问题的状态。状态通常代表问题在某一时刻的中间结果或特性。例如，在背包问题中，状态可能是物品选择的组合及其对应的总价值...
算法与分析实验三：动态规划法
02-10
动态规划是一种解决问题的有效方法，尤其在处理具有最优子结构和子问题重叠特性的复杂问题时。本实验的目的是让学生理解和...这个实验不仅让学生掌握了动态规划的基本思想，还锻炼了他们将算法转化为实际程序的能力。
路径规划与路径跟踪动态规划算法
07-03
动态规划的基本思想是将一个大问题分解为若干个相互关联的子问题，然后从最简单的子问题开始逐步解决，最终得到原问题的解。这一过程中，关键在于构建一个状态转移方程，它描述了从一个状态到下一个状态的转换过程，...
算法提高-动态规划（二）
01-14
动态规划的基本思想是将一个大问题分解为多个小问题，通过解决这些小问题来逐步构建出原问题的解。它与分治法类似，但不同之处在于，动态规划通常涉及重叠子问题，而分治法则尽量避免。通过存储和重用已解决的子问题...
算法提高-动态规划（六）
01-14
9. **代码实现**：学习如何用Python、Java或其他编程语言实现动态规划算法，了解动态规划代码的编写规范和技巧。 10. **复杂度分析**：讨论动态规划算法的时间复杂度和空间复杂度，分析其效率，并与贪心和回溯等...
动态规划之一：基本思想
北望花村
06-03 2万+
一.基本思想一般来说，只要问题可以划分为规模更小的字问题，并且原问题的最优解中包含了子问题的最优解，则可以考虑用动态规划解决。动态规划的实质是分治思想和解决冗余。因此，动态规划是一种将问题实例分解为更小的/相似的子问题，并存储子问题的解，使得每个子问题只求解一次，最终获得原问题的答案，以解决最优化问题的算法策略。与贪心法的关系：1.与贪心法类似，都是将问题实例归纳为更小的、相似的子问题，并通过求解...
动态规划算法的基本思想_算法五大基本思想
weixin_39845220的博客
11-23 2926
穷举算法基础穷举法，亦称作分类证明、分类分析证明、完全归纳法或暴力法, 是一种数学证明方法, 它将所求证的命题分为有限种情形或是等价情形的集合, 然后就每种类型分别检验该命题是否成立.这是一种直接证明(英语：direct proof)法. 穷举法证明包括两阶段:证明分类是完全的, 也就是说每一个待证的个例皆符合(至少)一类情形的条件;分别对每一类情形给出证明.数字计算机的普及大大提升了穷...
动态规划算法的基本思想_【算法学习】动态规划
weixin_39890327的博客
12-10 4414
动 态 规 划dynamic programming那些遗忘过去的人注定要重蹈覆辙。——乔治·桑塔亚纳(1863-1952)今天咱们来聊聊动态规划。动态规划(dynamic programming)是一种基础的算法设计思想。作为一种寻找最优解的通用方法，它是在20世纪50年代由美国数学家Richard Bellman(也就是之前最短路径问题中Bellman ford算法的发明者之一...
【动态规划】动态规划算法基本概念，原理应用和示例代码
qq_35831906的博客
11-12 1万+
动态规划（Dynamic Programming，简称DP）是一种解决多阶段决策问题的数学优化方法。它将原问题分解成若干个子问题，通过解决子问题只需解决一次并将结果保存下来，从而避免了重复计算，提高了算法效率。通俗来讲，动态规划算法是解决一类具有重叠子问题和最优子结构性质的问题的有效方法。其基本原理是将大问题分解为小问题，通过保存中间结果来避免重复计算，从而提高算法的效率。动态规划主要包括两个要素：最优子结构和重叠子问题。
动态规划算法的基本思想_动态规划算法
weixin_39534321的博客
12-10 1万+
动态规划算法介绍 1)动态规划(Dynamic Programming)算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法 2)动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。 3)与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。 ( 即下一个子阶段的求解是建立...
动态规划：基本思想与应用实例解析
理解并熟练运用动态规划的思想，能够帮助我们更有效地解决问题，提高决策效率。然而，每个具体问题都需要根据其特性和约束条件设计适合的动态规划模型，并且在实施过程中要注意避免重复计算，以提高算法效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值