动态规划(原理及C++实现)

动态规划简介

  动态规划是运筹学的一个分支，是解决多阶段决策过程最优化的一种数学方法，主要用于以时间或低于划分阶段的动态过程最优化。在计算机领域也多有应用，最广为人知的应该是动态规划解01背包问题。

例题

  给定n个物料的权重和值，将这些物料放在容量为W的背包中，以在背包中获得最大的总价值。

算法分析

  背包问题的状态转移方程
f [ i , j ] = m a x { f [ i − 1 , j − w i ] + v i ( j > = w i ) , f [ i − 1 , j ] } f[i,j]=max \left \{ f[i-1,j-w_{i}]+v_{i}(j>=w_{i}),f[i-1,j] \right \} f[i,j]=max{f[i−1,j−wi​]+vi​(j>=wi​),f[i−1,j]}
  $f[i,j]$表示在前i件物品中选择若干件放在承重为 j 的背包中，可以取得的最大价值。
  $v_i$表示第i件物品的价值。
  决策：为了背包中物品总价值最大化，第 i件物品应该放入背包中吗 ？

算法演绎

  现在假设有有产品$a,b,c,d,e$其价值分别是$5,3,2,5,6$,其重量分别是$3,2,5,8,4$
  使用代码一次进行演绎，依次计算，只拿第一组，只拿前两组，…，只拿前五组的情况

#include <iostream>
using namespace std;

int max(int a, int b) { return (a > b) ? a : b; }

int KnapSack(int val[], int wt[], int n, int W)
{
	int ret;
	int ** mat = new int *[n];
	for (int i = 0; i < n; i++) {
		mat[i] = new int[W + 1];
		for (int j = 0; j < W + 1; j++)
			mat[i][j] = 0;
	}
	
		for (int i = 0; i < n; i++) {
			for (int j = 1; j <= W; j++) {
				if (j > wt[i]) {
					if (i == 0)
						mat[i][j] = val[i];
					else
						mat[i][j] = max(val[i] + mat[i - 1][j - wt[i]], mat[i - 1][j]);
				}
				else {
					if (i == 0)
						mat[i][j] = 0;
					else
						mat[i][j] = mat[i-1][j];
				}
		}
	}



	for (int i = 0; i < n; i++) {
		for (int j = 1; j < W + 1; j++) {
			cout << mat[i][j] << ", ";
		}
		cout << endl;
	}
	for (int i = 0; i < n; i++) {
		delete[]	mat[i];
	}
	delete[] mat;

	return 0;
}

int main()
{
	int val[] = { 5,3,2,5,6 };
	int wt[] = { 3,2,5,8,4 };
	int W = 10;
	int n = sizeof(val) / sizeof(val[0]);
	KnapSack(val, wt, n, W);
	system("pause");
	return 0;
}

递归算法解题

  递归解题是一种很好的思路，只需要借助简单的逻辑就能实现这个复杂的功能。

递归代码

#include <iostream>
using namespace std;

int max(int a, int b) { return (a > b) ? a : b; }

int knapSack(int W, int wt[], int val[], int n)
{
	if (n == 0 || W == 0)
		return 0;

	if (wt[n - 1] > W)
		return knapSack(W, wt, val, n - 1);
	else
		return max(
			val[n - 1] + knapSack(W - wt[n - 1],
				wt, val, n - 1),
			knapSack(W, wt, val, n - 1));
}

int main()
{
	int val[] = { 5,3,2,5,6 };
	int wt[] = { 3,2,5,8,4 };
	int W = 50;
	int n = sizeof(val) / sizeof(val[0]);
	cout << knapSack(W, wt, val, n);
	return 0;
}

  上述代码使用了递归的方式实现DP模型.
  其中，

	if (wt[n - 1] > W)
		return knapSack(W, wt, val, n - 1);

  表示，如果当前物品的值大于背包的总重量，则不取
  其中，

	else
		return max(
			val[n - 1] + knapSack(W - wt[n - 1],
				wt, val, n - 1),
			knapSack(W, wt, val, n - 1));

  表示，如果取当前物品能够使得价值增加，则取，否则则不取

代码分析

  这段代码的精妙之处在于递归。递归就是自己调用，自己直接递归程序与间接递归中都要实现当前层调用下一层时的参数传递，并取得下一层所返回的结果，并向上一层调用返回当前层的结果。至于各层调用中现场的保存与恢复，均由程序自动实现，不需要人工干预。因此，在递归程序的设计中关键是找出调用所需要的参数、返回的结果及递归调用结束的条件。
  使用递归旨在，通过简单的代码实现复杂功能。

经典的递归程序

//阶乘
int factorial(int n)
{
   if(n == 1)
   {
      return 1;
   }
   else
   {
      return n * factorial(n - 1);
   }
}

空间优化后的递归代码

  很多人编写递归求01背包问题时都采用本文所示第一种写法，当背包的个数很大时，则会造成严重的内存浪费，这里对上述代码进行了空间优化。

#include <iostream>
using namespace std;

int max(int a, int b) { return (a > b) ? a : b; }

int KnapSack(int val[], int wt[], int n, int W)
{
	int ** mat = new int *[2];
	for (int i = 0; i < 2; i++) {
		mat[i] = new int[W + 1];
		for (int j = 0; j < W + 1; j++) {
			mat[i][j] = 0;
		}
	}
	int i = 0;
	while (i < n)
	{
		int j = 0;
		if (i % 2 != 0)
		{
			while (++j <= W)
			{
				if (wt[i] <= j) 
					mat[1][j] = max(val[i] + mat[0][j - wt[i]],
						mat[0][j]);
				else 
					mat[1][j] = mat[0][j];
			}
		}
		else
		{
			while (++j <= W)
			{
				if (wt[i] <= j)
					mat[0][j] = max(val[i] + mat[1][j - wt[i]],
						mat[1][j]);
				else
					mat[0][j] = mat[1][j];
			}
		}
		i++;
	}
	int ret;
	if (0 != n % 2) {
		ret = mat[0][W];
	}
	else {
		ret = mat[1][W];
	}
	for (int i = 0; i < 2; i++) {
		delete []	mat[i];
	}
	delete[] mat;
	return ret;
}

int main()
{
	int val[] = { 5,3,2,5,6 };
	int wt[] = { 3,2,5,8,4};
	int W = 6;
	int n = sizeof(val) / sizeof(val[0]);
	cout << KnapSack(val, wt, n, W) << endl;
	//system("pause");
	return 0;
}