 GFG App
Open App Browser
Continue

# Minimum cost to fill given weight in a bag

You are given a bag of size W kg and you are provided costs of packets different weights of oranges in array cost[] where cost[i] is basically the cost of ‘i’ kg packet of oranges. Where cost[i] = -1 means that ‘i’ kg packet of orange is unavailable
Find the minimum total cost to buy exactly W kg oranges and if it is not possible to buy exactly W kg oranges then print -1. It may be assumed that there is an infinite supply of all available packet types.
Note: array starts from index 1.

Examples:

```Input  : W = 5, cost[] = {20, 10, 4, 50, 100}
Output : 14
We can choose two oranges to minimize cost. First
orange of 2Kg and cost 10. Second orange of 3Kg
and cost 4.

Input  : W = 5, cost[] = {1, 10, 4, 50, 100}
Output : 5
We can choose five oranges of weight 1 kg.

Input  : W = 5, cost[] = {1, 2, 3, 4, 5}
Output : 5
Costs of 1, 2, 3, 4 and 5 kg packets are 1, 2, 3,
4 and 5 Rs respectively.
We choose packet of 5kg having cost 5 for minimum
cost to get 5Kg oranges.

Input  : W = 5, cost[] = {-1, -1, 4, 5, -1}
Output : -1
Packets of size 1, 2 and 5 kg are unavailable
because they have cost -1. Cost of 3 kg packet
is 4 Rs and of 4 kg is 5 Rs. Here we have only
weights 3 and 4 so by using these two we can
not make exactly W kg weight, therefore answer
is -1.```

Method 1:

This problem is can be reduced to Unbounded Knapsack. So in the cost array, we first ignore those packets which are not available i.e; cost is -1 and then traverse the cost array and create two array val[] for storing the cost of ‘i’ kg packet of orange and wt[] for storing weight of the corresponding packet. Suppose cost[i] = 50 so the weight of the packet will be i and the cost will be 50.
Algorithm :

• Create matrix min_cost[n+1][W+1], where n is number of distinct weighted packets of orange and W is the maximum capacity of the bag.
• Initialize the 0th row with INF (infinity) and 0th Column with 0.
• Now fill the matrix
• if wt[i-1] > j then min_cost[i][j] = min_cost[i-1][j] ;
• if wt[i-1] <= j then min_cost[i][j] = min(min_cost[i-1][j], val[i-1] + min_cost[i][j-wt[i-1]]);
• If min_cost[n][W]==INF then output will be -1 because this means that we cant not make weight W by using these weights else output will be min_cost[n][W].

Below is the implementation of the above algorithm:

## C++

 `// C++ program to find minimum cost to get exactly` `// W Kg with given packets` `#include` `#define INF 1000000` `using` `namespace` `std;`   `// cost[] initial cost array including unavailable packet` `// W capacity of bag` `int` `MinimumCost(``int` `cost[], ``int` `n, ``int` `W)` `{` `    ``// val[] and wt[] arrays` `    ``// val[] array to store cost of 'i' kg packet of orange` `    ``// wt[] array weight of packet of orange` `    ``vector<``int``> val, wt;`   `    ``// traverse the original cost[] array and skip` `    ``// unavailable packets and make val[] and wt[]` `    ``// array. size variable tells the available number` `    ``// of distinct weighted packets` `    ``int` `size = 0;` `    ``for` `(``int` `i=0; ij means capacity of bag is` `            ``// less than weight of item` `            ``if` `(wt[i-1] > j)` `                ``min_cost[i][j] = min_cost[i-1][j];`   `            ``// here we check we get minimum cost either` `            ``// by including it or excluding it` `            ``else` `                ``min_cost[i][j] = min(min_cost[i-1][j],` `                     ``min_cost[i][j-wt[i-1]] + val[i-1]);` `        ``}` `    ``}`   `    ``// exactly weight W can not be made by given weights` `    ``return` `(min_cost[n][W]==INF)? -1: min_cost[n][W];` `}`   `// Driver program to run the test case` `int` `main()` `{` `    ``int` `cost[] = {1, 2, 3, 4, 5}, W = 5;` `    ``int` `n = ``sizeof``(cost)/``sizeof``(cost);`   `    ``cout << MinimumCost(cost, n, W);` `    ``return` `0;` `}`

