# Fractional Knapsack Problem

Given weights and values of n items, we need to put these items in a knapsack of capacity W to get the maximum total value in the knapsack.

In the 0-1 Knapsack problem, we are not allowed to break items. We either take the whole item or don’t take it.

Input: Items as (value, weight) pairs arr[] = {{60, 10}, {100, 20}, {120, 30}} Knapsack Capacity, W = 50; Output: Maximum possible value = 220 by taking items of weight 20 and 30 kg

In **Fractional Knapsack**, we can break items for maximizing the total value of knapsack. This problem in which we can break an item is also called the fractional knapsack problem.

Input : Same as above Output : Maximum possible value = 240 By taking full items of 10 kg, 20 kg and 2/3rd of last item of 30 kg

A **brute-force solution** would be to try all possible subset with all different fraction but that will be too much time taking.

An **efficient solution** is to use Greedy approach. The basic idea of the greedy approach is to calculate the ratio value/weight for each item and sort the item on basis of this ratio. Then take the item with the highest ratio and add them until we can’t add the next item as a whole and at the end add the next item as much as we can. Which will always be the optimal solution to this problem.

A simple code with our own comparison function can be written as follows, please see sort function more closely, the third argument to sort function is our comparison function which sorts the item according to value/weight ratio in non-decreasing order.

After sorting we need to loop over these items and add them in our knapsack satisfying above-mentioned criteria.

## C++

