The 0-1 Knapsack problem is a popular combinatorial optimization problem:

Given a set of n items, each having a value \( p_i \) and a weight of \( w_i \), find a subset of these items such that the total value is maximized, while keeping the total weight of the items under a given constant weight capacity W.

Formally, we need to maximize \( \sum_{i=1}^{n}{p_{i}f_{i}} \), while subjecting to \( \sum_{i=1}^{n}{w_{i}f_{i}} \le W \), \( f_i \in \{0, 1\}, \forall i \in \{ 1, …, n\} \).

This problem has a nice Dynamic Programming solution, which runs in \( O(n) \) time (pseudopolynomial). It is a computationally hard problem, as it is NP-Complete, but it has many important applications.

It has many known variations, one of which is the Multiple Choice Knapsack Problem. In this case, the items are subdivided into \( k \) classes, each having \( N_i \) items, and exactly one item must be taken from each class. Formally, we need to maximize \( \sum_{i=1}^{k}\sum_{j \in N_i}{p_{ij}x_{ij}} \), while subjecting to \( \sum_{i=1}^{k}\sum_{j \in N_i}{w_{ij}x_{ij}} \le W\), with \( \sum_{j \in N_i}{x_{ij}} = 1, \forall i \in \{1, …, k\}\) and \( x_{ij} \in \{0, 1\}, \forall i \in \{1, …, k\} \) and \( \forall j \in N_i \).

To solve this problem, we will use a Dynamic Programming approach. The recursive equation that describes the relation between the overlapping subproblems is the following:

\[ Value[i, j] = \max_{1 \le u \le N_i, w_{iu} \le j}\{ Value[i-1, j-w_{iu}] + p_{iu} \} \]

Below is an implementation in C++:

```
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int max_value(const vector<vector<int>>& weight,
const vector<vector<int>>& value,
int max_weight) {
if (weight.empty())
return 0;
vector<int> last(max_weight + 1, -1);
for (int i = 0; i < weight[0].size(); ++i) {
if (weight[0][i] < max_weight)
last[weight[0][i]] = max(last[weight[0][i]], value[0][i]);
}
vector<int> current(max_weight + 1);
for (int i = 1; i < weight.size(); ++i) {
fill(current.begin(), current.end(), -1);
for (int j = 0; j < weight[i].size(); ++j) {
for (int k = weight[i][j]; k <= max_weight; ++k) {
if (last[k - weight[i][j]] > 0)
current[k] = max(current[k],
last[k - weight[i][j]] + value[i][j]);
}
}
swap(current, last);
}
return *max_element(last.begin(), last.end());
}
// driver code
int main(int argc, char const* argv[]) {
vector<int> values_class_1;
values_class_1.push_back(2);
values_class_1.push_back(3);
vector<int> weights_class_1;
weights_class_1.push_back(3);
weights_class_1.push_back(4);
vector<int> values_class_2;
values_class_2.push_back(1);
values_class_2.push_back(2);
vector<int> weights_class_2;
weights_class_2.push_back(2);
weights_class_2.push_back(3);
vector<vector<int>> values;
values.push_back(values_class_1);
values.push_back(values_class_2);
vector<vector<int>> weights;
weights.push_back(weights_class_1);
weights.push_back(weights_class_2);
int max_weight = 7;
cout << max_value(weights, values, max_weight) << endl;
return 0;
}
```

The time complexity of this solution is \(O(C\sum_{i=1}^{k}{N_i})\).