## Java

 `// Java Code for Minimum cost to` `// fill given weight in a bag` `import` `java.util.*;`   `class` `GFG {` `    `  `    ``// cost[] initial cost array including ` `    ``// unavailable packet W capacity of bag` `    ``public` `static` `int` `MinimumCost(``int` `cost[], ``int` `n, ` `                                             ``int` `W)` `    ``{` `        ``// val[] and wt[] arrays` `        ``// val[] array to store cost of 'i' kg ` `        ``// packet of orange wt[] array weight of ` `        ``// packet of orange` `        ``Vector val = ``new` `Vector();` `        ``Vector wt = ``new` `Vector();` `     `  `        ``// traverse the original cost[] array and skip` `        ``// unavailable packets and make val[] and wt[]` `        ``// array. size variable tells the available ` `        ``// number of distinct weighted packets` `        ``int` `size = ``0``;` `        ``for` `(``int` `i = ``0``; i < n; i++)` `        ``{` `            ``if` `(cost[i] != -``1``)` `            ``{` `                ``val.add(cost[i]);` `                ``wt.add(i + ``1``);` `                ``size++;` `            ``}` `        ``}` `     `  `        ``n = size;` `        ``int` `min_cost[][] = ``new` `int``[n+``1``][W+``1``];` `     `  `        ``// fill 0th row with infinity` `        ``for` `(``int` `i = ``0``; i <= W; i++)` `            ``min_cost[``0``][i] = Integer.MAX_VALUE;` `     `  `        ``// fill 0'th column with 0` `        ``for` `(``int` `i = ``1``; i <= n; i++)` `            ``min_cost[i][``0``] = ``0``;` `     `  `        ``// now check for each weight one by one and` `        ``// fill the matrix according to the condition` `        ``for` `(``int` `i = ``1``; i <= n; i++)` `        ``{` `            ``for` `(``int` `j = ``1``; j <= W; j++)` `            ``{` `                ``// wt[i-1]>j means capacity of bag is` `                ``// less than weight of item` `                ``if` `(wt.get(i-``1``) > j)` `                    ``min_cost[i][j] = min_cost[i-``1``][j];` `     `  `                ``// here we check we get minimum cost ` `                ``// either by including it or excluding` `                ``// it` `                ``else` `                    ``min_cost[i][j] = Math.min(min_cost[i-``1``][j],` `                                  ``min_cost[i][j-wt.get(i-``1``)] + ` `                                              ``val.get(i-``1``));` `            ``}` `        ``}` `     `  `        ``// exactly weight W can not be made by ` `        ``// given weights` `        ``return` `(min_cost[n][W] == Integer.MAX_VALUE)? -``1``: ` `                                        ``min_cost[n][W];` `    ``}` `    `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `         ``int` `cost[] = {``1``, ``2``, ``3``, ``4``, ``5``}, W = ``5``;` `            ``int` `n = cost.length;` `         `  `        ``System.out.println(MinimumCost(cost, n, W));` `    ``}` `}` `// This code is contributed by Arnav Kr. Mandal.`

