01背包问题：初入动规坑

**

01背包问题

**

有n个重量和价值分别为wi，vi的物品，从这些物品中挑选出总重量不超过W的物品，求所有挑选方案中价值总和的最大值。

这是被称为背包问题的一个著名问题。这个问题怎么求解好呢？这个问题是我遇到的第一个动规问题，最开始做的时候并不知道动规的思想，所以直接使用了最简单的方法：对每个物品是否放入背包进行枚举，然后对所有情况求最大值。

枚举的规律很简单，只需要分三种情况：

①：已经没有剩余的物品了，直接return 0；

②：如果挑选了这个物品重量就会超出限制，跳过这个物品；

③：如果可以挑选这个物品，只需要把挑选和不挑选都尝试一下就好了。

代码如下：

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

static int rec(int, int, int *, int *, int);

static int max(int, int);

int main()
{
int n, W;
printf("Please input n & W : \n");
scanf("%d %d",&n,&W);
int * w = (int *)malloc(n * sizeof(int));
int * v = (int *)malloc(n * sizeof(int));
for (int i = 0; i < n; i++)
{
scanf("%d %d",&w[i],&v[i]);
}
printf("%d\n",rec(0,W,w,v,n));
return 0;
}

int rec(i, j, w, v, n)
int i, j, n;
int * w, * v;
{
int res;
if (i == n)
res = 0;
else if (j < w[i])
res = rec(i+1,j,w,v,n);
else
res = max(rec(i+1,j,w,v,n), rec(i+1,j-w[i],w,v,n)+v[i]);
return res;
}

int max(int i, int j)
{
if (i > j)
return i;
else
return j;
}

但是这种方法的搜索深度是n，而且每层的搜索有需要两次分支，最坏情况下就需要O(2^n)的时间复杂度，当n比较大时就不具有可执行性了。怎么办才好呢？当我们分析程序的执行过程时，我们发现有很多值出现了多次，由于栈与栈的相互独立原理，每次计算都是与其他计算无关的。所以我们可以把第一次计算的结果给记录下来，省略掉第二次以后的重复计算试试看。

那么就模拟一个二维数组，由于一共n个物品，可以带走的总重量不超过W，所以就创建一个n*W的数组，并通过宏定义将其模拟为二维数组，将每个数第一次的计算结果记录下来。在函数调用时，如果发现结果已经计算过的话就直接使用之前计算的结果。原理已经知道了，那就来试一下吧：

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

#define dp(M,N,length)  dp[(M)*length+(N)+M]

static int rec(int, int, int *, int *, int *, int);

static int max(int, int);

int main()
{
int n, W;
printf("Please input n & W : \n");
scanf("%d %d",&n,&W);
int sdp = n * W;
int * w = (int *)malloc(n * sizeof(int));
int * v = (int *)malloc(n * sizeof(int));
int * dp = (int *)malloc(sdp * sizeof(int));
for (int i = 0; i < n; i++)
{
scanf("%d %d",&w[i],&v[i]);
}
memset(dp,-1,sdp * sizeof(int));
printf("%d\n",rec(0,W,dp,w,v,n));
return 0;
}

int rec(i, j, dp, w, v, n)
int i, j;
int * dp, * w, * v, n;
{
if (dp(i,j,n) >= 0)
return dp(i,j,n);
int res;
if (i == n)
res = 0;
else if (j < w[i])
res = rec(i+1,j,dp,w,v,n);
else
res = max(rec(i+1,j,dp,w,v,n),rec(i+1,j-w[i],dp,w,v,n)+v[i]);
dp(i,j,n) = res;
return dp(i,j,n);
}

int max(int i, int j)
{
if (i > j)
return i;
else
return j;
}

这样就通过记忆优化和递归的方式实现了对问题的求解。

这样微小的改动到底带来了多少速度呢？对于同样的参数，只会在第一次调用时执行递归部分，第二次调用时就可以直接在数组中找到对应的值。参数的组合不超过n*W种，所以只需要O(n*W)的时间就能解决这个问题。

当然，我们可以用非递归替换递归，这样子就不需要入栈出栈操作，程序的运行速度就可以进一步提高。非递归与递归没有太大差别，所以第二个程序写出来后，就可以直接站撸非递归算法了，写法很简单，在数组里循环求解就行了。

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

#define dp(M,N,length)  dp[(M)*length+(N)+M]

static int rec(int *, int *, int *, int, int);

static int max(int, int);

int main()
{
int n, W;
printf("Please input n & W : \n");
scanf("%d %d",&n,&W);
int sdp = n * W;
int * w = (int *)malloc(n * sizeof(int));
int * v = (int *)malloc(n * sizeof(int));
int * dp = (int *)malloc(sdp * sizeof(int));
for (int i = 0; i < n; i++)
{
scanf("%d %d",&w[i],&v[i]);
}
memset(dp,0,sdp * sizeof(int));
printf("%d\n",rec(w,v,dp,n,W));
return 0;
}

int rec(w,v,dp,n,W)
int * w, * v;
int * dp;
int n, W;
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j <= W; j++)
{
if (j < w[i])
dp(i+1,j,n) = dp(i,j,n);
else
dp(i+1,j,n) = max(dp(i,j,n),dp(i,j-w[i],n)+v[i]);
}
}
return dp(n,W,n);
}

int max(int i, int j)
{
if (i > j)
return i;
else
return j;
}

源代码可以直接编译运行，但是建议大家不要直接拷贝下去运行。其实你我心里也都明白，算法是思想，而不是单纯的代码，希望你们都能认真分析原理，总结题目的经验和特点，在下次遇到类似题目的时候不必上网查。

我是算法吹，以后会给大家带来更多精彩的算法。