动态规划：01背包问题

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

二维

#include <iostream>

using namespace std;
const int N = 1010;
int f[N][N];//f[i][j]表示前i-1个物品体积小于等于j的最优解（价值最大）
int v[N],w[N];
int n , m;
int main()
{
    cin >> n >> m;
    for (int i = 1 ; i <= n ; i ++)  cin >> v[i] >> w[i];
    
    for (int i = 1 ; i <= n ; i ++)
      for (int j = 0 ; j <= m ; j ++)
      {
          f[i][j] = f[i - 1][j];//不选i
          
          //选i,判断一下，背包容量是否够第i个物品的体积
          if ( j >= v[i]) 
          {
              f[i][j] = max(f[i][j] , f[i - 1][j - v[i]] + w[i]);//前i-1个物品的价值+上第i个物品的价值
          }
      }
    cout << f[n][m] << endl; //f[n][m]表示在前n个物品中选出体积小于等于m的最大价值
    return 0;
}

一维优化

#include <iostream>
using namespace std;
const int N  = 1010;
int f[N]; //  f[j] 表示前n件物品中，背包体积小于等于j的最大价值
int n , m;
int v[N] , w[N];
int main()
{
    cin >> n >> m;
    for (int i = 1 ; i <= n ; i ++)  cin >> v[i] >> w[i];
    
    for (int i = 1 ; i <= n ; i ++)
       for (int j = m ; j >= v[i] ; j --)//需要逆序遍历j
       f[j] = max (f[j] , f[j - v[i]] + w[i]);
   //对应表示：f[i][j] = max (f[i][j] , f[i - 1][j - v[i] + w[i]];
   //为什么要逆序遍历j呢？
   /*如果正序遍历j，循环到第i行，从左到右依次遍历j,
     当更新到某个j时用到了j - v[i] ,而此时j-v[i]已经在第i行被更新过了，
     (因为j-v[i] < j , j - v[i]一定会在j之前被更新)，此时表示f[i][j - v[i]]
     但在二维表示f[i - 1][j - v[i]，所以正序计算的不正确
   */
    
    cout << f[m] <<endl; //表示前n件物品中，背包体积小于等于m的最大价值
    return 0;
}

证明：j层循环是递增的，则是错误的
例子：假设有3件物品，背包的总体积为10

   物品    体积     价值 
  i = 1     4       5  
  i = 2     5       6  
  i = 3     6       7  

因为 f[0][j] 总共0件物品，所以最大价值为 0， 即 f[0][j] == 0 成立

    如果 j 层循环是递增的： 
    for (int i = 1; i <= n; i++) {
        for (int j = v[i]; j <= m; j++) {
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }

 当还未进入循环时:
    f[0] = 0;  f[1] = 0;  f[2] = 0;  f[3] = 0;  f[4] = 0;  
    f[5] = 0;  f[6] = 0;  f[7] = 0;  f[8] = 0;  f[9] = 0; f[10] = 0;
    当进入循环 i == 1 时：
    f[4] = max(f[4], f[0] + 5); 即max(0, 5) = 5; 即f[4] = 5;
    f[5] = max(f[5], f[1] + 5); 即max(0, 5) = 5; 即f[5] = 5;
    f[6] = max(f[6], f[2] + 5); 即max(0, 5) = 5; 即f[6] = 5;
    f[7] = max(f[7], f[3] + 5); 即max(0, 5) = 5; 即f[7] = 5;
    重点来了！！！
    f[8] = max(f[8], f[4] + 5); 即max(0, 5 + 5) = 10; 即f[8] = 10;
    这里就已经出错了
    因为此时处于 i == 1 这一层，即物品只有一件，不存在单件物品满足价值为10
    所以已经出错了。

    如果 j 层循环是逆序的：
    for (int i = 1; i <= n; i++) {
        for (int j = m; j >= v[i]; j--) {
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }

  当还未进入循环时:
    f[0] = 0;  f[1] = 0;  f[2] = 0;  f[3] = 0;  f[4] = 0;  
    f[5] = 0;  f[6] = 0;  f[7] = 0;  f[8] = 0;  f[9] = 0; f[10] = 0;
    当进入循环 i == 1 时：w[i] = 5; v[i] = 4;
    j = 10：f[10] = max(f[10], f[6] + 5); 即max(0, 5) = 5; 即f[10] = 5;
    j = 9 ：f[9] = max(f[9], f[5] + 5); 即max(0, 5) = 5; 即f[9] = 5;
    j = 8 ：f[8] = max(f[8], f[4] + 5); 即max(0, 5) = 5; 即f[8] = 5;
    j = 7 ：f[7] = max(f[7], f[3] + 5); 即max(0, 5) = 5; 即f[7] = 5;
    j = 6 ：f[6] = max(f[6], f[2] + 5); 即max(0, 5) = 5; 即f[6] = 5;
    j = 5 ：f[5] = max(f[5], f[1] + 5); 即max(0, 5) = 5; 即f[5] = 5;
    j = 4 ：f[6] = max(f[4], f[0] + 5); 即max(0, 5) = 5; 即f[4] = 5;
    当进入循环 i == 2 时：w[i] = 6; v[i] = 5; 
    j = 10：f[10] = max(f[10], f[5] + 6); 即max(5, 11) = 11; 即f[10] = 11;
    j = 9 ：f[9] = max(f[9], f[4] + 6); 即max(5, 11) = 5; 即f[9] = 11;
    j = 8 ：f[8] = max(f[8], f[3] + 6); 即max(5, 6) = 6; 即f[8] = 6;
    j = 7 ：f[7] = max(f[7], f[2] + 6); 即max(5, 6) = 6; 即f[7] = 6;
    j = 6 ：f[6] = max(f[6], f[1] + 6); 即max(5, 6) = 6; 即f[6] = 6;
    j = 5 ：f[5] = max(f[5], f[0] + 6); 即max(5, 6) = 6; 即f[5] = 6;
    当进入循环 i == 3 时: w[i] = 7; v[i] = 6; 
    j = 10：f[10] = max(f[10], f[4] + 7); 即max(11, 12) = 12; 即f[10] = 12;
    j = 9 ：f[9] = max(f[9], f[3] + 6); 即max(11, 6) = 11; 即f[9] = 11;
    j = 8 ：f[8] = max(f[8], f[2] + 6); 即max(6, 6) = 6; 即f[8] = 6;
    j = 7 ：f[7] = max(f[7], f[1] + 6); 即max(6, 6) = 6; 即f[7] = 6;
    j = 6 ：f[6] = max(f[6], f[0] + 6); 即max(6, 6) = 6; 即f[6] = 6;

就模拟一下发现没有错误，即逆序就可以解决这个优化的问题了