## Python3

 `# Python program to find minimum cost to get exactly` `# W Kg with given packets`   `INF ``=` `1000000`   `# cost[] initial cost array including unavailable packet` `# W capacity of bag` `def` `MinimumCost(cost, n, W):`   `    ``# val[] and wt[] arrays` `    ``# val[] array to store cost of 'i' kg packet of orange ` `    ``# wt[] array weight of packet of orange` `    ``val ``=` `list``()` `    ``wt``=` `list``()`   `    ``# traverse the original cost[] array and skip` `    ``# unavailable packets and make val[] and wt[]` `    ``# array. size variable tells the available number` `    ``# of distinct weighted packets.` `    ``size ``=` `0` `    ``for` `i ``in` `range``(n):` `        ``if` `(cost[i] !``=` `-``1``):` `            ``val.append(cost[i])` `            ``wt.append(i``+``1``)` `            ``size ``+``=` `1`   `    ``n ``=` `size` `    ``min_cost ``=` `[[``0` `for` `i ``in` `range``(W``+``1``)] ``for` `j ``in` `range``(n``+``1``)]`   `    ``# fill 0th row with infinity` `    ``for` `i ``in` `range``(W``+``1``):` `        ``min_cost[``0``][i] ``=` `INF`   `    ``# fill 0th column with 0` `    ``for` `i ``in` `range``(``1``, n``+``1``):` `        ``min_cost[i][``0``] ``=` `0`   `    ``# now check for each weight one by one and fill the` `    ``# matrix according to the condition` `    ``for` `i ``in` `range``(``1``, n``+``1``):` `        ``for` `j ``in` `range``(``1``, W``+``1``):` `            ``# wt[i-1]>j means capacity of bag is` `            ``# less than weight of item` `            ``if` `(wt[i``-``1``] > j):` `                ``min_cost[i][j] ``=` `min_cost[i``-``1``][j]`   `            ``# here we check we get minimum cost either` `            ``# by including it or excluding it` `            ``else``:` `                ``min_cost[i][j] ``=` `min``(min_cost[i``-``1``][j],` `                    ``min_cost[i][j``-``wt[i``-``1``]] ``+` `val[i``-``1``])`   `    ``# exactly weight W can not be made by given weights` `    ``if``(min_cost[n][W] ``=``=` `INF):` `        ``return` `-``1` `    ``else``:` `        ``return` `min_cost[n][W]`   `# Driver program to run the test case` `cost ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]` `W ``=` `5` `n ``=` `len``(cost)`   `print``(MinimumCost(cost, n, W))`   `# This code is contributed by Soumen Ghosh.`

## C#

 `// C# Code for Minimum cost to ` `// fill given weight in a bag `   `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG { ` `    `  `    ``// cost[] initial cost array including ` `    ``// unavailable packet W capacity of bag ` `    ``public` `static` `int` `MinimumCost(``int` `[]cost, ``int` `n, ` `                                            ``int` `W) ` `    ``{ ` `        ``// val[] and wt[] arrays ` `        ``// val[] array to store cost of 'i' kg ` `        ``// packet of orange wt[] array weight of ` `        ``// packet of orange ` `        ``List<``int``> val = ``new` `List<``int``>(); ` `        ``List<``int``> wt = ``new` `List<``int``>(); ` `    `  `        ``// traverse the original cost[] array and skip ` `        ``// unavailable packets and make val[] and wt[] ` `        ``// array. size variable tells the available ` `        ``// number of distinct weighted packets ` `        ``int` `size = 0; ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``if` `(cost[i] != -1) ` `            ``{ ` `                ``val.Add(cost[i]); ` `                ``wt.Add(i + 1); ` `                ``size++; ` `            ``} ` `        ``} ` `    `  `        ``n = size; ` `        ``int` `[,]min_cost = ``new` `int``[n+1,W+1]; ` `    `  `        ``// fill 0th row with infinity ` `        ``for` `(``int` `i = 0; i <= W; i++) ` `            ``min_cost[0,i] = ``int``.MaxValue; ` `    `  `        ``// fill 0'th column with 0 ` `        ``for` `(``int` `i = 1; i <= n; i++) ` `            ``min_cost[i,0] = 0; ` `    `  `        ``// now check for each weight one by one and ` `        ``// fill the matrix according to the condition ` `        ``for` `(``int` `i = 1; i <= n; i++) ` `        ``{ ` `            ``for` `(``int` `j = 1; j <= W; j++) ` `            ``{ ` `                ``// wt[i-1]>j means capacity of bag is ` `                ``// less than weight of item ` `                ``if` `(wt[i-1] > j) ` `                    ``min_cost[i,j] = min_cost[i-1,j]; ` `    `  `                ``// here we check we get minimum cost ` `                ``// either by including it or excluding ` `                ``// it ` `                ``else` `                    ``min_cost[i,j] = Math.Min(min_cost[i-1,j], ` `                                ``min_cost[i,j-wt[i-1]] + val[i-1]); ` `            ``} ` `        ``} ` `    `  `        ``// exactly weight W can not be made by ` `        ``// given weights ` `        ``return` `(min_cost[n,W] == ``int``.MaxValue )? -1: min_cost[n,W]; ` `    ``} ` `    `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `Main()` `    ``{ ` `            ``int` `[]cost = {1, 2, 3, 4, 5};` `            ``int` `W = 5; ` `            ``int` `n = cost.Length; ` `        `  `            ``Console.WriteLine(MinimumCost(cost, n, W)); ` `    ``} ` `} ` `// This code is contributed by Ryuga `

