Chap8 part ii
Download as PPT, PDF1 like720 views
This document discusses approximation algorithms for two NP-complete problems: scheduling independent tasks and bin packing. It introduces the longest processing time (LPT) rule for scheduling tasks, and proves an upper bound on how suboptimal LPT schedules can be compared to optimal schedules. It also describes four heuristics for bin packing - first fit, best fit, first fit decreasing, and best fit decreasing - and proves an upper bound on the number of bins they may use compared to optimal packings.
![
While the LPT rule may generate optimal schedules for
some problem instances, it does not do so for all
instances. How bad can LPT schedules be relative to
optimal schedules?
Theorem: [Graham] Let F*(I) be the finish time of an
optimal m processor schedule for instance I of the task
scheduling problem. Let F(I) be the finish time of an LPT
schedule for the same instance, then
|F*(I)-F(I)|/F*(I) ≤ 1/3 – 1/(3m)
The proof of this theorem can be referred to the book
“Fundamentals of Computer Algorithms”, E. Horowitz and
S. Sahni, Pitman Publishing, 1978.
6](https://image.slidesharecdn.com/chap8partii-140227195332-phpapp01/85/Chap8-part-ii-6-320.jpg)
Chap8 part ii
- 2. Outline Scheduling Independent tasks Bin packing 2
- 3. Scheduling independent tasks An instance of the scheduling problem is defined by a set of n task times, ti, 1≤ i ≤ n, and m, the number of processors. Obtaining minimum finish time schedules is NPcomplete. The scheduling rule we will use is called the LPT (longest processing time) rule. Definition: An LPT schedule is one that is the result of an algorithm, which, whenever a processor becomes free, assigns to that processor a task whose time is the largest of those tasks not yet assigned. 3
- 4. Example Let m = 3, n = 6 and (t1, t2, t3, t4, t5, t6) = (8, 7, 6, 5, 4, 3). In an LPT schedule tasks 1, 2 and 3 respectively. Tasks 1, 2, and 3 are assigned to processors 1, 2 and 3. Tasks 4, 5 and 6 are respectively assigned to the processors 3, 2, and 1. The finish time is 11. Since Σ ti /3 = 11, the schedule is also optimal. 678 11 P1 1 6 P3 2 5 P3 3 4 4
- 5. Example Let m = 3, n = 6 and (t1, t2, t3, t4, t5, t6, t7) = (5, 5, 4, 4, 3, 3, 3). The LPT schedule is shown in the following figure. This has a finish time is 11. The optimal schedule is 9. Hence, for this instance |F*(I) – F(I)|/F*(I) = (11-9)/9=2/9. 4 5 P1 1 8 5 11 7 9 1 3 4 P2 2 6 2 P3 3 4 5 (a) LPT schedule 6 7 (b) Optimal schedule 5
- 6. While the LPT rule may generate optimal schedules for some problem instances, it does not do so for all instances. How bad can LPT schedules be relative to optimal schedules? Theorem: [Graham] Let F*(I) be the finish time of an optimal m processor schedule for instance I of the task scheduling problem. Let F(I) be the finish time of an LPT schedule for the same instance, then |F*(I)-F(I)|/F*(I) ≤ 1/3 – 1/(3m) The proof of this theorem can be referred to the book “Fundamentals of Computer Algorithms”, E. Horowitz and S. Sahni, Pitman Publishing, 1978. 6
- 7. Bin Packing We are given n objects which have to be placed in bins of equal capacity L. Object i requires li units of bin capacity. The objective is to determine the minimum number of bins needed to accommodate all n objects. Example: Let L = 10, n = 6 and (l1, l2, l3, l4, l5, l6) = (5, 6, 3, 7, 5,4) The bin packing problem is NP-complete. 7
- 8. Four heuristics One can derive many simple heuristics for the bin packing problem. In general, they will not obtain optimal packings. However, they obtain packings that use only a “small” fraction of bins more than an optimal packing. Four heuristics: First fit (FF) Best fit (BF) First fit Decreasing (FFD) Best fit Decreasing (BFD) 8
- 9. First-fit and Best-fit First-fit Index the bins 1, 2, 3,… All bins are initially filled to level 0. Objects are considered for packing in the order 1, 2, …, n. To pack object i, find the least index j such that bin j is filled to the level r (r ≤ L – li). Pack I into bin j. Bin j is now filled to level r + li. Best-fit The initial conditions are the same as for FF. When object i is being considered, find the least j such that bin j is filled to a level r (r ≤ L – li) and r is as large as possible. Pack i into bin j. Bin j is now filled to level r + li. 9
- 10. Example 6 (a) First Fit 3 1 5 1 2 4 5 (b) Best Fit 3 4 2 6 10
- 11. First-fit decreasing and Best-fit decreasing First-fit decreasing (FFD) Reorder the objects so that li ≥ li+1, 1 ≤ i ≤ n. Now use First-fit to pack the objects. Best-fit decreasing (BFD) Reorder the objects so that li ≥ li+1, 1 ≤ i ≤ n. Now use First-fit to pack the objects. 11
- 12. Example 3 6 4 2 5 1 (c) First Fit Decreasing and Best Fit Decreasing FFD and BFD do better than either FF or BF on this instance. While FFD and BFD obtain optimal packings on this example, they do not in general obtain such a packings. 12
- 13. Theorem Let I be an instance of the bin packing problem and let F*(I) be the minimum number of bins needed for this instance. The packing generated by either FF or BF uses no more than (17/10)F*(I)+2 bins. The packings generated by either FFD or BFD uses no more than (11/9)F*(I)+4 bins. This proof of this theorem is long and complex (given by Johnson et al., 1974). 13
- 14. Appendix: A Taxonomy of Algorithm Design Strategies Strategy name Examples ---------------------------------------------------------------------------------------Bruce-force Sequential search, selection sort Divide-and-conquer Quicksort, mergesort, binary search Decrease-and-conquer Insertion sort, DFS, BFS Transform-and-conquer heapsort, Gauss elimination Greedy Prim’s, Dijkstra’s Dynamic Programming Floyd’s Backtracking Branch-and-Bound Approximate algorithms Heuristics Meta-heuristics 14