bin packing2 and scheduling for mul.pptx

 There is a list of numbers called “weights”
 These numbers represent objects that need to
be packed into “bins” with a particular
capacity
 The goal is to pack the weights into the
smallest number of bins possible

 Objects coming down a conveyor belt need to
be packed for shipping
 A construction plan calls for small boards of
various lengths, and you need to know how
many long boards to order
 Tour groups of various sizes need to be
assigned to busses so that the groups are not
split up

 Pack the weights 5, 7, 3, 5, 6, 2, 4, 4, 7, and 4
into bins with capacity 10

 Pack the weights 5, 7, 3, 5, 6, 2, 4, 4, 7, and 4
into bins with capacity 10
 There are many possible solutions

 We saw a solution with 5 bins
 Is that the best possible solution?
 If we add up all the weights, we get
5+7+3+5+6+2+4+4+7+4 = 47
 Since our bins have capacity 10, the best we
can hope for is 5 bins (5  10 = 50)

 Take a look at this solution
 Notice that some of the bins are exactly full:
no leftover space
 This is the best way to use a bin

 One heuristic method for packing weights is
to look for these “best fits”
 However, if the list of weights is very long, or
if the bin capacity is very large, this can be
impractical
 Also, sometimes circumstances prevent us
from looking at the entire list of weights
ahead of time

 In many packing problems, we have to decide
what to do with each weight, in order, before
moving on to the next one
 Example: Objects coming down a conveyor
belt

 Here are two (there are many more) methods
we will consider for deciding which bin to
pack the weight into
 Look for the first fit. Starting with the first bin,
check each bin one at a time until you find a bin
that has room for the weight.
 Look for the best fit. Consider all of the bins and
find the bin that can hold the weight and would
have the least room leftover after packing it.

 Let’s try the first fit algorithm on our problem

 We’re looking at weights one at a time, so
ignore everything but the first weight

 There is room in the first bin, so we put the 5
in there

 There is not room for this weight in the first
bin, so we create a new bin

 Now we consider the next weight

 It fits into the first bin, so that’s where we put
it

 It doesn’t fit into the first bin…

 …or the second bin, so it goes into a new bin

 The next weight doesn’t fit into any of the
existing bins, so it goes into a new one

 It fits into the first bin

 Now we move on to the next weight

 It doesn’t fit in the first bin…

 …but it does fit into the third bin

 Similarly, the next weight doesn’t fit into the
first three bins, but it does fit into the fourth

 The next weight doesn’t fit into any of our
bins, so we make a 5th bin

 There is no room for the last weight in any of
our bins

 We have finished packing the weights into six
bins
 But this isn’t the optimal solution!

 Let’s start over and use the best fit algorithm

 This time we need to keep track of how much
room is left in each bin

 When we consider a weight, we look at all the
bins that have room for it…

 …and put it into the bin that will have the
least room left over

 In this case, we only have one bin, so the 5
goes in there

 For the next weight, we don’t have a bin that
has room for it, so we make a new bin

 Remember, the number under the bin
represents how much room is left over

 Both of our bins have room for the next
weight

 Bin #2 has the least room left over, so that’s
where we put our weight

 Only one bin has room for our next weight, so
that’s where it goes

 Notice that we have two “best fits” now

 Since our two bins are full, the next weight
must go into a new bin

 The next weight (2) can only go into Bin #3

 This weight doesn’t fit into any of our bins…

 …so it goes into a new bin

 This next weight only fits into one bin

 This weight must go into a new bin

 The last weight doesn’t fit into any of our
bins, so we need to make a sixth bin

 Here is our final answer, with six bins
 This is a different result than the first fit
algorithm, but still not the best solution

 One reason why we weren’t finding the best
solution is that we had large weights that
came late in the list
 It’s more efficient to deal with big weights
first and fit in smaller weights around them

 First fit decreasing: Sort the list of weights
from biggest to smallest, then use the first fit
method
 Best fit decreasing: Sort the list of weights
from biggest to smallest, then use the best fit
method

 Scheduling problems
 The weights are tasks that need to be
completed
 The bins are “processors,” which are the
agents (people, machines, teams, etc.) that
will actually perform the tasks

 Two types of scheduling problems
 Type 1: The capacity of the bins represents a
deadline by which all tasks must be
completed
 The number of bins needed represents the
number of processors needed to complete all
tasks within the deadline

 Type 1: The capacity of the bins represents a
deadline by which all tasks must be
completed
 We solve this type of problem using normal
bin packing methods

 Type 2: There is a fixed number of bins, but
the bins do not have a set capacity
 This time the goal is to assign the tasks to
processors in such a way that all tasks are
completed as soon as possible

 We can’t use any of the bin packing methods
we have learned for this second type of
problem, since they rely on “fitting” weights
into bins
 This time, each bin has an infinite capacity, so
any weight “fits” into any bin

 Sort the task times from largest to smallest
 Assign each task, one at a time, to the
processor that currently has the least total
amount of time assigned to it
 If there is a tie, assign the task to the first
processor that is tied

 Assign tasks of length 14, 26, 11, 16, 22, 21, 8,
and 29 minutes to three processors using the
Longest Processing Time algorithm

 We know we have three processors, so we
draw three spaces to put tasks in

 The algorithm requires us to keep track of
how much time has been assigned to each
processor

 Now we sort the list of task times in
decreasing order:
 29, 26, 22, 21, 16, 14, 11, 8

 Since all the processors are tied at 0, we
assign the first task (29) to Processor #1
 26, 22, 21, 16, 14, 11, 8

 Now Processors #2 and #3 are tied, so we
assign the next task (26) to #2
 22, 21, 16, 14, 11, 8

 Next, Processor #3 has the least time assigned
to it, so the next task (22) goes there
 21, 16, 14, 11, 8

 Again Processor #3 has the least time
assigned to it, so the next task (21) goes there
 16, 14, 11, 8

 Now Processor #2 has the least amount of
time assigned to it, so that’s where 16 goes
 14, 11, 8

 Next, Processor #1 has the smallest amount
of time assigned, so the next task goes there
 11, 8

 Now Processor #2 has the lowest total time,
so the next task (11) goes there
 8

 Finally, Processors #1 and #3 are tied, so we
put the next task (8) into the first tied
processor

 We are done assigning tasks, and we can see
that with this method, all tasks will be
complete after 53 minutes

 How good is this answer?
 If we add up all the task times, we get:
29+26+22+21+16+14+11+8 = 147 minutes
 Since we have 3 processors, we might hope to
assign all the tasks so that each processor gets
exactly 147/3 = 49 minutes
 This might not be possible, but it suggests we
might be able to do better than 53

 In fact, we can do better
 This shows us that the LPT doesn’t always give
the best answer

bin packing2 and scheduling for mul.pptx

More Related Content

Similar to bin packing2 and scheduling for mul.pptx

More from naghamallella

Recently uploaded

bin packing2 and scheduling for mul.pptx