Algorithms: Dynamic Programming

    static int unbounded_knapsack(int[] weights, int[] values, int capacity) {
        java.util.Objects.requireNonNull(weights, "weights");
        java.util.Objects.requireNonNull(values, "values");
        int n = weights.length;
        alg_require(((n >= 0) && (n <= 1000000)));
        alg_require((weights.length == n));
        alg_require((values.length == n));
        alg_require(((capacity >= 0) && (capacity <= 1000000)));
        for (int alg_i = 0; alg_i < weights.length; alg_i++) {
            int alg_value = weights[alg_i];
            alg_require((alg_value > 0));
        }

function unbounded_knapsack(weights, values, capacity) {
    alg_require(weights instanceof Int32Array);
    alg_require(values instanceof Int32Array);
    alg_require(Number.isInteger(capacity) && capacity >= -2147483648 && capacity <= 2147483647);
    let n = weights.length;
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require((weights.length == n));
    alg_require((values.length == n));
    alg_require(((capacity >= 0) && (capacity <= 1000000)));
    for (let alg_i = 0; alg_i < weights.length; alg_i++) {
        let alg_value = weights[alg_i];
        alg_require((alg_value > 0));

def unbounded_knapsack(weights: list[int], values: list[int], capacity: int) -> int:
    alg_require(isinstance(weights, (list, tuple)) and len(weights) <= 1000000)
    alg_require(isinstance(values, (list, tuple)) and len(values) <= 1000000)
    alg_require(type(capacity) is int and -2147483648 <= capacity <= 2147483647)
    n: int = len(weights)
    alg_require(n >= 0 and n <= 1000000)
    alg_require(len(weights) == n)
    alg_require(len(values) == n)
    alg_require(capacity >= 0 and capacity <= 1000000)
    for value in weights:
        alg_require(value > 0)
    for value in values:

int unbounded_knapsack(const int *weights, size_t weights_length, const int *values, size_t values_length, int capacity) {
    int alg_error = 0;
    int alg_result = INT_MIN;
    errno = 0;
    int *dp = NULL;
    if (weights_length > 1000000 || (weights_length && !weights)) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (values_length > 1000000 || (values_length && !values)) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    int n = (int)weights_length;
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    if (!(((n >= 0) && (n <= 1000000)))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    if (!(((int)weights_length == n))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }

int unbounded_knapsack(const std::vector<int>& weights, const std::vector<int>& values, int capacity) {
    alg_require(weights.size() <= 1000000);
    alg_require(values.size() <= 1000000);
    int n = (int)weights.size();
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require(((int)weights.size() == n));
    alg_require(((int)values.size() == n));
    alg_require(((capacity >= 0) && (capacity <= 1000000)));
    for (int alg_i = 0; alg_i < (int)weights.size(); alg_i++) {
        int alg_value = weights[alg_i];
        alg_require((alg_value > 0));
    }