## PHP

 `j means capacity of bag ` `            ``// is less than weight of item` `            ``if` `(``\$wt``[``\$i` `- 1] > ``\$j``)` `                ``\$min_cost``[``\$i``][``\$j``] = ``\$min_cost``[``\$i` `- 1][``\$j``];`   `            ``// here we check we get minimum ` `            ``// cost either by including it ` `            ``// or excluding it` `            ``else` `                ``\$min_cost``[``\$i``][``\$j``] = min(``\$min_cost``[``\$i` `- 1][``\$j``],` `                                        ``\$min_cost``[``\$i``][``\$j` `- ``\$wt``[``\$i` `- 1]] + ` `                                                           ``\$val``[``\$i` `- 1]);` `        ``}` `    ``}`   `    ``// exactly weight W can not be made ` `    ``// by given weights` `    ``if` `(``\$min_cost``[``\$n``][``\$W``] == ``\$INF``)` `            ``return` `-1;` `    ``else` `        ``return` `\$min_cost``[``\$n``][``\$W``];` `}`   `// Driver Code` `\$cost` `= ``array``(1, 2, 3, 4, 5);` `\$W` `= 5;` `\$n` `= sizeof(``\$cost``);` `echo` `MinimumCost(``\$cost``, ``\$n``, ``\$W``);`   `// This code is contributed by ita_c` `?>`

## Javascript

 ``

Output

`5`

Time Complexity: O(N*W)
Auxiliary Space: O(N*W)

Space Optimized Solution If we take a closer look at this problem, we may notice that this is a variation of Rod Cutting Problem. Instead of doing maximization, here we need to do minimization.

## C++

 `// C++ program to find minimum cost to ` `// get exactly W Kg with given packets` `#include` `using` `namespace` `std;`   `/* Returns the best obtainable price for` `   ``a rod of length n and price[] as prices ` `   ``of different pieces */` `int` `minCost(``int` `cost[], ``int` `n) ` `{ ` `   ``int` `dp[n+1]; ` `   ``dp = 0; ` `  `  `   ``// Build the table val[] in bottom up ` `   ``// manner and return the last entry ` `   ``// from the table ` `   ``for` `(``int` `i = 1; i<=n; i++) ` `   ``{ ` `       ``int` `min_cost = INT_MAX; ` `       ``for` `(``int` `j = 0; j < i; j++) ` `         ``if``(cost[j]!=-1)` `             ``min_cost = min(min_cost, cost[j] + dp[i-j-1]); ` `       ``dp[i] = min_cost; ` `   ``} ` `  `  `   ``return` `dp[n]; ` `} `   `/* Driver code */` `int` `main() ` `{ ` `   ``int` `cost[] = {20, 10, 4, 50, 100};` `   ``int` `W = ``sizeof``(cost)/``sizeof``(cost); ` `   ``cout << minCost(cost, W); ` `   ``return` `0; ` `} `

