Knapsack problem dynamicprogramming

OUR TOPIC IS FRACTIONAL AND 0/1
KNAPSACK.
SUBMITTED BY:
Lithy Ema Rozario-162-15-7989
Imran Hossain-162-15-7672
Tania Maksum-162-15-7698
Shekh Hasibul Islam-162-15-7748
Mohd Nasir Uddin-162-15-7797
Md Fazlur Rahman-162-15-7796
Salowa Binte Sohel-162-15-7820
Submitted to :
Rifat Ara
Shams

THE FRACTIONAL KNAPSACK PROBLEM
• Given: A set S of n items, with each item i having
• bi - a positive benefit
• wi - a positive weight
• Goal: Choose items with maximum total benefit but with weight at
most W.
• If we are allowed to take fractional amounts, then this is the fractional
knapsack problem.
• In this case, we let xi denote the amount we take of item i
• Objective: maximize
• Constraint:
Si
iii wxb )/(
ii
Si
i wxWx 
0,

EXAMPLE
• Given: A set S of n items, with each item i having
• bi - a positive benefit
• wi - a positive weight
• Goal: Choose items with maximum total benefit but with total weight at
most W.
Weight:
Benefit:
1 2 3 4 5
4 ml 8 ml 2 ml 6 ml 1 ml
$12 $32 $40 $30 $50
Items:
Value:
3($ per ml) 4 20 5 50
10 ml
Solution: P
• 1 ml of 5 50$
• 2 ml of 3 40$
• 6 ml of 4 30$
• 1 ml of 2 4$
•Total Profit:124$
“knapsack”

THE FRACTIONAL KNAPSACK ALGORITHM
• Greedy choice: Keep taking item with highest value (benefit to
weight ratio)
• Since
Algorithm fractionalKnapsack(S, W)
Input: set S of items w/ benefit bi and weight wi; max. weight W
Output: amount xi of each item i to maximize benefit w/ weight at most W
for each item i in S
xi  0
vi  bi / wi {value}
w  0 {total weight}
while w < W
remove item i with highest vi
xi  min{wi , W - w}
w  w + min{wi , W - w}
 

Si
iii
Si
iii xwbwxb )/()/(

THE FRACTIONAL KNAPSACK ALGORITHM
• Running time: Given a collection S of n items, such that each item i has
a benefit bi and weight wi, we can construct a maximum-benefit subset of
S, allowing for fractional amounts, that has a total weight W in O(nlogn)
time.
• Use heap-based priority queue to store S
• Removing the item with the highest value takes O(logn) time
• In the worst case, need to remove all items

KNAPSACK PROBLEM
Given a set of items, each with a mass and a value,
determine the number of each item to include in a
collection so that the total weight is less than or equal
to a given limit and the total value is as large as
possible.
 It derives its name from the problem faced by
someone who is constrained by a fixed-
size knapsack and must fill it with the most valuable
items.

KNAPSACK PROBLEM
• In a knapsack problem or rucksack problem,
we are given a set of 𝑛 items, where each item 𝑖
is specified by a size 𝑠𝑖 and a value 𝑣𝑖. We are
also given a size bound 𝑆, the size of our
knapsack.
Item # Size Value
1 1 8
2 3 6
3 5 5

KNAPSACK PROBLEM
There are two versions of the problem:
1. 0-1 Knapsack Problem
2. Fractional Knapsack Problem
i. Bounded Knapsack Problem
ii. Unbounded Knapsack Problem

SOLUTIONS TO KNAPSACK
PROBLEMS
Greedy Algorithm – keep taking most
valuable items until maximum weight is
reached or taking the largest value of each
item by calculating 𝑉𝑖 =
𝑣𝑎𝑙𝑢𝑒 𝑖
𝑠𝑖𝑧𝑒 𝑖
Dynamic Programming – solve each sub
problem once and store their solutions in
an array

EXAMPLE
Given:
𝑛 = 4 (# of elements)
𝑆 = 5 pounds (maximum size)
Elements (size, value) =
{ (1, 200), (3, 240), (2, 140), (5, 150) }

GREEDY ALGORITHM
1. Calculate Vi =
vi
si
for 𝑖 = 1,2, … , 𝑛
2. Sort the items by decreasing Vi
3. Find j, such that
𝑠1 + 𝑠2 + ⋯ + 𝑠𝑗 ≤ 𝑆 < 𝑠1 + 𝑠2 + ⋯ + 𝑠𝑗+1

GREEDY ALGORITHM
Sample Problem
𝑉𝑖 =
𝑐𝑜𝑠𝑡𝑖
𝑤𝑒𝑖𝑔ℎ𝑡 𝑖
A B C D
cost 200 240 140 150
weight 1 3 2 5
value 200 80 70 30
𝑉𝑖 =
𝑣𝑎𝑙𝑢𝑒 𝑖
𝑠𝑖𝑧𝑒 𝑖
=
𝑐𝑜𝑠𝑡 𝑖
𝑤𝑒𝑖𝑔ℎ𝑡 𝑖

GREEDY ALGORITHM
 The optimal solution to the fractional
knapsack
 Not an optimal solution to the 0-1
knapsack

DYNAMIC PROGRAMMING
Recursive formula for sub problems:
𝑉 𝑘, 𝑠
=
𝑉 𝑘 − 1, 𝑠 𝑖𝑓𝑠 𝑘 > 𝑠
max 𝑉 𝑘 − 1, 𝑠 , 𝑉 𝑘 − 1, 𝑠 − 𝑠 𝑘 + 𝑣 𝑘 𝑒𝑙𝑠𝑒

DYNAMIC PROGRAMMING
for 𝑠 = 0 to 𝑆
V[ 0, s ] = 0
for 𝑖 = 1 to 𝑛
V[𝑖, 0 ] = 0

DYNAMIC PROGRAMMING
if 𝑠𝑖 ≤ 𝑠
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
V i, s = 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖
else
V i, s = V[i − 1, s]
else V i, s = V[i − 1, s]

EXAMPLE
Given:
𝑛 = 4 (# of elements)
𝑆 = 5 (maximum size)
Elements (size, value) =
{ (2, 3), (3, 4), (4, 5), (5, 6) }

EXAMPLE
is 0 1 2 3 4 5
0
1
2
3
4

EXAMPLE
for 𝑠 = 0 to 𝑆
V[ 0, 𝑠 ] = 0
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1
2
3
4

EXAMPLE
V[𝑖, 0 ] = 0
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0
2 0
3 0
4 0

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
V i, s = 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖
else
V i, s = V[i − 1, s]
else 𝐕 𝐢, 𝒔 = 𝐕[𝐢 − 𝟏, 𝐬]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0
2 0
3 0
4 0
Items (𝑠𝑖, 𝑣𝑖)
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
𝐕 𝐢, 𝒔 = 𝒗𝒊 + 𝑽 𝒊 − 𝟏, 𝒔 − 𝒔𝒊
else
V i, s = V[i − 1, s]
else 𝑉 𝑖, 𝑠 = 𝑉[𝑖 − 1, 𝑠]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3
2 0
3 0
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
𝐕 𝐢, 𝒔 = 𝒗𝒊 + 𝑽 𝒊 − 𝟏, 𝒔 − 𝒔𝒊
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3
2 0
3 0
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
𝐕 𝐢, 𝒔 = 𝒗𝒊 + 𝑽 𝒊 − 𝟏, 𝒔 − 𝒔𝒊
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3
2 0
3 0
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
𝐕 𝐢, 𝒔 = 𝒗𝒊 + 𝑽 𝒊 − 𝟏, 𝒔 − 𝒔𝒊
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0
3 0
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
V i, s = 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0
3 0
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
V i, s = 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3
3 0
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
𝐕 𝐢, 𝒔 = 𝒗𝒊 + 𝑽 𝒊 − 𝟏, 𝒔 − 𝒔𝒊
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4
3 0
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
𝐕 𝐢, 𝒔 = 𝒗𝒊 + 𝑽 𝒊 − 𝟏, 𝒔 − 𝒔𝒊
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4
3 0
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
𝐕 𝐢, 𝒔 = 𝒗𝒊 + 𝑽 𝒊 − 𝟏, 𝒔 − 𝒔𝒊
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
V i, s = 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0 0 3 4
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
𝐕 𝐢, 𝒔 = 𝒗𝒊 + 𝑽 𝒊 − 𝟏, 𝒔 − 𝒔𝒊
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0 0 3 4 5
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
𝑉 𝑖, 𝑠 = 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖
else
𝑽 𝒊, 𝒔 = 𝑽[𝒊 − 𝟏, 𝒔]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0 0 3 4 5 7
4 0
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
V i, s = 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0 0 3 4 5 7
4 0 0 3 4 5
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
if 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖 > 𝑉[𝑖 − 1, 𝑠]
V i, s = 𝑣𝑖 + 𝑉 𝑖 − 1, 𝑠 − 𝑠𝑖
else
V i, s = V[i − 1, s]
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0 0 3 4 5 7
4 0 0 3 4 5 7
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
𝑖 = 𝑛, 𝑘 = 𝑆
while 𝑖, 𝑘 > 0
if V 𝑖, 𝑘 ≠ 𝑉 1 − 𝑖, 𝑘
𝑖 = 𝑖 − 1, 𝑘 = 𝑘 − 𝑠𝑖
else
𝑖 = 𝑖 − 1
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0 0 3 4 5 7
4 0 0 3 4 5 7
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
𝑖 = 𝑛, 𝑘 = 𝑆
if V 𝑖, 𝑘 ≠ 𝑉 1 − 𝑖, 𝑘
𝑖 = 𝑖 − 1, 𝑘 = 𝑘 − 𝑠𝑖
else
𝒊 = 𝒊 − 𝟏
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0 0 3 4 5 7
4 0 0 3 4 5 7
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0 0 3 4 5 7
4 0 0 3 4 5 7
𝑖 = 𝑛, 𝑘 = 𝑆
if V 𝑖, 𝑘 ≠ 𝑉 1 − 𝑖, 𝑘
𝑖 = 𝑖 − 1, 𝑘 = 𝑘 − 𝑠𝑖
else
𝒊 = 𝒊 − 𝟏
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
𝑖 = 𝑛, 𝑘 = 𝑆
if V 𝑖, 𝑘 ≠ 𝑉 1 − 𝑖, 𝑘
𝒊 = 𝒊 − 𝟏, 𝒌 = 𝒌 − 𝒔𝒊
else
𝑖 = 𝑖 − 1
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0 0 3 4 5 7
4 0 0 3 4 5 7
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

EXAMPLE
The optimal knapsack should
contain {1,2} = 7
is 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 3 3 3 3
2 0 0 3 4 4 7
3 0 0 3 4 5 7
4 0 0 3 4 5 7
1: (2, 3)
2: (3, 4)
3: (4, 5)
4: (5, 6)

Knapsack problem dynamicprogramming

Knapsack problem dynamicprogramming

In this document