Knapsack Problem - Problem

You are given a knapsack with a maximum weight capacity and a collection of items, each with a specific weight and value. Your goal is to determine the maximum value you can achieve by selecting items to put in the knapsack without exceeding the weight capacity.

This is the classic 0/1 Knapsack Problem where each item can either be included (1) or excluded (0) - you cannot take partial items or multiple copies of the same item.

Input:

weights: An array of positive integers representing the weight of each item
values: An array of positive integers representing the value of each item
capacity: A positive integer representing the maximum weight capacity of the knapsack

Output:

Return the maximum value that can be obtained.

Input & Output

Example 1 — Basic Case

$ Input: weights = [2,1,3], values = [60,40,120], capacity = 5

› Output: 160

💡 Note: Select items 1 and 2: weight = 1+3 = 4 ≤ 5, value = 40+120 = 160. This is optimal.

Example 2 — Single Item

$ Input: weights = [10], values = [60], capacity = 15

› Output: 60

💡 Note: Only one item available and it fits in the knapsack, so take it for value 60.

Example 3 — No Items Fit

$ Input: weights = [5,4,6], values = [10,40,30], capacity = 3

› Output: 0

💡 Note: All items are too heavy for the capacity of 3, so maximum value is 0.

Constraints

1 ≤ weights.length ≤ 100
weights.length == values.length
1 ≤ weights[i], values[i] ≤ 1000
1 ≤ capacity ≤ 1000

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 F Facebook 28

The key insight is to recognize this as a classic dynamic programming problem where each item can be either included or excluded. The optimal approach uses a 2D DP table where dp[i][w] represents the maximum value achievable using the first i items with weight capacity w. Time: O(n×W), Space: O(n×W).

Common Approaches

✓ 2D Dynamic Programming - Bottom-Up

⏱️ Time: O(n × W) Space: O(n × W)

Create a 2D table dp[i][w] where dp[i][w] represents the maximum value achievable using first i items with weight capacity w. Fill the table bottom-up using the recurrence relation.

Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ) Space: O(n)

For each item, we have two choices: include it or exclude it. We recursively try both choices for all items and return the maximum value achievable within the weight capacity.

Memoization - Top-Down DP

⏱️ Time: O(n × W) Space: O(n × W)

Same recursive approach as brute force, but we store results of subproblems in a cache. When we encounter the same state (item index, remaining capacity) again, we return the cached result instead of recalculating.

2D Dynamic Programming - Bottom-Up — Algorithm Steps

Initialize 2D DP table with zeros
For each item and weight capacity
Choose max of including or excluding current item
Return dp[n][capacity] as final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Create (n+1) × (W+1) table with zeros

Fill Iteratively

For each cell: max(exclude, include)

Final Answer

Bottom-right cell contains optimal value

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int* weights, int* values, int n, int capacity) {
    // Create DP table: dp[i][w] = max value using first i items with capacity w
    int** dp = (int**)malloc((n + 1) * sizeof(int*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (int*)calloc(capacity + 1, sizeof(int));
    }
    
    // Fill the DP table
    for (int i = 1; i <= n; i++) {
        for (int w = 0; w <= capacity; w++) {
            // Option 1: Don't include current item
            dp[i][w] = dp[i-1][w];
            
            // Option 2: Include current item (if it fits)
            if (weights[i-1] <= w) {
                int includeValue = values[i-1] + dp[i-1][w - weights[i-1]];
                if (includeValue > dp[i][w]) {
                    dp[i][w] = includeValue;
                }
            }
        }
    }
    
    int result = dp[n][capacity];
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char line[1000];
    
    // Read weights array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int weights[100], n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        weights[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    // Read values array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int values[100];
    token = strtok(line + 1, ",]");
    for (int i = 0; i < n; i++) {
        values[i] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    // Read capacity
    int capacity;
    scanf("%d", &capacity);
    
    int result = solution(weights, values, n, capacity);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × W)

Nested loops: n items × W weight values, each cell computed once

✓ Linear Growth

Space Complexity

O(n × W)

2D DP table with n+1 rows and W+1 columns

⚡ Linearithmic Space

78.0K Views

High Frequency

~25 min Avg. Time

2.1K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Knapsack Problem - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

2D Dynamic Programming - Bottom-Up — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler