Related Articles
Minimum cost to fill given weight in a bag
• Difficulty Level : Medium
• Last Updated : 12 Apr, 2021

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.```

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 make weight W by using these weights else output will be min_cost[n][W].

## 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 then 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 then 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 then 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 then 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`

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``(j < n)``             ``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``(j < cost.length) {``                 ``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[] = {``20``, ``10``, ``4``, ``50``, ``100``};``       ``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` `j<``len``(cost):``                ``min_cost ``=` `min``(min_cost,``                           ``cost[j] ``+` `dp[i ``-` `j ``-` `1``])``            ` `        ``dp[i] ``=` `min_cost``        ` `    ``return` `dp[n]` `# Driver code``cost ``=` `[ ``20``, ``10``, ``4``, ``50``, ``100` `]``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``(j < n)``                 ``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`