ナップザック問題（個数制限あり、なし）を動的計画法で解くために理解する

ナップザック問題とは、「*n* 種類の品物（各々、価値 *v<sub>i</sub>*、重量 *w<sub>i</sub>*）が与えられたとき、重量の合計が *W* を超えない範囲で品物のいくつかをナップサックに入れて、その入れた品物の価値の合計を最大化するには入れる品物の組み合わせをどのように選べばよいか」（Wikipedia）という問題です。<br>

#### ナップザック問題（各1個）
ナップザック問題の基本パターンとして、品物が1個ずつの場合がよく説明される。例えば、n=3の場合で考えてみる。品物を〇、□、△としてそれぞれの価値、重さを<br>
![knapsack.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/ec47199e-b1d0-41bc-abe1-54b00b83b640.jpeg)<br>
とし、ナップザックに入れられる重さの上限を10として、最も価値が高くなるように品物を選ぶ。<br>
まず、解を全探索（それぞれの品物を選ぶ・選ばないをbitで表すとbit全探索）で求めると、<br>
![全探索.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/89aa643b-ec66-4458-933c-f694fedc1663.jpeg)<br>
と解13が得られる。このn=3の場合は、2<sup>3</sup>-1通り（どれも選ばないを除くため）なので、全探索でも解が得られる。しかし、n=20になると、2<sup>10</sup>-1=048575通りと計算量が大幅に増加してしまう。<br>

#### DP（動的計画法）
これを動的計画法で解くと、このようになる。<br>
![dp1.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/5a52f6e0-1320-4440-ae39-e2f7e966ddd4.jpeg)<br>
この表は、重さ1～10の各重さごとに、価値が最大になる品物の選び方を決めたものである。<br>

- 重さの上限が1、2のときは、どの品物も選ぶことができない
- 重さの上限が3のとき、品物□のみ選ぶことができるので、品物□を選び、価値は5となる
- 重さの上限が4のとき、品物□の代わりに品物〇を選ぶと価値が7で最大となる
- 重さの上限が5、6のとき、重さの上限が4のときの状態を維持する
- 重さの上限が7のとき、品物□を加えることができ、価値は12となる
- 重さの上限が8のとき、重さの上限が7の状態を維持する
- 重さの上限が9のとき、品物□の代わりに品物△を選ぶと、価値は13となる
- 重さの上限が10のとき、重さの上限が9の状態を維持する

重さの上限が3から4になるときを見てみる。重さの上限が3のときは品物□が選ばれているが、上限が4になると品物〇と△を選ぶことができるかどうかを調べる。品物〇を選ぶには、品物〇の重さ4だけ重さの和が小さい状態（つまり重さの上限が0の状態＝品物□を選んでいない）に対して品物〇を追加した状態を考える。この状態の価値は品物〇の価値7となる。品物△は重さが7なので選ぶことはできない。品物〇を選ばない場合は、重さの上限が3のとき維持するため、品物〇を選ぶことで価値が増える。価値が大きい状態を選択するので、品物□の代わりに品物〇を選ぶ。<br>

このような手順で、重さの上限を1から10まで増やしていきながら、価値の最大値を更新していく。そこで、下のような表を作る。<br>
![dp1-1.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/b39a1474-ec85-46e1-bfe4-804167915f23.jpeg)<br>
どの品物も選ばない状態を初期値として、表の上から下に品物を順番に調べていく。各品物について、重さの上限0～10までとして品物を選ぶ・選ばないで価値が最大になる方を選んでいく。表の各マスは、品物を*i*、重さを*j*としてdp[*i*][*j*]と表し、マスの中には価値の最大値を書いていく。<br>
品物〇を選ぶ・選ばないを調べていくには、初期状態（*i*=0）に対して、品物〇の重さだけ小さい重さのときの価値の最大値＋品物〇の価値と、品物〇を選ばないときの価値の大きい方をそのマスに書いていく。<br>
品物□を選ぶ・選ばないを調べていくときは、品物〇について調べた状態に対して、品物□の重さだけ小さい重さのときの価値の最大値＋品物□の価値と、品物□を選ばない（品物〇を調べた状態）ときの価値の大きい方をそのマスに書いていく。品物△についても、同じように調べていく。<br>
品物〇について、重さの上限が4のときを式で表すと、<br>

- 品物〇を選ぶ場合：dp[1][4] = dp[0][0] + 7
- 品物〇を選ばない場合：dp[1][4] = d[0][4]

となり、大きい方の値をdp[1][4]とする。品物〇、品物□、品物△についてそれぞれ調べていくと、<br>

品物〇について調べた状態<br>
![dp1-2.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/86c3168c-bef8-427b-8dc1-c682845d31df.jpeg)<br>
品物□について調べた状態<br>
![dp1-3.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/fda1f437-f5db-492f-ae66-2428e7875e81.jpeg)<br>
品物△について調べた状態<br>
![dp1-4.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/8446026a-1717-4cb9-82ec-1c6bbd6f2975.jpeg)<br>

と表のすべてのマスを埋めることができ、品物3つついて、重さの和が10以下のときの価値の最大値がdp[3][10]に得られている。この表をすべて埋めるのには、3×10=30（i=0は初期値でi=1～3を計算）の計算量となる。<br>
n=3の場合で見ると、全探索の方が計算量が少ないが、n=20になると20×10=200回となり、動的計画法の方がはるかに少ない計算量で解を得ることができる。<br>