## Java

 `// Java program to find minimum cost to ` `// get exactly W Kg with given packets` `import` `java.util.*;` `class` `Main` `{` `  `  `    ``/* Returns the best obtainable price for` `    ``a rod of length n and price[] as prices ` `    ``of different pieces */` `    ``public` `static` `int` `minCost(``int` `cost[], ``int` `n) ` `    ``{ ` `       ``int` `dp[] = ``new` `int``[n + ``1``]; ` `       ``dp[``0``] = ``0``; ` `       `  `       ``// Build the table val[] in bottom up ` `       ``// manner and return the last entry ` `       ``// from the table ` `       ``for` `(``int` `i = ``1``; i <= n; i++) ` `       ``{ ` `           ``int` `min_cost = Integer.MAX_VALUE; ` `           ``for` `(``int` `j = ``0``; j < i; j++) ` `               ``if``(cost[j]!=-``1``) {` `                 ``min_cost = Math.min(min_cost, cost[j] + dp[i - j - ``1``]); ` `            ``}` `            ``dp[i] = min_cost; ` `       ``} ` `       `  `       ``return` `dp[n]; ` `    ``} `   `    ``public` `static` `void` `main(String[] args) {` `       ``int` `cost[] = {``10``,-``1``,-``1``,-``1``,-``1``};` `       ``int` `W = cost.length; ` `       ``System.out.print(minCost(cost, W)); ` `    ``}` `}`   `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program to find minimum cost to ` `# get exactly W Kg with given packets` `import` `sys`   `# Returns the best obtainable price for` `# a rod of length n and price[] as prices ` `# of different pieces ` `def` `minCost(cost, n):` `    `  `    ``dp ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]`   `    ``# Build the table val[] in bottom up ` `       ``# manner and return the last entry ` `       ``# from the table ` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):` `        ``min_cost ``=` `sys.maxsize`   `        ``for` `j ``in` `range``(i):` `            ``if` `cost[j]!``=``-``1``:` `                ``min_cost ``=` `min``(min_cost,` `                           ``cost[j] ``+` `dp[i ``-` `j ``-` `1``])` `            `  `        ``dp[i] ``=` `min_cost` `        `  `    ``return` `dp[n]`   `# Driver code` `cost ``=` `[ ``10``,``-``1``,``-``1``,``-``1``,``-``1` `]` `W ``=` `len``(cost)`   `print``(minCost(cost, W))`   `# This code is contributed by rag2127`

## C#

 `// C# program to find minimum cost to ` `// get exactly W Kg with given packets` `using` `System;` `class` `GFG {` `    `  `    ``/* Returns the best obtainable price for` `    ``a rod of length n and price[] as prices ` `    ``of different pieces */` `    ``static` `int` `minCost(``int``[] cost, ``int` `n) ` `    ``{ ` `       ``int``[] dp = ``new` `int``[n + 1]; ` `       ``dp = 0; ` `        `  `       ``// Build the table val[] in bottom up ` `       ``// manner and return the last entry ` `       ``// from the table ` `       ``for` `(``int` `i = 1; i <= n; i++) ` `       ``{ ` `           ``int` `min_cost = Int32.MaxValue; ` `           ``for` `(``int` `j = 0; j < i; j++) ` `             ``if``(cost[j]!=-1)` `                 ``min_cost = Math.Min(min_cost, ` `                                    ``cost[j] + dp[i - j - 1]); ` `           ``dp[i] = min_cost; ` `       ``} ` `        `  `       ``return` `dp[n]; ` `    ``} ` `   `  `  ``// Driver code` `  ``static` `void` `Main() {` `   ``int``[] cost = {20, 10, 4, 50, 100};` `   ``int` `W = cost.Length; ` `   ``Console.Write(minCost(cost, W)); ` `  ``}` `}`   `// This code is contributed by divyesh072019`

## Javascript

 ``

Output

`14`

Time Complexity: O(N2)
Auxiliary Space: O(N)

Top Down Approach: We can also solve the problem using memoization.

