动态规划 订阅
动态规划(Dynamic Programming,DP)是运筹学的一个分支,是求解决策过程最优化的过程。20世纪50年代初,美国数学家贝尔曼(R.Bellman)等人在研究多阶段决策过程的优化问题时,提出了著名的最优化原理,从而创立了动态规划。动态规划的应用极其广泛,包括工程技术、经济、工业生产、军事以及自动化控制等领域,并在背包问题、生产经营问题、资金管理问题、资源分配问题、最短路径问题和复杂系统可靠性问题等中取得了显著的效果 [1]  。 展开全文
动态规划(Dynamic Programming,DP)是运筹学的一个分支,是求解决策过程最优化的过程。20世纪50年代初,美国数学家贝尔曼(R.Bellman)等人在研究多阶段决策过程的优化问题时,提出了著名的最优化原理,从而创立了动态规划。动态规划的应用极其广泛,包括工程技术、经济、工业生产、军事以及自动化控制等领域,并在背包问题、生产经营问题、资金管理问题、资源分配问题、最短路径问题和复杂系统可靠性问题等中取得了显著的效果 [1]  。
信息
运    用
求解决策过程(decision process)最优化的数学方法
外文名
dynamic programming
简    称
DP
中文名
动态规划
学    科
运筹学
第一本著作
《Dynamic Programming》
动态规划简介
动态规划问世以来,在经济管理、生产调度、工程技术和最优控制等方面得到了广泛的应用。例如最短路线、库存管理、资源分配、设备更新、排序、装载等问题,用动态规划方法比用其它方法求解更为方便 [2]  。虽然动态规划主要用于求解以时间划分阶段的动态过程的优化问题,但是一些与时间无关的静态规划(如线性规划、非线性规划),只要人为地引进时间因素,把它视为多阶段决策过程,也可以用动态规划方法方便地求解 [2]  。在现实生活中,有一类活动的过程,由于它的特殊性,可将过程分成若干个互相联系的阶段,在它的每一阶段都需要作出决策,从而使整个过程达到最好的活动效果。因此各个阶段决策的选取不能任意确定,它依赖于当前面临的状态,又影响以后的发展。当各个阶段决策确定后,就组成一个决策序列,因而也就确定了整个过程的一条活动路线.这种把一个问题看作是一个前后关联具有链状结构的多阶段过程就称为多阶段决策过程,这种问题称为多阶段决策问题。在多阶段决策问题中,各个阶段采取的决策,一般来说是与时间有关的,决策依赖于当前状态,又随即引起状态的转移,一个决策序列就是在变化的状态中产生出来的,故有“动态”的含义,称这种解决多阶段决策最优化的过程为动态规划方法 [3]  。动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中,可能会有许多可行解。每一个解都对应于一个值,我们希望找到具有最优值的解。动态规划算法与分治法类似,其基本思想也是将待求解问题分解成若干个子问题,先求解子问题,然后从这些子问题的解得到原问题的解。与分治法不同的是,适合于用动态规划求解的问题,经分解得到子问题往往不是互相独立的。若用分治法来解这类问题,则分解得到的子问题数目太多,有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案,而在需要时再找出已求得的答案,这样就可以避免大量的重复计算,节省时间。我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到,只要它被计算过,就将其结果填入表中。这就是动态规划法的基本思路。具体的动态规划算法多种多样,但它们具有相同的填表格式 [4]  。1. 多阶段决策问题如果一类活动过程可以分为若干个互相联系的阶段,在每一个阶段都需作出决策(采取措施),一个阶段的决策确定以后,常常影响到下一个阶段的决策,从而就完全确定了一个过程的活动路线,则称它为多阶段决策问题 [5]  。各个阶段的决策构成一个决策序列,称为一个策略。每一个阶段都有若干个决策可供选择,因而就有许多策略供我们选取,对应于一个策略可以确定活动的效果,这个效果可以用数量来确定。策略不同,效果也不同,多阶段决策问题,就是要在可以选择的那些策略中间,选取一个最优策略,使在预定的标准下达到最好的效果 [5]  。2.动态规划问题中的术语阶段:把所给求解问题的过程恰当地分成若干个相互联系的阶段,以便于求解,过程不同,阶段数就可能不同.描述阶段的变量称为阶段变量。在多数情况下,阶段变量是离散的,用k表示。此外,也有阶段变量是连续的情形。如果过程可以在任何时刻作出决策,且在任意两个不同的时刻之间允许有无穷多个决策时,阶段变量就是连续的 [5]  。状态:状态表示每个阶段开始面临的自然状况或客观条件,它不以人们的主观意志为转移,也称为不可控因素。在上面的例子中状态就是某阶段的出发位置,它既是该阶段某路的起点,同时又是前一阶段某支路的终点 [5]  。无后效性:我们要求状态具有下面的性质:如果给定某一阶段的状态,则在这一阶段以后过程的发展不受这阶段以前各段状态的影响,所有各阶段都确定时,整个过程也就确定了。换句话说,过程的每一次实现可以用一个状态序列表示,在前面的例子中每阶段的状态是该线路的始点,确定了这些点的序列,整个线路也就完全确定。从某一阶段以后的线路开始,当这段的始点给定时,不受以前线路(所通过的点)的影响。状态的这个性质意味着过程的历史只能通过当前的状态去影响它的未来的发展,这个性质称为无后效性 [5]  。决策:一个阶段的状态给定以后,从该状态演变到下一阶段某个状态的一种选择(行动)称为决策。在最优控制中,也称为控制。在许多问题中,决策可以自然而然地表示为一个数或一组数。不同的决策对应着不同的数值。描述决策的变量称决策变量,因状态满足无后效性,故在每个阶段选择决策时只需考虑当前的状态而无须考虑过程的历史 [5]  。决策变量的范围称为允许决策集合 [5]  。策略:由每个阶段的决策组成的序列称为策略。对于每一个实际的多阶段决策过程,可供选取的策略有一定的范围限制,这个范围称为允许策略集合 [5]  。允许策略集合中达到最优效果的策略称为最优策略 [5]  。给定k阶段状态变量x(k)的值后,如果这一阶段的决策变量一经确定,第k+1阶段的状态变量x(k+1)也就完全确定,即x(k+1)的值随x(k)和第k阶段的决策u(k)的值变化而变化,那么可以把这一关系看成(x(k),u(k))与x(k+1)确定的对应关系,用x(k+1)=Tk(x(k),u(k))表示。这是从k阶段到k+1阶段的状态转移规律,称为状态转移方程 [5]  。最优化原理:作为整个过程的最优策略,它满足:相对前面决策所形成的状态而言,余下的子策略必然构成“最优子策略” [5]  。最优性原理实际上是要求问题的最优策略的子策略也是最优 [5]  。多阶段决策问题中,各个阶段采取的决策,一般来说是与时间有关的,决策依赖于当前状态,又随即引起状态的转移,一个决策序列就是在变化的状态中产生出来的,故有“动态”的含义,称这种解决多阶段决策最优化问题的方法为动态规划方法 [6]  。任何思想方法都有一定的局限性,超出了特定条件,它就失去了作用。同样,动态规划也并不是万能的。适用动态规划的问题必须满足最优化原理和无后效性 [7]  。1、最优化原理(最优子结构性质)最优化原理可这样阐述:一个最优化策略具有这样的性质,不论过去状态和决策如何,对前面的决策所形成的状态而言,余下的诸决策必须构成最优策略。简而言之,一个最优化策略的子策略总是最优的。一个问题满足最优化原理又称其具有最优子结构性质 [7]  。2、无后效性将各阶段按照一定的次序排列好之后,对于某个给定的阶段状态,它以前各阶段的状态无法直接影响它未来的决策,而只能通过当前的这个状态。换句话说,每个状态都是过去历史的一个完整总结。这就是无后向性,又称为无后效性 [7]  。3、子问题的重叠性动态规划算法的关键在于解决冗余,这是动态规划算法的根本目的。动态规划实质上是一种以空间换时间的技术,它在实现的过程中,不得不存储产生过程中的各种状态,所以它的空间复杂度要大于其他的算法。选择动态规划算法是因为动态规划算法在空间上可以承受,而搜索算法在时间上却无法承受,所以我们舍空间而取时间 [7]  。
收起全文
精华内容
下载资源
问答
  • 夜深人静写算法(二)- 动态规划

    万次阅读 多人点赞 2017-12-28 14:57:36
  • 教你彻底学会动态规划——入门篇

    万次阅读 多人点赞 2015-08-11 13:26:41
    动态规划相信大家都知道,动态规划算法也是新手在刚接触算法设计时很苦恼的问题,有时候觉得难以理解,但是真正理解之后,就会觉得动态规划其实并没有想象中那么难。网上也有很多关于讲解动态规划的文章,大多都是...

        动态规划相信大家都知道,动态规划算法也是新手在刚接触算法设计时很苦恼的问题,有时候觉得难以理解,但是真正理解之后,就会觉得动态规划其实并没有想象中那么难。网上也有很多关于讲解动态规划的文章,大多都是叙述概念,讲解原理,让人觉得晦涩难懂,即使一时间看懂了,发现当自己做题的时候又会觉得无所适从。我觉得,理解算法最重要的还是在于练习,只有通过自己练习,才可以更快地提升。话不多说,接下来,下面我就通过一个例子来一步一步讲解动态规划是怎样使用的,只有知道怎样使用,才能更好地理解,而不是一味地对概念和原理进行反复琢磨。

        首先,我们看一下这道题(此题目来源于北大POJ):

        数字三角形(POJ1163)

       

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

        输入格式:

        5      //表示三角形的行数    接下来输入三角形

        7

        3   8

        8   1   0

        2   7   4   4

        4   5   2   6   5

        要求输出最大和

        接下来,我们来分析一下解题思路:

        首先,肯定得用二维数组来存放数字三角形

        然后我们用D( r, j) 来表示第r行第 j 个数字(r,j从1开始算)

        我们用MaxSum(r, j)表示从D(r,j)到底边的各条路径中,最佳路径的数字之和。

        因此,此题的最终问题就变成了求 MaxSum(1,1)

        当我们看到这个题目的时候,首先想到的就是可以用简单的递归来解题:

        D(r, j)出发,下一步只能走D(r+1,j)或者D(r+1, j+1)。故对于N行的三角形,我们可以写出如下的递归式:   

    if ( r == N)                
    	MaxSum(r,j) = D(r,j)  
    else      
    	MaxSum( r, j) = Max{ MaxSum(r+1,j), MaxSum(r+1,j+1) } + D(r,j) 

        根据上面这个简单的递归式,我们就可以很轻松地写出完整的递归代码: 

    #include <iostream>  
    #include <algorithm> 
    #define MAX 101  
    using namespace std; 
    int D[MAX][MAX];  
    int n;  
    int MaxSum(int i, int j){    
    	if(i==n)  
    		return D[i][j];    
    	int x = MaxSum(i+1,j);    
    	int y = MaxSum(i+1,j+1);    
    	return max(x,y)+D[i][j];  
    }
    int main(){    
    	int i,j;    
    	cin >> n;    
    	for(i=1;i<=n;i++)   
    		for(j=1;j<=i;j++)        
    			cin >> D[i][j];    
    	cout << MaxSum(1,1) << endl;  
    }      

        对于如上这段递归的代码,当我提交到POJ时,会显示如下结果:

       

        对的,代码运行超时了,为什么会超时呢?

        答案很简单,因为我们重复计算了,当我们在进行递归时,计算机帮我们计算的过程如下图:

        

        就拿第三行数字1来说,当我们计算从第2行的数字3开始的MaxSum时会计算出从1开始的MaxSum,当我们计算从第二行的数字8开始的MaxSum的时候又会计算一次从1开始的MaxSum,也就是说有重复计算。这样就浪费了大量的时间。也就是说如果采用递规的方法,深度遍历每条路径,存在大量重复计算。则时间复杂度为 2的n次方,对于 n = 100 行,肯定超时。 

        接下来,我们就要考虑如何进行改进,我们自然而然就可以想到如果每算出一个MaxSum(r,j)就保存起来,下次用到其值的时候直接取用,则可免去重复计算。那么可以用n方的时间复杂度完成计算。因为三角形的数字总数是 n(n+1)/2

        根据这个思路,我们就可以将上面的代码进行改进,使之成为记忆递归型的动态规划程序: 

    #include <iostream>  
    #include <algorithm> 
    using namespace std;
     
    #define MAX 101
      
    int D[MAX][MAX];    
    int n;  
    int maxSum[MAX][MAX];
     
    int MaxSum(int i, int j){      
    	if( maxSum[i][j] != -1 )         
    		return maxSum[i][j];      
    	if(i==n)   
    		maxSum[i][j] = D[i][j];     
    	else{    
    		int x = MaxSum(i+1,j);       
    		int y = MaxSum(i+1,j+1);       
    		maxSum[i][j] = max(x,y)+ D[i][j];     
    	}     
    	return maxSum[i][j]; 
    } 
    int main(){    
    	int i,j;    
    	cin >> n;    
    	for(i=1;i<=n;i++)   
    		for(j=1;j<=i;j++) {       
    			cin >> D[i][j];       
    			maxSum[i][j] = -1;   
    		}    
    	cout << MaxSum(1,1) << endl; 
    } 

        当我们提交如上代码时,结果就是一次AC

       

        虽然在短时间内就AC了。但是,我们并不能满足于这样的代码,因为递归总是需要使用大量堆栈上的空间,很容易造成栈溢出,我们现在就要考虑如何把递归转换为递推,让我们一步一步来完成这个过程。

        我们首先需要计算的是最后一行,因此可以把最后一行直接写出,如下图:

       

        现在开始分析倒数第二行的每一个数,现分析数字2,2可以和最后一行4相加,也可以和最后一行的5相加,但是很显然和5相加要更大一点,结果为7,我们此时就可以将7保存起来,然后分析数字7,7可以和最后一行的5相加,也可以和最后一行的2相加,很显然和5相加更大,结果为12,因此我们将12保存起来。以此类推。。我们可以得到下面这张图:

       

        然后按同样的道理分析倒数第三行和倒数第四行,最后分析第一行,我们可以依次得到如下结果:

       

       

        上面的推导过程相信大家不难理解,理解之后我们就可以写出如下的递推型动态规划程序: 

    #include <iostream>  
    #include <algorithm> 
    using namespace std; 
    
    #define MAX 101  
    
    int D[MAX][MAX];   
    int n;  
    int maxSum[MAX][MAX]; 
    int main(){    
    	int i,j;    
    	cin >> n;    
    	for(i=1;i<=n;i++)   
    		for(j=1;j<=i;j++)        
    			cin >> D[i][j];   
    	for( int i = 1;i <= n; ++ i )     
    		maxSum[n][i] = D[n][i];   
    	for( int i = n-1; i>= 1;  --i )     
    		for( int j = 1; j <= i; ++j )         
    			maxSum[i][j] = max(maxSum[i+1][j],maxSum[i+1][j+1]) + D[i][j];    
    	cout << maxSum[1][1] << endl;  
    } 

         我们的代码仅仅是这样就够了吗?当然不是,我们仍然可以继续优化,而这个优化当然是对于空间进行优化,其实完全没必要用二维maxSum数组存储每一个MaxSum(r,j),只要从底层一行行向上递推,那么只要一维数组maxSum[100]即可,即只要存储一行的MaxSum值就可以。

         对于空间优化后的具体递推过程如下:

       

       

       

       

       

       

        接下里的步骤就按上图的过程一步一步推导就可以了。进一步考虑,我们甚至可以连maxSum数组都可以不要,直接用D的第n行直接替代maxSum即可。但是这里需要强调的是:虽然节省空间,但是时间复杂度还是不变的。

        依照上面的方式,我们可以写出如下代码:    

     

    #include <iostream>  
    #include <algorithm> 
    using namespace std; 
    
    #define MAX 101  
    
    int D[MAX][MAX];  
    int n; 
    int * maxSum; 
    
    int main(){    
    	int i,j;    
    	cin >> n;    
    	for(i=1;i<=n;i++)   
    		for(j=1;j<=i;j++)        
    			cin >> D[i][j];   
    	maxSum = D[n]; //maxSum指向第n行    
    	for( int i = n-1; i>= 1;  --i )     
    		for( int j = 1; j <= i; ++j )       
    			maxSum[j] = max(maxSum[j],maxSum[j+1]) + D[i][j];    
    	cout << maxSum[1] << endl;  
    }

     

     

     

     

     

        接下来,我们就进行一下总结:

        递归到动规的一般转化方法

        递归函数有n个参数,就定义一个n维的数组,数组的下标是递归函数参数的取值范围,数组元素的值是递归函数的返回值,这样就可以从边界值开始, 逐步填充数组,相当于计算递归函数值的逆过程。

        动规解题的一般思路

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

    •     把原问题分解为若干个子问题,子问题和原问题形式相同或类似,只不过规模变小了。子问题都解决,原问题即解决(数字三角形例)。
    •     子问题的解一旦求出就会被保存,所以每个子问题只需求 解一次。

        2.确定状态

    •     在用动态规划解题时,我们往往将和子问题相关的各个变量的一组取值,称之为一个“状 态”。一个“状态”对应于一个或多个子问题, 所谓某个“状态”下的“值”,就是这个“状 态”所对应的子问题的解。
    •     所有“状态”的集合,构成问题的“状态空间”。“状态空间”的大小,与用动态规划解决问题的时间复杂度直接相关。 在数字三角形的例子里,一共有N×(N+1)/2个数字,所以这个问题的状态空间里一共就有N×(N+1)/2个状态。

        整个问题的时间复杂度是状态数目乘以计算每个状态所需时间。在数字三角形里每个“状态”只需要经过一次,且在每个状态上作计算所花的时间都是和N无关的常数。

        3.确定一些初始状态(边界状态)的值

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

        4. 确定状态转移方程

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

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

       
     

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

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

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

     

    好久没看博客发现这篇文章现在已经这么火热了,看了一下评论发现不少人对这篇文章都比较有兴趣,我当初写这篇文章是受到了Coursera上面一门算法课程的启发,大家有兴趣可以去听听这门课程数据结构与算法

     

    展开全文
  • 动态规划

    千次阅读 多人点赞 2019-06-30 21:30:12
  • 动态规划的重要性就不多说,直接进入正题 首先,我们看一下官方定义: 定义: 动态规划算法是通过拆分问题,定义问题状态和状态之间的关系,使得问题能够以递推(或者说分治)的方式去解决。 动态规划算法的基本思想与...

    首先,本博客为原创作品,欢迎指导,随意转载,如果可以请转载时说明出处,附上本文链接(https://blog.csdn.net/ailaojie/article/details/83014821),谢谢
    原文链接
    动态规划的重要性就不多说,直接进入正题

    首先,我们看一下官方定义:
    定义:
    动态规划算法是通过拆分问题,定义问题状态和状态之间的关系,使得问题能够以递推(或者说分治)的方式去解决。
    动态规划算法的基本思想与分治法类似,也是将待求解的问题分解为若干个子问题(阶段),按顺序求解子阶段,前一子问题的解,为后一子问题的求解提供了有用的信息。在求解任一子问题时,列出各种可能的局部解,通过决策保留那些有可能达到最优的局部解,丢弃其他局部解。依次解决各子问题,最后一个子问题就是初始问题的解。
    基本思想与策略编辑:
    由于动态规划解决的问题多数有重叠子问题这个特点,为减少重复计算,对每一个子问题只解一次,将其不同阶段的不同状态保存在一个二维数组中。
    (来自百度百科)
    说实话,没有动态规划的基础很难看懂,但是也能从中看出一些信息,下面我翻译成人话:
    首先是拆分问题,我的理解就是根据问题的可能性把问题划分成一步一步这样就可以通过递推或者递归来实现.
    关键就是这个步骤,动态规划有一类问题就是从后往前推到,有时候我们很容易知道:如果只有一种情况时,最佳的选择应该怎么做.然后根据这个最佳选择往前一步推导,得到前一步的最佳选择
    然后就是定义问题状态和状态之间的关系,我的理解是前面拆分的步骤之间的关系,用一种量化的形式表现出来,类似于高中学的推导公式,因为这种式子很容易用程序写出来,也可以说对程序比较亲和(也就是最后所说的状态转移方程式)
    我们再来看定义的下面的两段,我的理解是比如我们找到最优解,我们应该讲最优解保存下来,为了往前推导时能够使用前一步的最优解,在这个过程中难免有一些相比于最优解差的解,此时我们应该放弃,只保存最优解,这样我们每一次都把最优解保存了下来,大大降低了时间复杂度

    说很难理解清楚,容易懵懵懂懂的,所以下面结合实例看一下(建议结合实例,纸上谈兵不太好):

    经典的数字三角形问题(简单易懂,经典动态规划);

    题目:题目描述
    输入格式
    可以看出每走第n行第m列时有两种后续:向下或者向右下
    由于最后一行可以确定,当做边界条件,所以我们自然而然想到递归求解
    解题思路:解题思路
    c语言答案
    下面简单写一下java代码:

    //java代码纯属自己练习,标准答案参考上面的c语言答案
    class solution{
    	public int getMax(){
    		int MAX = 101;
    		int[][] D = new int[MAX][MAX];   //存储数字三角形
    		int n;              //n表示层数
    		int i = 0; int j = 0;
    		int maxSum = getMaxSum(D,n,i,j);
    		return maxSum;
    	}
    	public int getMaxSum(int[][] D,int n,int i,int j){
    		if(i == n){
    			return D[i][j];
    		}
    		int x = getMaxSum(D,n,i+1,j);
    		int y = getMaxSum(D,n,i+1,j+1);
    		return Math.max(x,y)+D[i][j];
    	}
    }
    

    其实仔细观察,上面的解答过程时间复杂度难以想象的大,那是因为他对有的数字的解进行了多次的重复计算,具体如下图:
    超时原因
    如果不明白上图,可以把每条路径都画出来,观察每个数字有多少条路径经过了他,就会一目了然
    然后我们就可以自然而然的想到,如果我们每次都把结果保存下来,复杂度就会大大降低
    改进方法
    其实答案很简单:改进解法
    其实这是动态规划很精髓的一部分,是减少复杂度的主要原因
    我们都知道,递归一般情况下是可以转化为递推的,不详细解释了,贴上答案:
    递推解法
    其实,仔细观察该解题过程,该过程就是标准的动态规划解题过程,如果把该过程画出来(找到每一步的最优解,其他的舍弃)对动态规划会有更深刻的解法
    还有就是,递推的另一个好处是可以进行空间优化,如图:
    空间优化
    下面总结一下动态规划的解题一般思路:
    首先递归应该是我们解决动态规划问题最常用的方法,帅,速度不算太慢
    那么递归到动规的一般转化方法为:
    如果该递归函数有n个参数,那么就定义一个n维数组,数组下标是递归函数参数的取值范围(也就是数组每一维的大小).数组元素的值就是递归函数的返回值(初始化为一个标志值,表明还未被填充),这样就可以从边界值开始逐步的填充数组,相当于计算递归函数的逆过程(这和前面所说的推导过程应该是相同的).
    原文链接:https://blog.csdn.net/ailaojie/article/details/83014821

    动规解题的一般思路(标准官方,不过经过前边讲解应该就能理解了):

    1. 将原问题分解为子问题(开头已经介绍了怎么分解) (注意:1,子问题与原问题形式相同或类似,只是问题规模变小了,从而变简单了; 2,子问题一旦求出就要保存下来,保证每个子问题只求解一遍)
    2. 确定状态(状态:在动规解题中,我们将和子问题相关的各个变量的一组取值,称之为一个"状态",一个状态对应一个或多个子问题所谓的在某个状态的值,这个就是状态所对应的子问题的解,所有状态的集合称为"状态空间".我的理解就是状态就是某个问题某组变量,状态空间就是该问题的所有组变量) 另外:整个问题的时间复杂度就是状态数目乘以每个状态所需要的时间
    3. 确定一些初始状态(边界条件)的值 (这个视情况而定,千万别以为就是最简单的那个子问题解,上面只是例子,真正实践动规千变万化)
    4. 确定状态转移方程 (这一步和第三步是最关键的 记住"人人为我"递推,由已知推未知)

    适合使用动规求解的问题:
    1,问题具有最优子结构
    2,无后效性 说的花里胡哨的,其实一般遇到求最优解问题一般适合使用动态规划

    部分参考资料出自:北大信科郭炜老师

    感觉自己洋洋洒洒写了几个小时,对动态规划有了一定的理解,也希望对你们有所帮助,动态规划千变万化,这仅仅是一个理解过程,我们还是应该多练习,共勉吧.转载的话,如果方便请加上转载地址,谢谢.

    展开全文
  • 算法-动态规划 Dynamic Programming--从菜鸟到老鸟

    万次阅读 多人点赞 2017-07-15 22:58:29
    前言最近在牛客网上做了几套公司的真题,发现有关动态规划(Dynamic Programming)算法的题目很多。相对于我来说,算法里面遇到的问题里面感觉最难的也就是动态规划(Dynamic Programming)算法了,于是花了好长时间...
  • 简要介绍动态规划的几个基本模型和状态转移方程
  • 动态规划难吗?说实话,我觉得很难,特别是对于初学者来说,我当时入门动态规划的时候,是看 0-1 背包问题,当时真的是一脸懵逼。后来,我遇到动态规划的题,看的懂答案,但就是自己不会做,不知道怎么下手。就像做...
  • 最火的瓜,得用动态规划来吃

    万次阅读 多人点赞 2020-04-23 21:45:46
    罗志祥才是动态规划的高手一、事件的前因后果二、被罗志祥的技术能力折服三、 你要成为这样的高手吗?四、 递归树分析五、 动态规划的代码六、 与妹子沟通是个技术活 今天真是被罗志祥的大瓜砸到了!全网络都是关于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,915
精华内容 43,966
关键字:

动态规划