#### 実装例（C++）
3つの品物について、各品物の価値、重さが一行ずつ与えられる。<br>
```
7 4
5 3
6 5
```
各行の価値、重さをvectorに読み込んで、ナップザック問題を解いていく。<br>
```
int main() {
  int n = 3, m = 10;                    /* 3 items, weight <= 10 */
  vector<int> v(n), w(n);               /* v: value, w: weight */
  for (int i = 0; i < n; i++)
    cin >> v[i] >> w[i];
}
```
重さ1～mで価値が最大になるように、品物1～nを選ぶ・選ばないを決めていく。<br>
```
int main() {
  int n = 3, m = 10;                    /* 3 items, weight <= 10 */
  vector<int> v(n), w(n), c(n);         /* v: value, w: weight, c: count */
  for (int i = 0; i < n; i++)
    cin >> v[i] >> w[i] >> c[i];

  vector<vector<int>> dp(n+1, vector<int> (m+1, 0)); /* vector table*/
  for (int i = 0; i < n; i++) {
  	for (int j = 1; j < m+1; j++) {
      if (j < w[i])
	      dp[i+1][j] = dp[i][j];
      else
	      dp[i+1][j] = max(dp[i][j - w[i]] + v[i], dp[i][j]);
    }
  }
  cout << dp[n][m] << endl;
}
```
<br>

#### ナップザック問題（個数あり）
各品物に対して、複数個選べる場合を考える。例として□のみ3個を上限として選べる場合を考える。<br>
![knapsack2.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/cc060b56-7715-4f59-aaa2-b962b96be19e.jpeg)<br>
品物□について、個数1～3で価値が最大になる場合を調べると、<br>
```
  vector<vector<int>> dp(n+1, vector<int> (m+1, 0)); /* vector table */
  for (int i = 0; i < n; i++) {
    for (int j = 1; j < m+1; j++) {
      for (int k = 1; k <= c[i]; k++) { /* check item numbers for c[i] */
        if (j < w[i] * k)
          dp[i+1][j] = max(dp[i+1][j], dp[i][j]);
        else
          dp[i+1][j] = max({dp[i][j - w[i]*k] + v[i]*k, dp[i+1][j], dp[i][j]});
        }
    }
  }
```
のようなコードが書ける。<br>
これをdp表（上のコードと同一ではないが、個数1～3について調べる部分をdp表上に展開した形）にしてみると、<br>
![dp2.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/b944adf6-6cfd-4e5d-8e22-7001e21cc892.jpeg)<br>
とできるが、ここで3個を選ぶというのは、1個と2個の両方を選ぶのと同じなので、3個の場合は不要で<br>
![dp2-2.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/1884d221-4c0e-4959-8e86-69ce175268cf.jpeg)<br>
とできる。<br>

これは、数を2進表記するのと同じで、例えば7以下の数は、1と2と4の組み合わせで表現できる。ただし、例えば10の場合、1と2と4と8の組み合わせで表現しようとすると、1+2+4+8=16となり上限の10を超えてしまうことに注意が必要である。そこで、組み合わせの最大値が上限の10になるように、1+2+4+3とする。<br>
![累乗数1.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/b61434f6-0e9e-4ca5-afdf-f80d9c9dcddf.jpeg)<br>
このようにすると、例えば10個の個数を調べるのに、4つの組み合わせで済むことになる。<br>

![累乗数2.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/4054118/835e9c14-d3ff-4500-acb9-a0e73a42d93e.jpeg)<br>
<br>
数を2の累乗数に分解する（x=2<sup>0</sup>+2<sup>1</sup>+...+2<sup>n</sup>+m）には、<br>

```
vector<int> decomp(int x) {             /* decomposition */
  vector<int> v;                        /* array size undeclared */
  int p = 1;
  while (x > 0) {
    v.push_back(min(p, x));             /* append 2^x or residual */
    x -= min(p, x);
    p *= 2;
  }
  return v;
}
```
とすることで、配列 [2<sup>0</sup>, 2<sup>1</sup>, ... , 2<sup>n</sup>, m] が生成される。これを使って、<br>
```
int main() {
  int n = 3, m = 10;                    /* 3 items, weight <= 10 */
  vector<int> v, w;                     /* array size undeclared */
  for (int i = 0; i < n; i++) {
    int vi, wi, ci;
    cin >> vi >> wi >> ci;
    vector<int> d = decomp(ci);         /* decomposition */
    for (int x : d) {                   /* item of 2^? */
      v.push_back(v * x);
      w.push_back(w * x);
    }
  }
  int nn = (int)v.size();

  vector<vector<int>> dp(nn+1, vector<int> (m+1, 0)); /* dp table */
  for (int i = 0; i < nn; i++) {
    for (int j = 1; j < m+1; j++) {
      if (j < w[i])
        dp[i+1][j] = dp[i][j];
      else
        dp[i+1][j] = max(dp[i][j - w[i]] + v[i], dp[i][j]);
    }
  }
  cout << dp[nn][m] << endl;
}
```

#### ナップザック問題（個数制限なし）
各品物に個数制限がなく、何個でも選ぶことができる問題の場合を考える。<br>
この場合、各品物の個数の上限＝重さの上限を超えない範囲の最大の個数、となる。つまり、<br>
```
    int ci = m / wi;
```
と個数の上限の計算式を挿入して、<br>
```
  for (int i = 0; i < n; i++) {
    int vi, wi;
    cin >> vi >> wi;                    /* no limit for number of item */
    int ci = m / wi;                    /* upper limit of number of item */
    vector<int> tmp = decomp(ci);       /* decomposition */
    for (int x : tmp) {                 /* item of 2^? */
      v.push_back(v * x);
      w.push_back(w * x);
    }
  }

```
とすればいい。