动态规划算法介绍

http://www.stevenwang.name/dpa-knapsack-problem-31001.html

一、动态规划算法介绍

动态规划算法(Dynamic Programming Algorithm, DPA)与分治法类似，其基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划法求解的问题，经分解得到的子问题往往不是互相独立的，若用分治法解这类问题，则分解得到的子问题数目太多，以至于最后解决原问题需要耗费过多的时间。在用分治法求解时，有些子问题被重复计算了许多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算。为了达到此目的，可以用一个表来记录所有已解决的子问题的答案。这就是动态规划法的基本思想。

动态规划算法使用于解最优化问题。通常可按以下4个步骤设计：
1、找出最优解的性质，并刻画其结构特征；
2、递归地定义最优值；
3、以自底向上的方式计算出最优值；
4、根据计算最优值时得到的信息，构造最优解。

步骤1~3是动态规划算法的基本步骤。在只需要求出最优值的情形，步骤4可以省去。若需要求出问题的最优解，则必须执行步骤4。此时，在步骤3中计算最优值时，通常需记录更多的信息，以便在步骤4中，根据所记录的信息，快速构造出一个最优解。

二、0-1背包问题

【问题描述】：给定n种物品和一背包。物品i的重量是wi，其价值为vi，背包容量为c。问应如何选择装入背包中的物品，使得装入背包中物品的总价值最大。在选择装入背包的物品时，对每种物品i只有两种选择，即装入背包或不装入背包。不能将物品i装入背包多次，也不能只装入部分的物品i。因此，该问题称为0-1背包问题。

【算法分析】：0-1背包问题的最优子结构，设(y1,y2,...,yn)是所给0-1背包问题的一个最优解，则(y2,y3,...,yn)是经过一次选择后的0-1背包问题的最优解。0-1背包问题的递归关系，设当前子问题的最优值为m(i,j)，即m(i,j)使背包容量为j，可选择物品为i,i+1,...,n时0-1背包问题的最优值。由0-1背包问题的最优子结构性质，可以建立计算m(i,j)的递归式：
当i=n时，若j>=wn，则m(i,j)=vn；若0<=j<wn，则m(i,j)=0。
当i<n时，若j>=wi，则m(i,j)=max{m(i+1,j),m(i+1,j-wi)+vi}；若0<=j<wi，则m(i,j)=m(i+1,j)。

【算法实现】Knapsack算法的C++实现如下：
(其中背包信息从文件中读取，点击进入该文件下载界面)

#include "iostream"
using namespace std;

#define n 50   //物品的数量

//物体重量、收益、背包容量
int weight[n], profit[n], contain, x[n], **m;

//从文件中读取背包信息
int read_infor()
{
	FILE *fp;
	int i;
	if ((fp=fopen("knapsack.txt","r"))==NULL)
	{   
		printf("The file is not found!");
		return 0;
	}
	//读取物体收益信息
	for(i = 0;i < n;i++)
	{
		fscanf(fp, "%d", &profit[i]);
	}
	//读取物体重量信息
	for(i = 0;i < n;i++)
	{
		fscanf(fp, "%d", &weight[i]);
	} 
	//读取背包容量
	fscanf(fp, "%d", &contain);
	fclose(fp);
	return 1;
}

void Knapsack()
{
	int jMax = min(weight[n - 1] - 1, contain);
	int i, j;
	for(j = 0;j <= jMax;j++)
	{
		m[n - 1][j] = 0;
	}
	for(j = weight[n - 1];j <= contain;j++)
	{
		m[n - 1][j] = profit[n - 1];
	}
	for(i = n - 2;i > 0;i--)
	{
		jMax = min(weight[i] - 1, contain);
		for(j = 0;j <= jMax;j++)
		{
			m[i][j] = m[i + 1][j];
		}
		for(j = weight[i];j <= contain;j++)
		{
			m[i][j] = max(m[i + 1][j], m[i + 1][j - weight[i]] + profit[i]);
		}
	}
	m[0][contain] = m[1][contain];
	if(contain >= weight[0])
	{
		m[0][contain] = max(m[1][contain], m[1][contain - weight[0]] + profit[0]);
	}
}

void Traceback()
{
	int c = contain;
	for(int i = 0;i < n - 1;i++)
	{
		if(m[i][c] == m[i + 1][c])
		{
			x[i] = 0;
		}
		else
		{
			x[i] = 1;
			c -= weight[i];
		}
	}
	x[n - 1] = (m[n - 1][c]) ? 1 : 0;
}

void main()
{
	int i, sumWeight = 0;
	if(read_infor())
	{
		m = (int**)malloc(n * sizeof(int*));
		for(i = 0;i < n;i++)
		{
			m[i] = (int*)malloc(contain * sizeof(int));
		}
		Knapsack();
		Traceback();
	}
	printf("The choice is:  \n");
	for(i = 0;i < n;i++)
	{
		sumWeight += weight[i] * x[i];
		if(i != 0 && i % 5 == 0) 
		{
			printf(" ");
		}
		printf("%1d", x[i]);
	}
	printf("\nThe maximum profit is: %d.", m[1][contain]);
	printf("\nThe knapsack weight is %d.\n", sumWeight);
	scanf("%d", &i);
	for(i = 0;i < n;i++)
	{
		free(m[i]);
	}
	free(m);
}

【算法复杂度分析】：从计算m(i,j)的递归式容易看出，上述算法Knapsack需要O(nc)计算时间，而Traceback需要O(n)计算时间。其中，算法Knapsack还存在可以改进的地方，改进算法将在后续的文章中给出。