01背包（降维 + 常数级优化）

题目：

    共n个物体，第i个重量为w[i]，价值v[i]，背包最多能背不超过W的物体，求最大的价值

分析：

    每个物体只有一个，在容量允许时（W>w[i]），则对于每个物体只有取、不取两种选择

    状态：dp[i][j]：前i个物体，在容量为j的时候，最大的价值

    状态转移：

        dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i]);

二维核心：

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

二维代码：

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <string>
#include <math.h>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <vector>

using namespace std;

int w[100], v[100];
int dp[100][100];

int main()
{
	freopen("a.txt", "r", stdin);
	int n, W, i, j;
	while(~scanf("%d%d", &W, &n))
	{
		memset(dp, 0, sizeof(dp));
		for(i = 1; i<=n; i++)
		{
			scanf("%d%d", &w[i], &v[i]);
		}
		for(i = 1; i<=n; i++)
		{
			for(j = 0; j<=W; j++)
			{
				if(j<w[i])
					dp[i][j] = dp[i-1][j];
				else
					dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i]);
			}
		}
		printf("%d\n", dp[n][W]);
	}
	return 0;
}

降维：

    减行，第i个物体的更新，只依赖于第i-1个的物体的结果

    所以可以用滚动数组，每次只存i和i-1时候的值 （可得：dp[n][W] → dp[2][W] ）

    删行，第i个物体在容积为j状态的更新，只依赖i-1物体容量里j-w[i]的状态的结果

    所以，从后面开始向前更新，则求j位置时候，j-w[i]的值依旧为i-1时候的值（可得：dp[n][W] → dp[W] ）

一维核心：

for(i = 1; i<=n; i++)
{
    for(j = W; j>=w[i]; j--) //从后向前，此时dp[j-w[i]]相当于dp[i-1][j-w[i]]
    {
        dp[j] = max(dp[j], dp[j-w[i]] + v[i]);
    }
}

一维代码：

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <string>
#include <math.h>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <vector>

using namespace std;

int w[100], v[100];
int dp[100];

int main()
{
	freopen("a.txt", "r", stdin);
	int n, W, i, j;
	while(~scanf("%d%d", &W, &n))
	{
		memset(dp, 0, sizeof(dp));
		for(i = 1; i<=n; i++)
		{
			scanf("%d%d", &w[i], &v[i]);
		}
		for(i = 1; i<=n; i++)
		{
			for(j = W; j>=w[i]; j--)
			{
				dp[j] = max(dp[j], dp[j-w[i]] + v[i]);
			}
		}
		printf("%d\n", dp[W]);
	}
	return 0;
}

初始化：

    1、memset(dp, 0, sizeof(dp))

        求不超过容积的W的最大价值

        容积有剩余的状态依旧有值，为前一个恰好装满最优解的值

    2、memset(dp, -0x3f, sizeof(dp)); //负无穷、不可达点（当前值约为：-1e+10）

        求恰好装满容积的最大价值（可能无解）

        当且仅当恰好装满的状态有值，其他存在空白容积的状态无法到达

常数级优化：

    一维中的内循环下限，由j>=w[i] → j>=max{w[i], W-(∑(i,n)w[i])}

    1、下限为j>=w[i]时候

        在所有剩余容积大于等于w[i]时候，选择取、不取第i物品

    2、下限为j>=max{w[i], W-(∑(i,n)w[i])}时候

        只更新在i+1时候需要用到的状态，并不把所以可能状态求出

常数级优化代码：

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <string>
#include <math.h>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <vector>

using namespace std;

int w[100], v[100];
int dp[100];

int main()
{
	freopen("a.txt", "r", stdin);
	int n, W, i, j;
	while(~scanf("%d%d", &W, &n))
	{
		memset(dp, 0, sizeof(dp));
		for(i = 1; i<=n; i++)
		{
			scanf("%d%d", &w[i], &v[i]);
		}
		int lower, sum = 0;
		for(i = 1; i<=n; i++)
		{
			if(i!=1) sum += w[i-1];
			lower = max(sum, w[i]);
			for(j = W; j>=lower; j--)
			{
				dp[j] = max(dp[j], dp[j-w[i]] + v[i]);
			}
		}
		printf("%d\n", dp[W]);
	}
	return 0;
}