Knapsack Problem in JavaScript: Dynamic Programming Approach for Optimal Solutions


The Knapsack Problem is a classic optimization problem that involves selecting items to maximize the total value while respecting a given weight constraint. It has various applications in fields such as resource allocation, portfolio optimization, and scheduling. In this article, we'll explore how to solve the Knapsack Problem using a dynamic programming approach in JavaScript.

Understanding the Knapsack Problem:

The Knapsack Problem can be described as follows: Given a set of items, each with its own value and weight, determine the most valuable combination of items that can be included in a knapsack without exceeding its weight capacity. The goal is to maximize the total value of the selected items.

Code Snippet: 

function knapsack(items, capacity) {

  const n = items.length;

  const dp = Array(n + 1).fill().map(() => Array(capacity + 1).fill(0));

  for (let i = 1; i <= n; i++) {

    const { value, weight } = items[i - 1];

    for (let j = 1; j <= capacity; j++) {

      if (weight <= j) {

        dp[i][j] = Math.max(dp[i - 1][j], value + dp[i - 1][j - weight]);

      } else {

        dp[i][j] = dp[i - 1][j];




  return dp[n][capacity];


// Usage example:

const items = [

  { value: 60, weight: 10 },

  { value: 100, weight: 20 },

  { value: 120, weight: 30 }


const capacity = 50;

const maxValue = knapsack(items, capacity);

console.log("Max value:", maxValue);


1. We start by defining the `knapsack` function that takes an array of items and the knapsack's capacity as input.

2. We create a 2D array `dp` to store the maximum values for different capacities and item subsets.

3. We iterate through each item and capacity combination and fill in the `dp` array using dynamic programming.

4. For each item, we check if its weight is less than or equal to the current capacity. If so, we consider two options: either include the item or exclude it.

5. We update the `dp` array based on the maximum value obtained from the two options.

6. Finally, we return the maximum value at `dp[n][capacity]`, where `n` is the total number of items.


The Knapsack Problem is a challenging optimization problem with various real-world applications. By implementing the dynamic programming solution in JavaScript, we can efficiently find the most valuable combination of items for a given weight constraint. Understanding and implementing this algorithm can greatly enhance your problem-solving skills as a JavaScript developer.

Note: The provided code snippet solves the 0/1 Knapsack Problem, where each item can be selected at most once.