高手来区分几个概念:动态规划、线性规划、最优控制......

[qiuzhenguang]

我是菜鸟，有几个概念不理解，经常混淆，望高手指点！

如何区别以下几个概念：动态规划、线性规划、非线性规划、二次规划、整数规划、0-1规划、最优化、变分学.......等等。

它们有什么区别和联系？

大家多多指教，能讲出几个是几个。也欢迎补充相关的概念，谢谢！

[DarkChampion]

最优化方法（也称做运筹学方法）是近几十年形成的，它主要运用数学方法研究各种系统的优化途径及方案，为决策者提供科学决策的依据。最优化方法的主要研究对象是各种有组织系统的管理问题及其生产经营活动。最优化方法的目的在于针对所研究的系统，求得一个合理运用人力、物力和财力的最佳方案，发挥和提高系统的效能及效益，最终达到系统的最优目标。

主要分支
线性规划
当目标函数f是线性函数而且集合A是由线性等式函数和线性不等式函数来确定的， 我们称这一类问题为线性规划
整数规划
当线性规划问题的部分或所有的变量局限于整数值时， 我们称这一类问题为整数规划问题
二次规划
目标函数是二次函数，而且集合A必须是由线性等式函数和线性不等式函数来确定的。
非线性规划
研究的是目标函数或是限制函数中含有非线性函数的问题。
随机规划
研究的是某些变量是随机变量的问题。
动态规划
研究的是最优策略基于将问题分解成若干个较小的子问题的优化问题。
组合最优化
研究的是可行解是离散或是可转化为离散的问题。
无限维最优化
研究的是可行解的集合是无限维空间的子集的问题，一个无限维空间的例子是函数空间。

[qiuzhenguang]

非常感谢DarkChampion ，请大家继续讨论 ！

[qiuzhenguang]

6楼 讲的好像是说动态规划是一个决策问题。我认同。但是有些算法书上讲动态规划要有两个部分：（1）最优子结构 （2）重叠子问题 。 书上还说动态规划要存储一些已求解子问题，以便后面要重复使用。

感觉这两种说法（决策问题 和 重叠子问题 ）很难统一起来。它们是怎样一种关系呢？

望多多指教 ！能举个例子最好。谢谢！

[youdandan]

不太明白，学习一下

[qiuzhenguang]

例如，计算6个发点8个收点的最小费用运输问题，产地Ai到销地Bj的运费已知，Ai生产能力已知，Bj需求量已知，如下表所示：

产地\销地B1 B2 B3 B4 B5 B6 B7 B8 产量
A1 6 2 6 7 4 2 5 9 60
A2 4 9 5 3 8 5 8 2 55
A3 5 2 1 9 7 4 3 3 51
A4 7 6 7 3 9 2 7 1 43
A5 2 3 9 5 7 2 6 5 41
A6 5 5 2 2 8 1 4 3 52
销量 35 37 22 32 41 32 43 38

要求计算从Ai到Bj的发货量，以使用费用最小。

这样的题目有Lingo等线性规划软件，只要几个语句就能解决。如下：

model:
!6发点8收点运输问题;
sets:
warehouses/wh1..wh6/: capacity;
vendors/v1..v8/: demand;
links(warehouses,vendors): cost, volume;
endsets
!目标函数;
min=@sum(links: cost*volume);
!需求约束;
@for(vendors(J):
@sum(warehouses(I): volume(I,J))=demand(J));
!产量约束;
@for(warehouses(I):
@sum(vendors(J): volume(I,J))<=capacity(I));

!这里是数据;
data:
capacity=60 55 51 43 41 52;
demand=35 37 22 32 41 32 43 38;
cost=6 2 6 7 4 2 9 5
4 9 5 3 8 5 8 2
5 2 1 9 7 4 3 3
7 6 7 3 9 2 7 1
2 3 9 5 7 2 6 5
5 5 2 2 8 1 4 3;
enddata
end


但是我想知道如果不使用专用软件，而自已去编程，应该怎么编呢？是用动态规划吗？

望各位多多指教 ！
注：上面求解结果有可能是浮点数，而不限制是整数。

[qiuzhenguang]

18楼数据排列不整齐，真抱歉，重新贴一下。

产地\销地 B1 B2 B3 B4 B5 B6 B7 B8 产量
A1 6 2 6 7 4 2 5 9 60
A2 4 9 5 3 8 5 8 2 55
A3 5 2 1 9 7 4 3 3 51
A4 7 6 7 3 9 2 7 1 43
A5 2 3 9 5 7 2 6 5 41
A6 5 5 2 2 8 1 4 3 52
销量 35 37 22 32 41 32 43 38

[linren]

动态优化最重要的是它的优化原理：
作为整个过程的最优策略，无论过去的状态和决策如何，对前面的决策形成的状态而言，余下的诸多决策必构成最优策略

这样就提供了一种逆推的根据……

如果问题不满足优化原理
就没有办法通过动态规划来得到最优解
不过确可以得到一个非常理想的近似解……

比如说这里的21楼：http://topic.csdn.net/u/20090725/10/086dc55c-d713-4808-a98b-a343fb67f6a6.html
最优解为334
但是使用动态规划得到的结果是337……

再比如说这里的100楼：http://topic.csdn.net/u/20090726/19/f8db8744-8469-4145-8f90-358c2a22a107.html
可以在很短的时间内得到非常不错的近似解……

所以说不论是近似解还是最优解
动态规划都很有用途……

只要理解的动态规划的优化原理
就算掌握了动态规划……
实现方面的细节其实并不重要

比如说这里的126楼：http://topic.csdn.net/u/20090717/10/4c170fbc-8f83-4163-812b-c278289fcb3c_2.html
在动态规划时并没有保存最大递增序列的内容
而是在动态规划结束后用两个时间复杂度为n的操作把序列找出来……

[linren]

[Quote=引用 12 楼 linren 的回复:]
动态优化最重要的是它的优化原理：
作为整个过程的最优策略，无论过去的状态和决策如何，对前面的决策形成的状态而言，余下的诸多决策必构成最优策略
[/Quote]
应该是：
“动态规划最重要的是它的优化原理：”
想着“优化原理”这个词结果把动态规划打成动态优化了（晕倒）……

[fiwiner]

说实话，我也一头雾水。百度百科上有，说的挺详细..

[linren]

线性规划同样可以用它的优化原理来说明
在优化前需要引入松弛变量来把不等式改为等式
这样就可以通过找一个高维空间的凸多面体的顶点来找到最优解……
计算方法是单纯形法……

线性规划是最近刚开始接触的
没有接触过可以用来举例的例子……
期待大家补充^_^……

[Victor_Dinho]

动态规划是一种在数学和计算机科学中使用的，用于求解包含重叠子问题的最优化问题的方法。其基本思想是，将原问题分解为相似的子问题，在求解的过程中通过子问题的解求出原问题的解。动态规划的思想是多种算法的基础，被广泛应用于计算机科学和工程领域。比较著名的应用实例有：求解最短路径问题，背包问题，项目管理，网络流优化等。

动态规划在查找有很多重叠子问题的情况的最优解时有效。它将问题重新组合成子问题。为了避免多次解决这些子问题，它们的结果都逐渐被计算并被保存，从简单的问题直到整个问题都被解决。因此，动态规划保存递归时的结果，因而不会在解决同样的问题时花费时间。

动态规划只能应用于有最优子结构的问题。最优子结构的意思是局部最优解能决定全局最优解(对有些问题这个要求并不能完全满足，故有时需要引入一定的近似)。简单地说，问题能够分解成子问题来解决。

[Victor_Dinho]

在数学中，线性规划 (Linear Programming，简称LP) 问题是目标函数和约束条件都是线性的最优化问题。

线性规划是最优化问题中的重要领域之一。很多运筹学中的实际问题都可以用线性规划来表述。线性规划的某些特殊情况，例如网络流、多商品流量等问题，都被认为非常重要，并有大量对其算法的专门研究。很多其他种类的最优化问题算法都可以分拆成线性规划子问题，然后求得解。在历史上，由线性规划引申出的很多概念，启发了最优化理论的核心概念，诸如“对偶”、“分解”、“凸性”的重要性及其一般化等。同样的，在微观经济学和商业管理领域，线性规划被大量应用于解决收入极大化或生产过程的成本极小化之类的问题。乔治·丹齐格被认为是线性规划之父。

http://zh.wikipedia.org/zh-cn/%E7%BA%BF%E6%80%A7%E8%A7%84%E5%88%92

16L的链接是http://zh.wikipedia.org/zh-cn/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92

[qiuzhenguang]

linren 见多识厂，令人佩服！！谢谢你的解答！

[qiuzhenguang]

答案 664 是正确解。

[XGJ889]

精彩，学习up

[linren]

[Quote=引用 18 楼 qiuzhenguang 的回复:]

但是我想知道如果不使用专用软件，而自已去编程，应该怎么编呢？是用动态规划吗？
[/Quote]
可以用表上作业法来计算……
这里有个表上作业法的实现：http://bbs.matwav.com/viewthread.php?tid=101122

[linren]

[Quote=引用 20 楼 linren 的回复:]
引用 18 楼 qiuzhenguang 的回复:

但是我想知道如果不使用专用软件，而自已去编程，应该怎么编呢？是用动态规划吗？

可以用表上作业法来计算……
这里有个表上作业法的实现：http://bbs.matwav.com/viewthread.php?tid=101122
[/Quote]

尝试着使用了一下……
运行结果为：