## C++

 `// C++ program to find minimum cost to` `// get exactly W Kg with given packets` `#include ` `using` `namespace` `std;`   `int` `helper(vector<``int``>& cost, vector<``int``>& weight, ``int` `n,` `           ``int` `w, vector >& dp)` `{` `    ``// base cases` `    ``if` `(w == 0)` `        ``return` `0;` `    ``if` `(w < 0 or n <= 0)` `        ``return` `INT_MAX;`   `    ``if` `(dp[n][w] != -1)` `        ``return` `dp[n][w];`   `    ``if` `(cost[n - 1] < 0)` `        ``return` `dp[n][w]` `               ``= min(INT_MAX,` `                     ``helper(cost, weight, n - 1, w, dp));`   `    ``if` `(weight[n - 1] <= w) {` `        ``return` `dp[n][w]` `               ``= min(cost[n - 1]` `                         ``+ helper(cost, weight, n,` `                                  ``w - weight[n - 1], dp),` `                     ``helper(cost, weight, n - 1, w, dp));` `    ``}` `    ``return` `dp[n][w] = helper(cost, weight, n - 1, w, dp);` `}` `int` `minCost(vector<``int``>& cost, ``int` `W)` `{` `    ``int` `N = cost.size();` `    ``// Your code goes here` `    ``vector<``int``> weight(N);`   `    ``// create the weight array` `    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``weight[i - 1] = i;` `    ``}`   `    ``// initialize the dp array` `    ``vector > dp(N + 1, vector<``int``>(W + 1, -1));`   `    ``int` `res = helper(cost, weight, N, W, dp);`   `    ``// return -1 if result is MAX` `    ``return` `(res == INT_MAX) ? -1 : res;` `}`   `/* Driver code */` `int` `main()` `{` `    ``vector<``int``> cost = { 20, 10, 4, 50, 100 };` `    ``int` `W = cost.size();` `    ``cout << minCost(cost, W);` `    ``return` `0;` `}`

## Java

 `// Java program to find minimum cost to` `// get exactly W Kg with given packets` `import` `java.io.*;`   `class` `GFG {`   `    ``public` `static` `int` `helper(``int` `cost[], ``int` `weight[],` `                             ``int` `n, ``int` `w, ``int` `dp[][])` `    ``{` `        ``// base cases` `        ``if` `(w == ``0``)` `            ``return` `0``;` `        ``if` `(w < ``0` `|| n <= ``0``)` `            ``return` `Integer.MAX_VALUE;`   `        ``if` `(dp[n][w] != -``1``)` `            ``return` `dp[n][w];`   `        ``if` `(cost[n - ``1``] < ``0``)` `            ``return` `dp[n][w] = Math.min(` `                       ``Integer.MAX_VALUE,` `                       ``helper(cost, weight, n - ``1``, w, dp));`   `        ``if` `(weight[n - ``1``] <= w) {` `            ``return` `dp[n][w] = Math.min(` `                       ``cost[n - ``1``]` `                           ``+ helper(cost, weight, n,` `                                    ``w - weight[n - ``1``], dp),` `                       ``helper(cost, weight, n - ``1``, w, dp));` `        ``}` `        ``return` `dp[n][w]` `            ``= helper(cost, weight, n - ``1``, w, dp);` `    ``}` `    ``public` `static` `int` `minCost(``int` `cost[], ``int` `W)` `    ``{` `        ``int` `N = cost.length;` `        ``int` `weight[] = ``new` `int``[N];`   `        ``// create the weight array` `        ``for` `(``int` `i = ``1``; i <= N; i++) {` `            ``weight[i - ``1``] = i;` `        ``}`   `        ``// initialize the dp array` `        ``int` `dp[][] = ``new` `int``[N + ``1``][W + ``1``];` `        ``for` `(``int` `i = ``0``; i < N + ``1``; i++)` `            ``for` `(``int` `j = ``0``; j < W + ``1``; j++)` `                ``dp[i][j] = -``1``;`   `        ``int` `res = helper(cost, weight, N, W, dp);`   `        ``// return -1 if result is MAX` `        ``return` `(res == Integer.MAX_VALUE) ? -``1` `: res;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `cost[] = { ``20``, ``10``, ``4``, ``50``, ``100` `};` `        ``int` `W = cost.length;` `        ``System.out.print(minCost(cost, W));` `    ``}` `}`   `// This code is contributed by Rohit Pradhan`

