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

```

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

## Python 3

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

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.

## CPP

 `// 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++) ` `         ``min_cost = min(min_cost, cost[j] + dp[i-j-1]); ` `       ``dp[i] = min_cost; ` `   ``} ` `  `  `   ``return` `dp[n]; ` `} `   `/* Driver program to test above functions */` `int` `main() ` `{ ` `   ``int` `cost[] = {20, 10, 4, 50, 100};` `   ``int` `W = ``sizeof``(cost)/``sizeof``(cost); ` `   ``cout << minCost(cost, W); ` `   ``return` `0; ` `} `

Output:

```14

```