please input the data file name: 1.txt








=============Data File================
     6.000     2.000     6.000     7.000     4.000     2.000     5.000     9.000
    60.000
     4.000     9.000     5.000     3.000     8.000     5.000     8.000     2.000
    55.000
     5.000     2.000     1.000     9.000     7.000     4.000     3.000     3.000
    51.000
     7.000     6.000     7.000     3.000     9.000     2.000     7.000     1.000
    43.000
     2.000     3.000     9.000     5.000     7.000     2.000     6.000     5.000
    41.000
     5.000     5.000     2.000     2.000     8.000     1.000     4.000     3.000
    52.000
    35.000    37.000    22.000    32.000    41.000    32.000    43.000    38.000
    38.000

=============init Solution===================
    ******    37.000    ******    ******    23.000    ******    ******    ******

    ******    ******    ******    12.000    18.000    ******     3.000    ******

    ******    ******    22.000    ******    ******    ******    29.000    ******

    ******    ******    ******    ******    ******    ******     5.000    38.000

    35.000    ******    ******    ******    ******    ******     6.000    ******

    ******    ******    ******    20.000    ******    32.000    ******    ******



        The Cost is: 730.0000

=============Best Solution===================
    ******    19.000    ******    ******    41.000    ******    ******    ******

     1.000    ******    ******    32.000    ******    ******    ******    ******

    ******    11.000    ******    ******    ******    ******    40.000    ******

    ******    ******    ******    ******    ******     5.000    ******    38.000

    34.000     7.000    ******    ******    ******    ******    ******    ******

    ******    ******    22.000    ******    ******    27.000     3.000    ******



        The min Cost is: 664.0000
Press any key to continue

[linren]

[Quote=引用 22 楼 qiuzhenguang 的回复:]
linren 见多识厂，令人佩服！！谢谢你的解答！
[/Quote]
过奖了^_^

试着写了一个表上作业法的函数：

【程序】

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/**只用修改这里***********************************/
#define M 6
#define N 8
double tariff[M][N]={//运费
6, 2, 6, 7, 4, 2, 5, 9,
4, 9, 5, 3, 8, 5, 8, 2,
5, 2, 1, 9, 7, 4, 3, 3,
7, 6, 7, 3, 9, 2, 7, 1,
2, 3, 9, 5, 7, 2, 6, 5,
5, 5, 2, 2, 8, 1, 4, 3
};
double product[M]={60,55,51,43,41,52};//产量
double need[N]={35,37,22,32,41,32,43,38};//需求
/***********************************只用修改这里**/

struct ssp{
	double p;
	int m,n;
};

int compar(const void *a,const void *b){
	struct ssp *aa,*bb;
	aa=(struct ssp*)a;
	bb=(struct ssp*)b;
	if((aa->p)>(bb->p)) return 1;
	if((aa->p)==(bb->p)) return 0;
	return -1;
}

void find_loop(int pmc,int pnc,char* map,int m,int n,struct ssp* pssp,int* k);