## Python3

 `# Python3 program to find minimum cost to` `# get exactly W Kg with given packets` `import` `sys`   `def` `helper(cost, weight, n, w, dp):`   `    ``# base cases` `    ``if` `(w ``=``=` `0``):` `        ``return` `0` `    ``if` `(w < ``0` `or` `n <``=` `0``):` `        ``return` `sys.maxsize`   `    ``if` `(dp[n][w] !``=` `-``1``):` `        ``return` `dp[n][w]`   `    ``if` `(cost[n ``-` `1``] < ``0``):` `        ``dp[n][w] ``=` `min``(sys.maxsize, helper(cost, weight, n ``-` `1``, w, dp))` `        ``return` `dp[n][w]`   `    ``if` `(weight[n ``-` `1``] <``=` `w):` `        ``dp[n][w] ``=` `min``(cost[n ``-` `1``] ``+` `helper(cost, weight, n, w ``-` `weight[n ``-` `1``], dp), helper(cost, weight, n ``-` `1``, w, dp))` `        ``return` `dp[n][w]`   `    `  `    ``dp[n][w] ``=` `helper(cost, weight, n ``-` `1``, w, dp)` `    ``return` `dp[n][w]`   `def` `minCost(cost, W):`   `    ``N ``=` `len``(cost)` `    `  `    ``weight ``=` `[``0` `for` `i ``in` `range``(N)]`   `    ``# create the weight array` `    ``for` `i ``in` `range``(``1``,N ``+` `1``):` `        ``weight[i ``-` `1``] ``=` `i`   `    ``# initialize the dp array` `    ``dp ``=` `[[``-``1` `for` `i ``in` `range``(W ``+` `1``)]``for` `j ``in` `range``(N ``+` `1``)]`   `    ``res ``=` `helper(cost, weight, N, W, dp)`   `    ``# return -1 if result is MAX` `    ``return` `-``1` `if``(res ``=``=` `sys.maxsize) ``else` `res`   `# Driver code ` `cost ``=` `[ ``20``, ``10``, ``4``, ``50``, ``100` `]` `W ``=` `len``(cost)` `print``(minCost(cost, W))`   `# This code is contributed by shinjanpatra`

## C#

 `// C# program to find minimum cost to` `// get exactly W Kg with given packets` `using` `System;`   `class` `GFG ` `{` `  ``static` `int` `helper(``int``[] cost, ``int``[] weight, ` `                    ``int` `n, ``int` `w, ``int``[,] dp)` `  ``{` `    ``// base cases` `    ``if` `(w == 0)` `      ``return` `0;` `    ``if` `(w < 0 || n <= 0)` `      ``return` `Int32.MaxValue;`   `    ``if` `(dp[n,w] != -1)` `      ``return` `dp[n,w];`   `    ``if` `(cost[n - 1] < 0)` `      ``return` `dp[n,w] = Math.Min(` `      ``Int32.MaxValue,` `      ``helper(cost, weight, n - 1, w, dp));`   `    ``if` `(weight[n - 1] <= w) ` `    ``{` `      ``return` `dp[n,w] = Math.Min(` `        ``cost[n - 1]` `        ``+ helper(cost, weight, n,` `                 ``w - weight[n - 1], dp),` `        ``helper(cost, weight, n - 1, w, dp));` `    ``}` `    ``return` `dp[n,w]` `      ``= helper(cost, weight, n - 1, w, dp);` `  ``}`   `  ``static` `int` `minCost(``int``[] cost, ``int` `W)` `  ``{` `    ``int` `N = cost.Length;` `    ``int``[] weight = ``new` `int``[N];`   `    ``// create the weight array` `    ``for` `(``int` `i = 1; i <= N; i++) ` `    ``{` `      ``weight[i - 1] = i;` `    ``}`   `    ``// initialize the dp array` `    ``int``[,] dp = ``new` `int``[N + 1, W + 1];` `    ``for` `(``int` `i = 0; i < N + 1; i++)` `      ``for` `(``int` `j = 0; j < W + 1; j++)` `        ``dp[i,j] = -1;`   `    ``int` `res = helper(cost, weight, N, W, dp);`   `    ``// return -1 if result is MAX` `    ``return` `(res == Int32.MaxValue) ? -1 : res;` `  ``}`   `  ``// Driver Code` `  ``static` `public` `void` `Main()` `  ``{` `    ``int``[] cost = { 20, 10, 4, 50, 100 };` `    ``int` `W = cost.Length;` `    ``Console.Write(minCost(cost, W));` `  ``}` `}`   `// This code is contributed by kothavvsaakash`

## Javascript

 ``

Output

`14`

Time Complexity: O(N*W)
Auxiliary Space: O(N*W)