动态规划（01背包问题）

首先要想办法求出状态转移方程，自然会想到在背包放a物品和不放a物品的背包价值需要做比较，用f（i，y）表示背包的总价值，i表示第i到n（物品总量）个物品，y表示此时背包的剩余容量，即需要求出max{f（i，y），f（i,y-wi）+pi）}, 此时y比如要大于等于wi。加上i为最后一个物品时的特殊情况，可以写出方程：

f(n,y) =pn                                                  (y >= wn),

           0                                                    (y < wn);  

f(i, y) = max{f(i-1,y), f(i, y-wi)+pi}             (y >= wn),  

             f(i-1, y)                                        (y < wn)

此方程很容易用递归实现

int f(int num, int y, int &count)
{
	count++;
	if (num == Num-1)
		return (y < weight[num] ? 0 : profit[num]);
	if (y < weight[num])
		return f(num+1, y, count);
	return max(f(num + 1, y, count), f(num + 1, y - weight[num], count) + profit[num]);
}

若用capacity = 10; Num = 5;weight[5] = { 2,2,6,5,4 };profit[5] = { 6,3,5,4,6 }; 来测试，计数器返回27，说明迭代了27次，其中有重复计算f（4,8），f(4,2)  等。

为避免重复计算，设计一个二维矩阵保存已计算的值，若矩阵>=0直接放回， 得到一个新的f

int f_New(int num, int y, int &count)
{
	if (arr[num][y] >= 0)
		return arr[num][y];
	count++;
	if (num == Num - 1)
	{
		arr[num][y] = (y < weight[num] ? 0 : profit[num]);
		return arr[num][y];
	}
	if (y < weight[num])
	{
		arr[num][y] = f_New(num + 1, y, count);
		return arr[num][y];
	}
	arr[num][y] = max(f_New(num + 1, y, count), f_New(num + 1, y - weight[num], count) + profit[num]);
	return arr[num][y];

}

此时count返回21，去除了重复计算。

用迭代代替递归

int knapsack(int *profit, int *weight, int NumOfOjects, int capacity, int **f)
{
	for (int i = 0; i < NumOfOjects; i++)
	{
		f[i][0] = 0;
	}
	for (int i = 1; i < capacity + 1; i++)
	{
		if (weight[0] > i)
			f[0][i] = 0;
		else
			f[0][i] = profit[0];

		for (int j = 1; j < NumOfOjects; j++)
		{
			if (weight[j] > i)
				f[j][i] = f[j - 1][i];
			else
				f[j][i] = max(f[j - 1][i], f[j - 1][i - weight[j]] + profit[j]);
		}
	}

	return f[NumOfOjects - 1][capacity];
}