void fun(double *tar,double *pro,int m,double *nee,int n){
	struct ssp* pssp;
	double *t,*pm,*pn;
	int i,j,k;
	double a,b,c;
	char *map,*mpm,*mpn;
	int pmc,pnc;

	pssp=(struct ssp*)malloc(sizeof(struct ssp)*m*n);
	t=(double*)malloc(sizeof(double)*m*n);
	pm=(double*)malloc(sizeof(double)*m);
	pn=(double*)malloc(sizeof(double)*n);
	map=(char*)malloc(sizeof(char)*m*n);
	mpm=(char*)malloc(sizeof(char)*m);
	mpn=(char*)malloc(sizeof(char)*n);

	memset(t,0,sizeof(double)*m*n);
	memcpy(pm,pro,sizeof(double)*m);
	memcpy(pn,nee,sizeof(double)*n);

	/*基本可行解*/
	k=0;
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			pssp[k].p=*(tar+i*n+j);
			pssp[k].m=i;pssp[k].n=j;
			k++;
		}
	}
	qsort(pssp,m*n,sizeof(struct ssp),compar);
	for(k=0;k<m*n;k++){
		a=pm[pssp[k].m];
		b=pn[pssp[k].n];
		if(a<b){
			*(t+pssp[k].m*n+pssp[k].n)=a;
			pm[pssp[k].m]=0;pn[pssp[k].n]-=a;
		}else{
			*(t+pssp[k].m*n+pssp[k].n)=b;
			pn[pssp[k].n]=0;pm[pssp[k].m]-=b;
		}
	}

	/*寻找最优解*/
	while(1){
		memset(map,0,sizeof(char)*m*n);
		memset(pm,0,sizeof(double)*m);
		memset(pn,0,sizeof(double)*n);
		memset(mpm,0,sizeof(char)*m);
		memset(mpn,0,sizeof(char)*n);

		/*判断方案是否最优*/
		k=0;
		for(i=0;i<m;i++){
			for(j=0;j<n;j++){
				if(*(t+i*n+j)!=0){
					*(map+i*n+j)=1;
				}else{
					pssp[k].p=*(tar+i*n+j);
					pssp[k].m=i;pssp[k].n=j;
					k++;
				}
			}
		}
		mpm[0]=1;
		pmc=1;pnc=0;
		while(pnc!=n||pmc!=m){
			for(i=0;i<m;i++){
				if(mpm[i]==0) continue;
				for(j=0;j<n;j++){
					if(*(map+i*n+j)==0) continue;
					if(mpn[j]==1) continue;
					pn[j]=*(tar+i*n+j)-pm[i];
					mpn[j]=1;pnc++;
				}
			}
			for(i=0;i<n;i++){
				if(mpn[i]==0) continue;
				for(j=0;j<m;j++){
					if(*(map+j*n+i)==0) continue;
					if(mpm[j]==1) continue;
					pm[j]=*(tar+j*n+i)-pn[i];
					mpm[j]=1;pmc++;
				}
			}
		}
		b=0;j=-1;
		for(i=0;i<k;i++){
			a=pssp[i].p-pm[pssp[i].m]-pn[pssp[i].n];
			if(a<0&&(b==0||a<b)){
				b=a;j=i;
			}
		}
		if(j==-1) break;
		pmc=pssp[j].m;//记录入基空格坐标
		pnc=pssp[j].n;//记录入基空格坐标

		/*下一个基本可行解*/
		find_loop(pmc,pnc,map,m,n,pssp,&k);
		b=0;
		for(i=0;i<k;i++){
			if(pssp[i].p<0){
				a=*(t+pssp[i].m*n+pssp[i].n);
				if(b==0||a<b) b=a;
			}
		}
		for(i=0;i<k;i++){
			if(pssp[i].p<0){
				*(t+pssp[i].m*n+pssp[i].n)-=b;
			}else{
				*(t+pssp[i].m*n+pssp[i].n)+=b;
			}
		}
	}
	
	/*打印最优解*/
	c=0;
	printf("【 solution 】\n\n");
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			if(*(t+i*n+j)==0) printf("%8s","------");
			else printf("%8.3f",*(t+i*n+j));
			c+=(*(t+i*n+j))*(*(tar+i*n+j));
		}
		printf("\n");
	}
	printf("\ncost: %-8.3f\n\n",c);

	free(t);free(pm);free(pn);free(pssp);free(map);free(mpm);free(mpn);
}

void find_loop(int pmc,int pnc,char* map,int m,int n,struct ssp* pssp,int* k){
	int i,d,c;
	int x,y;
	x=pmc;y=pnc;
	*(map+x*n+y)=3;
	d=1;c=0;
	pssp[c].m=x;pssp[c].n=y;pssp[c].p=1;
	while(d!=0){
		if(d==1){
			for(i=0;i<n;i++){
				if(c!=0&&*(map+x*n+i)==3){
					d=0;break;
				}
				if(*(map+x*n+i)==1){
					*(map+x*n+i)=2;
					c++;
					d=2;y=i;
					pssp[c].m=x;pssp[c].n=y;
					if(c%2==0) pssp[c].p=1;
					else pssp[c].p=-1;
					break;
				}
			}
			if(i==n){
				*(map+x*n+y)=0;
				d=2;c--;
				x=pssp[c].m;
			}
		}else{
			for(i=0;i<m;i++){
				if(c!=0&&*(map+i*n+y)==3){
					d=0;break;
				}
				if(*(map+i*n+y)==1){
					*(map+i*n+y)=2;
					c++;
					d=1;x=i;
					pssp[c].m=x;pssp[c].n=y;
					if(c%2==0) pssp[c].p=1;
					else pssp[c].p=-1;
					break;
				}
			}
			if(i==m){
				*(map+x*n+y)=0;
				d=1;c--;
				y=pssp[c].n;
			}
		}
	}
	*k=c+1;
}

int main(){
	fun(&tariff[0][0],product,M,need,N);
	return 0;
}

【运行结果】

【 solution 】

  ------  19.000  ------  ------  41.000  ------  ------  ------
   1.000  ------  ------  32.000  ------  ------  ------  ------
  ------  11.000  ------  ------  ------  ------  40.000  ------
  ------  ------  ------  ------  ------   5.000  ------  38.000
  34.000   7.000  ------  ------  ------  ------  ------  ------
  ------  ------  22.000  ------  ------  27.000   3.000  ------

cost: 664.000

Press any key to continue

感觉上难点是在于寻找入基空格的闭合回路上……

[zhongjiekangping]

这算法 , 看了多次 最后还是没有消化

[firePhoenix1981]

Mark!