`// C/C++ program to solve fractional Knapsack Problem ` `#include <bits/stdc++.h> ` ` ` `using` `namespace` `std; ` ` ` `// Structure for an item which stores weight and corresponding ` `// value of Item ` `struct` `Item ` `{ ` ` ` `int` `value, weight; ` ` ` ` ` `// Constructor ` ` ` `Item(` `int` `value, ` `int` `weight) : value(value), weight(weight) ` ` ` `{} ` `}; ` ` ` `// Comparison function to sort Item according to val/weight ratio ` `bool` `cmp(` `struct` `Item a, ` `struct` `Item b) ` `{ ` ` ` `double` `r1 = (` `double` `)a.value / a.weight; ` ` ` `double` `r2 = (` `double` `)b.value / b.weight; ` ` ` `return` `r1 > r2; ` `} ` ` ` `// Main greedy function to solve problem ` `double` `fractionalKnapsack(` `int` `W, ` `struct` `Item arr[], ` `int` `n) ` `{ ` ` ` `// sorting Item on basis of ratio ` ` ` `sort(arr, arr + n, cmp); ` ` ` ` ` `// Uncomment to see new order of Items with their ratio ` ` ` `/* ` ` ` `for (int i = 0; i < n; i++) ` ` ` `{ ` ` ` `cout << arr[i].value << " " << arr[i].weight << " : " ` ` ` `<< ((double)arr[i].value / arr[i].weight) << endl; ` ` ` `} ` ` ` `*/` ` ` ` ` `int` `curWeight = 0; ` `// Current weight in knapsack ` ` ` `double` `finalvalue = 0.0; ` `// Result (value in Knapsack) ` ` ` ` ` `// Looping through all Items ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `{ ` ` ` `// If adding Item won't overflow, add it completely ` ` ` `if` `(curWeight + arr[i].weight <= W) ` ` ` `{ ` ` ` `curWeight += arr[i].weight; ` ` ` `finalvalue += arr[i].value; ` ` ` `} ` ` ` ` ` `// If we can't add current Item, add fractional part of it ` ` ` `else` ` ` `{ ` ` ` `int` `remain = W - curWeight; ` ` ` `finalvalue += arr[i].value * ((` `double` `) remain / arr[i].weight); ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Returning final value ` ` ` `return` `finalvalue; ` `} ` ` ` `// driver program to test above function ` `int` `main() ` `{ ` ` ` `int` `W = 50; ` `// Weight of knapsack ` ` ` `Item arr[] = {{60, 10}, {100, 20}, {120, 30}}; ` ` ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` ` ` `cout << ` `"Maximum value we can obtain = "` ` ` `<< fractionalKnapsack(W, arr, n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to solve fractional Knapsack Problem ` `import` `java.util.Arrays; ` `import` `java.util.Comparator; ` ` ` `//Greedy approach ` `public` `class` `FractionalKnapSack { ` `//Time complexity O(n log n) ` ` ` `public` `static` `void` `main(String[] args){ ` ` ` `int` `[] wt = {` `10` `, ` `40` `, ` `20` `, ` `30` `}; ` ` ` `int` `[] val = {` `60` `, ` `40` `, ` `100` `, ` `120` `}; ` ` ` `int` `capacity = ` `50` `; ` ` ` ` ` `double` `maxValue = getMaxValue(wt, val, capacity); ` ` ` `System.out.println(` `"Maximum value we can obtain = "` `+maxValue); ` ` ` ` ` `} ` ` ` `// // function to get maximum value ` ` ` `private` `static` `double` `getMaxValue(` `int` `[] wt, ` `int` `[] val, ` `int` `capacity){ ` ` ` `ItemValue[] iVal = ` `new` `ItemValue[wt.length]; ` ` ` ` ` `for` `(` `int` `i = ` `0` `; i < wt.length; i++){ ` ` ` `iVal[i] = ` `new` `ItemValue(wt[i], val[i], i); ` ` ` `} ` ` ` ` ` `//sorting items by value; ` ` ` `Arrays.sort(iVal, ` `new` `Comparator<ItemValue>() { ` ` ` `@Override` ` ` `public` `int` `compare(ItemValue o1, ItemValue o2) { ` ` ` `return` `o2.cost.compareTo(o1.cost) ; ` ` ` `} ` ` ` `}); ` ` ` ` ` ` ` `double` `totalValue = 0d; ` ` ` ` ` `for` `(ItemValue i: iVal){ ` ` ` ` ` `int` `curWt = (` `int` `) i.wt; ` ` ` `int` `curVal = (` `int` `) i.val; ` ` ` ` ` `if` `(capacity - curWt >= ` `0` `){` `//this weight can be picked while ` ` ` `capacity = capacity-curWt; ` ` ` `totalValue += curVal; ` ` ` ` ` `}` `else` `{` `//item cant be picked whole ` ` ` ` ` `double` `fraction = ((` `double` `)capacity/(` `double` `)curWt); ` ` ` `totalValue += (curVal*fraction); ` ` ` `capacity = (` `int` `)(capacity - (curWt*fraction)); ` ` ` `break` `; ` ` ` `} ` ` ` ` ` ` ` `} ` ` ` ` ` `return` `totalValue; ` ` ` ` ` `} ` ` ` ` ` `// item value class ` ` ` `static` `class` `ItemValue { ` ` ` `Double cost; ` ` ` `double` `wt, val, ind; ` ` ` ` ` `// item value function ` ` ` `public` `ItemValue(` `int` `wt, ` `int` `val, ` `int` `ind){ ` ` ` `this` `.wt = wt; ` ` ` `this` `.val = val; ` ` ` `this` `.ind = ind; ` ` ` `cost = ` `new` `Double(val/wt ); ` ` ` `} ` ` ` ` ` `} ` ` ` `} ` |

*chevron_right*

*filter_none*

Output :

Maximum value in Knapsack = 240

As main time taking step is sorting, the whole problem can be solved in O(n log n) only.

This article is contributed by Utkarsh Trivedi.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## Recommended Posts:

- 0-1 Knapsack Problem | DP-10
- A Space Optimized DP solution for 0-1 Knapsack Problem
- Find the fractional (or n/k - th) node in linked list
- Printing Items in 0/1 Knapsack
- 0/1 Knapsack using Branch and Bound
- Implementation of 0/1 Knapsack using Branch and Bound
- Unbounded Knapsack (Repetition of items allowed)
- Water Connection Problem
- Water drop problem
- Max Flow Problem Introduction
- Job Sequencing Problem | Set 2 (Using Disjoint Set)
- Shortest Superstring Problem
- Fitting Shelves Problem
- Job Sequencing Problem - Loss Minimization
- Job Sequencing Problem | Set 1 (Greedy Algorithm)