More Approximation Algorithms
|
|
|
- Preston Horn
- 5 years ago
- Views:
Transcription
1 CS 473: Algorithms, Spring 2018 More Approximation Algorithms Lecture 25 April 26, 2018 Most slides are courtesy Prof. Chekuri Ruta (UIUC) CS473 1 Spring / 28
2 Formal definition of approximation algorithm An algorithm A for an optimization problem X is an α-approximation algorithm if the following conditions hold: for each instance I of X the algorithm A correctly outputs a valid solution to I A is a polynomial-time algorithm Letting OPT (I ) and A(I ) denote the values of an optimum solution and the solution output by A on instances I, OPT (I )/A(I ) α and A(I )/OPT (I ) α. Alternatively: If X is a minimization problem: A(I )/OPT (I ) α If X is a maximization problem: OPT (I )/A(I ) α Definition ensures that α 1 To be formal we need to say α(n) where n = I since in some cases the approximation ratio depends on the size of the instance. Ruta (UIUC) CS473 2 Spring / 28
3 Part I Approximation for Load Balancing Ruta (UIUC) CS473 3 Spring / 28
4 Load Balancing Given n jobs J 1, J 2,..., J n with sizes s 1, s 2,..., s n and m identical machines M 1,..., M m assign jobs to machines to minimize maximum load (also called makespan). Problem sometimes referred to as multiprocessor scheduling. Example: 3 machines and 8 jobs with sizes 4, 3, 1, 2, 5, 6, 9, 7. Ruta (UIUC) CS473 4 Spring / 28
5 Load Balancing Given n jobs J 1, J 2,..., J n with sizes s 1, s 2,..., s n and m identical machines M 1,..., M m assign jobs to machines to minimize maximum load (also called makespan). Formally, an assignment is a mapping f : {1, 2,..., n} {1,..., m}. The load l f (j) of machine M j under f is i :f (i )=j s i Goal is to find f to minimize max j l f (j). Ruta (UIUC) CS473 5 Spring / 28
6 Greedy List Scheduling List-Scheduling Let J 1, J 2,..., J n be an ordering of jobs for i = 1 to n do Schedule job J i on the currently least loaded machine Ruta (UIUC) CS473 6 Spring / 28
7 Greedy List Scheduling List-Scheduling Let J 1, J 2,..., J n be an ordering of jobs for i = 1 to n do Schedule job J i on the currently least loaded machine Example: 3 machines and 8 jobs with sizes 4, 3, 1, 2, 5, 6, 9, 7. Ruta (UIUC) CS473 6 Spring / 28
8 Example Example: 3 machines and 8 jobs with sizes 4, 3, 1, 2, 5, 6, 9, 7. Different list: 9, 7, 6, 5, 4, 3, 2, 1 Ruta (UIUC) CS473 7 Spring / 28
9 Two lower bounds on OPT OPT is the optimum load Lower bounds on OPT: Ruta (UIUC) CS473 8 Spring / 28
10 Two lower bounds on OPT OPT is the optimum load Lower bounds on OPT: average load: OPT n i =1 s i /m. Why? maximum job size: OPT max n i =1 s i. Why? Ruta (UIUC) CS473 8 Spring / 28
11 Analysis of Greedy List Scheduling Theorem Let L be makespan of Greedy List Scheduling on a given instance. Then L 2(1 1/m)OPT where OPT is the optimum makespan for that instance. Ruta (UIUC) CS473 9 Spring / 28
12 Analysis of Greedy List Scheduling Theorem Let L be makespan of Greedy List Scheduling on a given instance. Then L 2(1 1/m)OPT where OPT is the optimum makespan for that instance. Let M h be the machine which achieves the load L for Greedy List Scheduling. Let J i be the job that was last scheduled on M h. Why was J i scheduled on M h? It means that M h was the least loaded machine when J i was considered. Implies all machines had load at least L s i at that time. Ruta (UIUC) CS473 9 Spring / 28
13 Analysis continued Lemma L s i ( i 1 l=1 s l)/m. Proof. Since all machines had load at least L s i it means that m(l s i ) i 1 l=1 s l and hence i 1 L s i ( s l )/m. l=1 Ruta (UIUC) CS Spring / 28
14 Analysis continued But then i 1 L ( s l )/m + s i ( l=1 n s l )/m + (1 1 m )s i l=1 Ruta (UIUC) CS Spring / 28
15 Analysis continued But then i 1 L ( s l )/m + s i ( l=1 n s l )/m + (1 1 m )s i l=1 OPT + (1 1 m )OPT (2 2 m )OPT = 2(1 1 m )OPT. Ruta (UIUC) CS Spring / 28
16 A Tight Example Question: Is the analysis of the algorithm tight? That is, are there instances where L is 2(1 1/m)OPT? Ruta (UIUC) CS Spring / 28
17 A Tight Example Question: Is the analysis of the algorithm tight? That is, are there instances where L is 2(1 1/m)OPT? Example: m(m 1) jobs of size 1 and one big job of size m where m is number of machines. Ruta (UIUC) CS Spring / 28
18 A Tight Example Question: Is the analysis of the algorithm tight? That is, are there instances where L is 2(1 1/m)OPT? Example: m(m 1) jobs of size 1 and one big job of size m where m is number of machines. OPT = m. Why? Ruta (UIUC) CS Spring / 28
19 A Tight Example Question: Is the analysis of the algorithm tight? That is, are there instances where L is 2(1 1/m)OPT? Example: m(m 1) jobs of size 1 and one big job of size m where m is number of machines. OPT = m. Why? If the list has large job at end the Greedy will give makespan of Ruta (UIUC) CS Spring / 28
20 A Tight Example Question: Is the analysis of the algorithm tight? That is, are there instances where L is 2(1 1/m)OPT? Example: m(m 1) jobs of size 1 and one big job of size m where m is number of machines. OPT = m. Why? If the list has large job at end the Greedy will give makespan of m + m 1 = 2m 1. Ruta (UIUC) CS Spring / 28
21 Ordering jobs from largest to smallest Obvious heuristic: Order jobs in decreasing size order and then use Greedy. Ruta (UIUC) CS Spring / 28
22 Ordering jobs from largest to smallest Obvious heuristic: Order jobs in decreasing size order and then use Greedy. Does it lead to an improved performance in the worst case? How much? Ruta (UIUC) CS Spring / 28
23 Ordering jobs from largest to smallest Obvious heuristic: Order jobs in decreasing size order and then use Greedy. Does it lead to an improved performance in the worst case? How much? Theorem Greedy List Scheduling with jobs sorted from largest to smallest gives a 4/3-approximation and this is essentially tight. Ruta (UIUC) CS Spring / 28
24 Analysis Not so obvious. Ruta (UIUC) CS Spring / 28
25 Analysis Not so obvious. If we only use average load and maximum job size as lower bounds on OPT then we cannot improve the bound of 2 Example: m + 1 jobs of size 1 OPT = 2 average load is 1 + 1/m and max job size is 1 Ruta (UIUC) CS Spring / 28
26 Analysis Not so obvious. If we only use average load and maximum job size as lower bounds on OPT then we cannot improve the bound of 2 Example: m + 1 jobs of size 1 OPT = 2 average load is 1 + 1/m and max job size is 1 Need another lower bound Ruta (UIUC) CS Spring / 28
27 Another useful lower bound Lemma Suppose jobs are sorted, that is s 1 s 2... s n and n > m then OPT s m + s m+1 2s m+1. Ruta (UIUC) CS Spring / 28
28 Another useful lower bound Lemma Suppose jobs are sorted, that is s 1 s 2... s n and n > m then OPT s m + s m+1 2s m+1. Proof. Consider OPTimal schedule of the first m + 1 jobs J 1,..., J m+1. By pigeon hole principle two of these jobs on same machine. Ruta (UIUC) CS Spring / 28
29 Another useful lower bound Lemma Suppose jobs are sorted, that is s 1 s 2... s n and n > m then OPT s m + s m+1 2s m+1. Proof. Consider OPTimal schedule of the first m + 1 jobs J 1,..., J m+1. By pigeon hole principle two of these jobs on same machine. Ruta (UIUC) CS Spring / 28
30 Another useful lower bound Lemma Suppose jobs are sorted, that is s 1 s 2... s n and n > m then OPT s m + s m+1 2s m+1. Proof. Consider OPTimal schedule of the first m + 1 jobs J 1,..., J m+1. By pigeon hole principle two of these jobs on same machine. OPT Load on that machine Ruta (UIUC) CS Spring / 28
31 Another useful lower bound Lemma Suppose jobs are sorted, that is s 1 s 2... s n and n > m then OPT s m + s m+1 2s m+1. Proof. Consider OPTimal schedule of the first m + 1 jobs J 1,..., J m+1. By pigeon hole principle two of these jobs on same machine. OPT Load on that machine the sum of the smallest two job sizes in the first m + 1 jobs Ruta (UIUC) CS Spring / 28
32 Another useful lower bound Lemma Suppose jobs are sorted, that is s 1 s 2... s n and n > m then OPT s m + s m+1 2s m+1. Proof. Consider OPTimal schedule of the first m + 1 jobs J 1,..., J m+1. By pigeon hole principle two of these jobs on same machine. OPT Load on that machine the sum of the smallest two job sizes in the first m + 1 jobs = s m + s m+1. Ruta (UIUC) CS Spring / 28
33 Proving a 3/2 bound Using the new lower bound we will prove a weaker upper bound of 3/2 rather than the right bound of 4/3. Ruta (UIUC) CS Spring / 28
34 Proving a 3/2 bound Using the new lower bound we will prove a weaker upper bound of 3/2 rather than the right bound of 4/3. As before let M j be the machine achieving the makespan L and let J i be the last job assigned to M j. we have L s i 1 i 1 m l=1 s l OPT. Now a more careful analysis. Ruta (UIUC) CS Spring / 28
35 Proving a 3/2 bound Using the new lower bound we will prove a weaker upper bound of 3/2 rather than the right bound of 4/3. As before let M j be the machine achieving the makespan L and let J i be the last job assigned to M j. we have L s i 1 i 1 m l=1 s l OPT. Now a more careful analysis. Case 1: If s i is only job on M j then Ruta (UIUC) CS Spring / 28
36 Proving a 3/2 bound Using the new lower bound we will prove a weaker upper bound of 3/2 rather than the right bound of 4/3. As before let M j be the machine achieving the makespan L and let J i be the last job assigned to M j. we have L s i 1 i 1 m l=1 s l OPT. Now a more careful analysis. Case 1: If s i is only job on M j then L = s i OPT. Ruta (UIUC) CS Spring / 28
37 Proving a 3/2 bound Using the new lower bound we will prove a weaker upper bound of 3/2 rather than the right bound of 4/3. As before let M j be the machine achieving the makespan L and let J i be the last job assigned to M j. we have L s i 1 i 1 m l=1 s l OPT. Now a more careful analysis. Case 1: If s i is only job on M j then L = s i OPT. Case 2: At least one more job on M j before s i. We have seen that L s i OPT. Ruta (UIUC) CS Spring / 28
38 Proving a 3/2 bound Using the new lower bound we will prove a weaker upper bound of 3/2 rather than the right bound of 4/3. As before let M j be the machine achieving the makespan L and let J i be the last job assigned to M j. we have L s i 1 i 1 m l=1 s l OPT. Now a more careful analysis. Case 1: If s i is only job on M j then L = s i OPT. Case 2: At least one more job on M j before s i. We have seen that L s i OPT. Claim: s i OPT /2 Ruta (UIUC) CS Spring / 28
39 Proving a 3/2 bound Using the new lower bound we will prove a weaker upper bound of 3/2 rather than the right bound of 4/3. As before let M j be the machine achieving the makespan L and let J i be the last job assigned to M j. we have L s i 1 i 1 m l=1 s l OPT. Now a more careful analysis. Case 1: If s i is only job on M j then L = s i OPT. Case 2: At least one more job on M j before s i. We have seen that L s i OPT. Claim: s i OPT /2 Together, we have L OPT + s i 3OPT /2. Ruta (UIUC) CS Spring / 28
40 Proof of Claim Claim: s i OPT /2 Ruta (UIUC) CS Spring / 28
41 Proof of Claim Claim: s i OPT /2 Proof: Since M j had a job before s i we have i > m. Why? Ruta (UIUC) CS Spring / 28
42 Proof of Claim Claim: s i OPT /2 Proof: Since M j had a job before s i we have i > m. Why? Hence s i s m+1 becase jobs were sorted by decreasing size. Ruta (UIUC) CS Spring / 28
43 Proof of Claim Claim: s i OPT /2 Proof: Since M j had a job before s i we have i > m. Why? Hence s i s m+1 becase jobs were sorted by decreasing size. Since 2s m+1 OPT, we have s i s m+1 OPT /2. Ruta (UIUC) CS Spring / 28
44 Part II Approximation for Set Cover Ruta (UIUC) CS Spring / 28
45 Set Cover Input: Universe U of n elements and m subsets S 1, S 2,..., S m such that i S i = U. Goal: Pick fewest number of subsets to cover all of U (equivalently, whose union is U). Ruta (UIUC) CS Spring / 28
46 Set Cover Input: Universe U of n elements and m subsets S 1, S 2,..., S m such that i S i = U. Goal: Pick fewest number of subsets to cover all of U (equivalently, whose union is U). Greedy(U, S 1, S 2,..., S m ) Uncovered = U While Uncovered do Pick set S j that covers max number of uncovered elements Add S j to solution Uncovered = Uncovered S j endwhile Output chosen sets Ruta (UIUC) CS Spring / 28
47 Analysis of Greedy Let k be minimum number of sets to cover U. Let k be number of sets chosen by Greedy. Let α i be # new elements covered in iteration i. Let β i be # elements uncovered at end of iteration i. β 0 = n. Ruta (UIUC) CS Spring / 28
48 Analysis of Greedy Let k be minimum number of sets to cover U. Let k be number of sets chosen by Greedy. Let α i be # new elements covered in iteration i. Let β i be # elements uncovered at end of iteration i. β 0 = n. Lemma α i β i 1 /k. Ruta (UIUC) CS Spring / 28
49 Analysis of Greedy Let k be minimum number of sets to cover U. Let k be number of sets chosen by Greedy. Let α i be # new elements covered in iteration i. Let β i be # elements uncovered at end of iteration i. β 0 = n. Lemma α i β i 1 /k. Proof. Let U i be uncovered elements at start of iteration i. All these elements can be covered by some k sets since all of U can be covered by k sets. Ruta (UIUC) CS Spring / 28
50 Analysis of Greedy Let k be minimum number of sets to cover U. Let k be number of sets chosen by Greedy. Let α i be # new elements covered in iteration i. Let β i be # elements uncovered at end of iteration i. β 0 = n. Lemma α i β i 1 /k. Proof. Let U i be uncovered elements at start of iteration i. All these elements can be covered by some k sets since all of U can be covered by k sets. There exists one of those sets that covers at least U i /k elements. Ruta (UIUC) CS Spring / 28
51 Analysis of Greedy Let k be minimum number of sets to cover U. Let k be number of sets chosen by Greedy. Let α i be # new elements covered in iteration i. Let β i be # elements uncovered at end of iteration i. β 0 = n. Lemma α i β i 1 /k. Proof. Let U i be uncovered elements at start of iteration i. All these elements can be covered by some k sets since all of U can be covered by k sets. There exists one of those sets that covers at least U i /k elements. Greedy picks the best set and hence covers at least that many elements. Note U i = β i 1. Ruta (UIUC) CS Spring / 28
52 Analysis of Greedy contd Lemma α i β i 1 /k. β i = β i 1 α i Ruta (UIUC) CS Spring / 28
53 Analysis of Greedy contd Lemma α i β i 1 /k. β i = β i 1 α i β i 1 β i 1 /k = (1 1/k )β i 1. Ruta (UIUC) CS Spring / 28
54 Analysis of Greedy contd Lemma α i β i 1 /k. β i = β i 1 α i β i 1 β i 1 /k = (1 1/k )β i 1. Hence by induction, β i β 0 (1 1/k ) i = n(1 1/k ) i. Thus, after k = k ln n iterations number number of uncovered elements is at most n(1 1/k ) k ln n ne ln n 1. Ruta (UIUC) CS Spring / 28
55 Analysis of Greedy contd Lemma α i β i 1 /k. β i = β i 1 α i β i 1 β i 1 /k = (1 1/k )β i 1. Hence by induction, β i β 0 (1 1/k ) i = n(1 1/k ) i. Thus, after k = k ln n iterations number number of uncovered elements is at most n(1 1/k ) k ln n ne ln n 1. Thus algorithm terminates in at most k ln n + 1 iterations. Total number of sets chosen is number of iterations. Ruta (UIUC) CS Spring / 28
56 Analysis contd Theorem Greedy gives a (ln n + 1)-approximation for Set Cover. Ruta (UIUC) CS Spring / 28
57 Analysis contd Theorem Greedy gives a (ln n + 1)-approximation for Set Cover. Algorithm generalizes to weighted case easily. Pick sets in each iteration based on ratio of elements covered divided by weight. Analysis a bit harder but also gives a (ln n + 1)-approximation. Ruta (UIUC) CS Spring / 28
58 Analysis contd Theorem Greedy gives a (ln n + 1)-approximation for Set Cover. Algorithm generalizes to weighted case easily. Pick sets in each iteration based on ratio of elements covered divided by weight. Analysis a bit harder but also gives a (ln n + 1)-approximation. Can show a tighter bound of (ln d + 1) where d is maximum set size. Ruta (UIUC) CS Spring / 28
59 Analysis contd Theorem Greedy gives a (ln n + 1)-approximation for Set Cover. Algorithm generalizes to weighted case easily. Pick sets in each iteration based on ratio of elements covered divided by weight. Analysis a bit harder but also gives a (ln n + 1)-approximation. Can show a tighter bound of (ln d + 1) where d is maximum set size. Theorem Unless P = NP no (ln n + ɛ)-approximation for Set Cover. Ruta (UIUC) CS Spring / 28
60 A bad example for Greedy n = 2( p ) = 2(2 p+1 1), m = 2 + (p + 1), OPT = 2, Greedy picks (p + 1) and hence ratio is Ω(ln n). Ruta (UIUC) CS Spring / 28
61 Advantage of Greedy Greedy is a simple algorithm. In several scenarios the set system is implicit and exponentially large in n. Ruta (UIUC) CS Spring / 28
62 Advantage of Greedy Greedy is a simple algorithm. In several scenarios the set system is implicit and exponentially large in n. Nevertheless, the Greedy algorithm can be implemented efficiently if there is an oracle that each step picks the best set efficiently. Ruta (UIUC) CS Spring / 28
63 Advantage of Greedy Greedy is a simple algorithm. In several scenarios the set system is implicit and exponentially large in n. Nevertheless, the Greedy algorithm can be implemented efficiently if there is an oracle that each step picks the best set efficiently. Example. Covering all the edges of a graph using minimum number of disjoint trees. Ruta (UIUC) CS Spring / 28
64 Max k-cover Input: Universe U of n elements and m subsets S 1, S 2,..., S m and integer k. Goal: Pick k subsets to maximize number of covered elements. Ruta (UIUC) CS Spring / 28
65 Max k-cover Input: Universe U of n elements and m subsets S 1, S 2,..., S m and integer k. Goal: Pick k subsets to maximize number of covered elements. Greedy(U, S 1, S 2,..., S m, k) Uncovered = U for i = 1 to k do Pick set S j that covers max number of uncovered elements Add S j to solution Uncovered = Uncovered S j endwhile Output chosen k sets Ruta (UIUC) CS Spring / 28
66 Analysis Similar to previous analysis. Let OPT be max number of covered elements to cover U. Let α i be number of new elements covered in iteration i. Let γ i be number of elements covered by greedy after i iterations. Ruta (UIUC) CS Spring / 28
67 Analysis Similar to previous analysis. Let OPT be max number of covered elements to cover U. Let α i be number of new elements covered in iteration i. Let γ i be number of elements covered by greedy after i iterations. Let β i = OPT γ i. Define β 0 = OPT. Ruta (UIUC) CS Spring / 28
68 Analysis Similar to previous analysis. Let OPT be max number of covered elements to cover U. Let α i be number of new elements covered in iteration i. Let γ i be number of elements covered by greedy after i iterations. Let β i = OPT γ i. Define β 0 = OPT. Lemma α i β i 1 /k. Proof: Exercise. Ruta (UIUC) CS Spring / 28
69 Analysis contd Lemma α i β i 1 /k. β i = β i 1 α i β i 1 β i 1 /k = (1 1/k)β i 1. Hence by induction, β i β 0 (1 1/k) i = OPT (1 1/k) i. Thus, after k iterations, β k OPT (1 1/k) k OPT /e. Ruta (UIUC) CS Spring / 28
70 Analysis contd Lemma α i β i 1 /k. β i = β i 1 α i β i 1 β i 1 /k = (1 1/k)β i 1. Hence by induction, β i β 0 (1 1/k) i = OPT (1 1/k) i. Thus, after k iterations, β k OPT (1 1/k) k OPT /e. Thus γ k = OPT β k (1 1/e)OPT. Ruta (UIUC) CS Spring / 28
71 Analysis contd Theorem Greedy gives a (1 1/e)-approximation for Max k-coverage. Above theorem generalizes to submodular function maximization and has many applications. Theorem (Feige 1998) Unless P = NP there is no (1 1/e ɛ)-approximation for Max k-coverage for any fixed ɛ > 0. Ruta (UIUC) CS Spring / 28
Approximation Algorithms (Load Balancing)
July 6, 204 Problem Definition : We are given a set of n jobs {J, J 2,..., J n }. Each job J i has a processing time t i 0. We are given m identical machines. Problem Definition : We are given a set of
This means that we can assume each list ) is
This means that we can assume each list ) is of the form ),, ( )with < and Since the sizes of the items are integers, there are at most +1pairs in each list Furthermore, if we let = be the maximum possible
Network Design and Game Theory Spring 2008 Lecture 2
Network Design and Game Theory Spring 2008 Lecture 2 Instructor: Mohammad T. Hajiaghayi Scribe: Imdadullah Khan February 04, 2008 MAXIMUM COVERAGE In this lecture we review Maximum Coverage and Unique
Aside: Golden Ratio. Golden Ratio: A universal law. Golden ratio φ = lim n = 1+ b n = a n 1. a n+1 = a n + b n, a n+b n a n
Aside: Golden Ratio Golden Ratio: A universal law. Golden ratio φ = lim n a n+b n a n = 1+ 5 2 a n+1 = a n + b n, b n = a n 1 Ruta (UIUC) CS473 1 Spring 2018 1 / 41 CS 473: Algorithms, Spring 2018 Dynamic
CS 374: Algorithms & Models of Computation, Spring 2017 Greedy Algorithms Lecture 19 April 4, 2017 Chandra Chekuri (UIUC) CS374 1 Spring / 1
CS 374: Algorithms & Models of Computation, Spring 2017 Greedy Algorithms Lecture 19 April 4, 2017 Chandra Chekuri (UIUC) CS374 1 Spring 2017 1 / 1 Part I Greedy Algorithms: Tools and Techniques Chandra
1 Ordinary Load Balancing
Comp 260: Advanced Algorithms Prof. Lenore Cowen Tufts University, Spring 208 Scribe: Emily Davis Lecture 8: Scheduling Ordinary Load Balancing Suppose we have a set of jobs each with their own finite
SAT, NP, NP-Completeness
CS 473: Algorithms, Spring 2018 SAT, NP, NP-Completeness Lecture 22 April 13, 2018 Most slides are courtesy Prof. Chekuri Ruta (UIUC) CS473 1 Spring 2018 1 / 57 Part I Reductions Continued Ruta (UIUC)
Bin packing and scheduling
Sanders/van Stee: Approximations- und Online-Algorithmen 1 Bin packing and scheduling Overview Bin packing: problem definition Simple 2-approximation (Next Fit) Better than 3/2 is not possible Asymptotic
Partition is reducible to P2 C max. c. P2 Pj = 1, prec Cmax is solvable in polynomial time. P Pj = 1, prec Cmax is NP-hard
I. Minimizing Cmax (Nonpreemptive) a. P2 C max is NP-hard. Partition is reducible to P2 C max b. P Pj = 1, intree Cmax P Pj = 1, outtree Cmax are both solvable in polynomial time. c. P2 Pj = 1, prec Cmax
Lecture 11 October 7, 2013
CS 4: Advanced Algorithms Fall 03 Prof. Jelani Nelson Lecture October 7, 03 Scribe: David Ding Overview In the last lecture we talked about set cover: Sets S,..., S m {,..., n}. S has cost c S. Goal: Cover
Chapter 11. Approximation Algorithms. Slides by Kevin Wayne Pearson-Addison Wesley. All rights reserved.
Chapter 11 Approximation Algorithms Slides by Kevin Wayne. Copyright @ 2005 Pearson-Addison Wesley. All rights reserved. 1 Approximation Algorithms Q. Suppose I need to solve an NP-hard problem. What should
More NP-Complete Problems
CS 473: Algorithms, Spring 2018 More NP-Complete Problems Lecture 23 April 17, 2018 Most slides are courtesy Prof. Chekuri Ruta (UIUC) CS473 1 Spring 2018 1 / 57 Recap NP: languages/problems that have
Aditya Bhaskara CS 5968/6968, Lecture 1: Introduction and Review 12 January 2016
Lecture 1: Introduction and Review We begin with a short introduction to the course, and logistics. We then survey some basics about approximation algorithms and probability. We also introduce some of
1 Submodular functions
CS 369P: Polyhedral techniques in combinatorial optimization Instructor: Jan Vondrák Lecture date: November 16, 2010 1 Submodular functions We have already encountered submodular functions. Let s recall
COSC 341: Lecture 25 Coping with NP-hardness (2)
1 Introduction Figure 1: Famous cartoon by Garey and Johnson, 1979 We have seen the definition of a constant factor approximation algorithm. The following is something even better. 2 Approximation Schemes
APTAS for Bin Packing
APTAS for Bin Packing Bin Packing has an asymptotic PTAS (APTAS) [de la Vega and Leuker, 1980] For every fixed ε > 0 algorithm outputs a solution of size (1+ε)OPT + 1 in time polynomial in n APTAS for
ABHELSINKI UNIVERSITY OF TECHNOLOGY
Approximation Algorithms Seminar 1 Set Cover, Steiner Tree and TSP Siert Wieringa siert.wieringa@tkk.fi Approximation Algorithms Seminar 1 1/27 Contents Approximation algorithms for: Set Cover Steiner
Discrete Optimization 2010 Lecture 2 Matroids & Shortest Paths
Matroids Shortest Paths Discrete Optimization 2010 Lecture 2 Matroids & Shortest Paths Marc Uetz University of Twente m.uetz@utwente.nl Lecture 2: sheet 1 / 25 Marc Uetz Discrete Optimization Matroids
CSE541 Class 22. Jeremy Buhler. November 22, Today: how to generalize some well-known approximation results
CSE541 Class 22 Jeremy Buhler November 22, 2016 Today: how to generalize some well-known approximation results 1 Intuition: Behavior of Functions Consider a real-valued function gz) on integers or reals).
P C max. NP-complete from partition. Example j p j What is the makespan on 2 machines? 3 machines? 4 machines?
Multiple Machines Model Multiple Available resources people time slots queues networks of computers Now concerned with both allocation to a machine and ordering on that machine. P C max NP-complete from
Linear Programming. Scheduling problems
Linear Programming Scheduling problems Linear programming (LP) ( )., 1, for 0 min 1 1 1 1 1 11 1 1 n i x b x a x a b x a x a x c x c x z i m n mn m n n n n! = + + + + + + = Extreme points x ={x 1,,x n
Dynamic Programming( Weighted Interval Scheduling)
Dynamic Programming( Weighted Interval Scheduling) 17 November, 2016 Dynamic Programming 1 Dynamic programming algorithms are used for optimization (for example, finding the shortest path between two points,
Approximation Algorithms
Approximation Algorithms What do you do when a problem is NP-complete? or, when the polynomial time solution is impractically slow? assume input is random, do expected performance. Eg, Hamiltonian path
CS264: Beyond Worst-Case Analysis Lecture #18: Smoothed Complexity and Pseudopolynomial-Time Algorithms
CS264: Beyond Worst-Case Analysis Lecture #18: Smoothed Complexity and Pseudopolynomial-Time Algorithms Tim Roughgarden March 9, 2017 1 Preamble Our first lecture on smoothed analysis sought a better theoretical
CS264: Beyond Worst-Case Analysis Lecture #15: Smoothed Complexity and Pseudopolynomial-Time Algorithms
CS264: Beyond Worst-Case Analysis Lecture #15: Smoothed Complexity and Pseudopolynomial-Time Algorithms Tim Roughgarden November 5, 2014 1 Preamble Previous lectures on smoothed analysis sought a better
Algorithms. Outline! Approximation Algorithms. The class APX. The intelligence behind the hardware. ! Based on
6117CIT - Adv Topics in Computing Sci at Nathan 1 Algorithms The intelligence behind the hardware Outline! Approximation Algorithms The class APX! Some complexity classes, like PTAS and FPTAS! Illustration
Lecture 20: LP Relaxation and Approximation Algorithms. 1 Introduction. 2 Vertex Cover problem. CSCI-B609: A Theorist s Toolkit, Fall 2016 Nov 8
CSCI-B609: A Theorist s Toolkit, Fall 2016 Nov 8 Lecture 20: LP Relaxation and Approximation Algorithms Lecturer: Yuan Zhou Scribe: Syed Mahbub Hafiz 1 Introduction When variables of constraints of an
CS 580: Algorithm Design and Analysis. Jeremiah Blocki Purdue University Spring 2018
CS 580: Algorithm Design and Analysis Jeremiah Blocki Purdue University Spring 2018 Chapter 9 PSPACE: A Class of Problems Beyond NP Slides by Kevin Wayne. Copyright @ 2005 Pearson-Addison Wesley. All rights
CS 6901 (Applied Algorithms) Lecture 3
CS 6901 (Applied Algorithms) Lecture 3 Antonina Kolokolova September 16, 2014 1 Representative problems: brief overview In this lecture we will look at several problems which, although look somewhat similar
9. Submodular function optimization
Submodular function maximization 9-9. Submodular function optimization Submodular function maximization Greedy algorithm for monotone case Influence maximization Greedy algorithm for non-monotone case
Chapter 11. Approximation Algorithms. Slides by Kevin Wayne Pearson-Addison Wesley. All rights reserved.
Chapter 11 Approximation Algorithms Slides by Kevin Wayne. Copyright @ 2005 Pearson-Addison Wesley. All rights reserved. 1 P and NP P: The family of problems that can be solved quickly in polynomial time.
Topic: Intro, Vertex Cover, TSP, Steiner Tree Date: 1/23/2007
CS880: Approximations Algorithms Scribe: Michael Kowalczyk Lecturer: Shuchi Chawla Topic: Intro, Vertex Cover, TSP, Steiner Tree Date: 1/23/2007 Today we discuss the background and motivation behind studying
a 1 a 2 a 3 a 4 v i c i c(a 1, a 3 ) = 3
AM 221: Advanced Optimization Spring 2016 Prof. Yaron Singer Lecture 17 March 30th 1 Overview In the previous lecture, we saw examples of combinatorial problems: the Maximal Matching problem and the Minimum
1 The Knapsack Problem
Comp 260: Advanced Algorithms Prof. Lenore Cowen Tufts University, Spring 2018 Scribe: Tom Magerlein 1 Lecture 4: The Knapsack Problem 1 The Knapsack Problem Suppose we are trying to burgle someone s house.
immediately, without knowledge of the jobs that arrive later The jobs cannot be preempted, ie, once a job is scheduled (assigned to a machine), it can
A Lower Bound for Randomized On-Line Multiprocessor Scheduling Jir Sgall Abstract We signicantly improve the previous lower bounds on the performance of randomized algorithms for on-line scheduling jobs
On Two Class-Constrained Versions of the Multiple Knapsack Problem
On Two Class-Constrained Versions of the Multiple Knapsack Problem Hadas Shachnai Tami Tamir Department of Computer Science The Technion, Haifa 32000, Israel Abstract We study two variants of the classic
CS 6783 (Applied Algorithms) Lecture 3
CS 6783 (Applied Algorithms) Lecture 3 Antonina Kolokolova January 14, 2013 1 Representative problems: brief overview of the course In this lecture we will look at several problems which, although look
Algorithms Design & Analysis. Approximation Algorithm
Algorithms Design & Analysis Approximation Algorithm Recap External memory model Merge sort Distribution sort 2 Today s Topics Hard problem Approximation algorithms Metric traveling salesman problem A
Lecture 4 Scheduling 1
Lecture 4 Scheduling 1 Single machine models: Number of Tardy Jobs -1- Problem 1 U j : Structure of an optimal schedule: set S 1 of jobs meeting their due dates set S 2 of jobs being late jobs of S 1 are
Solutions to Exercises
1/13 Solutions to Exercises The exercises referred to as WS 1.1(a), and so forth, are from the course book: Williamson and Shmoys, The Design of Approximation Algorithms, Cambridge University Press, 2011,
CSE101: Design and Analysis of Algorithms. Ragesh Jaiswal, CSE, UCSD
Course Overview Material that will be covered in the course: Basic graph algorithms Algorithm Design Techniques Greedy Algorithms Divide and Conquer Dynamic Programming Network Flows Computational intractability
CS 161: Design and Analysis of Algorithms
CS 161: Design and Analysis of Algorithms Greedy Algorithms 3: Minimum Spanning Trees/Scheduling Disjoint Sets, continued Analysis of Kruskal s Algorithm Interval Scheduling Disjoint Sets, Continued Each
Introduction to Computer Science and Programming for Astronomers
Introduction to Computer Science and Programming for Astronomers Lecture 8. István Szapudi Institute for Astronomy University of Hawaii March 7, 2018 Outline Reminder 1 Reminder 2 3 4 Reminder We have
Santa Claus Schedules Jobs on Unrelated Machines
Santa Claus Schedules Jobs on Unrelated Machines Ola Svensson (osven@kth.se) Royal Institute of Technology - KTH Stockholm, Sweden March 22, 2011 arxiv:1011.1168v2 [cs.ds] 21 Mar 2011 Abstract One of the
NP and NP Completeness
CS 374: Algorithms & Models of Computation, Spring 2017 NP and NP Completeness Lecture 23 April 20, 2017 Chandra Chekuri (UIUC) CS374 1 Spring 2017 1 / 44 Part I NP Chandra Chekuri (UIUC) CS374 2 Spring
LPT rule: Whenever a machine becomes free for assignment, assign that job whose. processing time is the largest among those jobs not yet assigned.
LPT rule Whenever a machine becomes free for assignment, assign that job whose processing time is the largest among those jobs not yet assigned. Example m1 m2 m3 J3 Ji J1 J2 J3 J4 J5 J6 6 5 3 3 2 1 3 5
CO759: Algorithmic Game Theory Spring 2015
CO759: Algorithmic Game Theory Spring 2015 Instructor: Chaitanya Swamy Assignment 1 Due: By Jun 25, 2015 You may use anything proved in class directly. I will maintain a FAQ about the assignment on the
Knapsack and Scheduling Problems. The Greedy Method
The Greedy Method: Knapsack and Scheduling Problems The Greedy Method 1 Outline and Reading Task Scheduling Fractional Knapsack Problem The Greedy Method 2 Elements of Greedy Strategy An greedy algorithm
Symmetry and hardness of submodular maximization problems
Symmetry and hardness of submodular maximization problems Jan Vondrák 1 1 Department of Mathematics Princeton University Jan Vondrák (Princeton University) Symmetry and hardness 1 / 25 Submodularity Definition
CSE 421 Greedy Algorithms / Interval Scheduling
CSE 421 Greedy Algorithms / Interval Scheduling Yin Tat Lee 1 Interval Scheduling Job j starts at s(j) and finishes at f(j). Two jobs compatible if they don t overlap. Goal: find maximum subset of mutually
Dynamic Programming: Shortest Paths and DFA to Reg Exps
CS 374: Algorithms & Models of Computation, Spring 207 Dynamic Programming: Shortest Paths and DFA to Reg Exps Lecture 8 March 28, 207 Chandra Chekuri (UIUC) CS374 Spring 207 / 56 Part I Shortest Paths
Lecture 4 : Quest for Structure in Counting Problems
CS6840: Advanced Complexity Theory Jan 10, 2012 Lecture 4 : Quest for Structure in Counting Problems Lecturer: Jayalal Sarma M.N. Scribe: Dinesh K. Theme: Between P and PSPACE. Lecture Plan:Counting problems
8 Knapsack Problem 8.1 (Knapsack)
8 Knapsack In Chapter 1 we mentioned that some NP-hard optimization problems allow approximability to any required degree. In this chapter, we will formalize this notion and will show that the knapsack
Deterministic Finite Automata (DFAs)
CS/ECE 374: Algorithms & Models of Computation, Fall 28 Deterministic Finite Automata (DFAs) Lecture 3 September 4, 28 Chandra Chekuri (UIUC) CS/ECE 374 Fall 28 / 33 Part I DFA Introduction Chandra Chekuri
CS 473: Algorithms. Ruta Mehta. Spring University of Illinois, Urbana-Champaign. Ruta (UIUC) CS473 1 Spring / 32
CS 473: Algorithms Ruta Mehta University of Illinois, Urbana-Champaign Spring 2018 Ruta (UIUC) CS473 1 Spring 2018 1 / 32 CS 473: Algorithms, Spring 2018 Universal Hashing Lecture 10 Feb 15, 2018 Most
/633 Introduction to Algorithms Lecturer: Michael Dinitz Topic: Matroids and Greedy Algorithms Date: 10/31/16
60.433/633 Introduction to Algorithms Lecturer: Michael Dinitz Topic: Matroids and Greedy Algorithms Date: 0/3/6 6. Introduction We talked a lot the last lecture about greedy algorithms. While both Prim
CS224W: Social and Information Network Analysis Jure Leskovec, Stanford University
CS224W: Social and Information Network Analysis Jure Leskovec, Stanford University http://cs224w.stanford.edu Find most influential set S of size k: largest expected cascade size f(s) if set S is activated
Algorithms Exam TIN093 /DIT602
Algorithms Exam TIN093 /DIT602 Course: Algorithms Course code: TIN 093, TIN 092 (CTH), DIT 602 (GU) Date, time: 21st October 2017, 14:00 18:00 Building: SBM Responsible teacher: Peter Damaschke, Tel. 5405
Automata Theory. Lecture on Discussion Course of CS120. Runzhe SJTU ACM CLASS
Automata Theory Lecture on Discussion Course of CS2 This Lecture is about Mathematical Models of Computation. Why Should I Care? - Ways of thinking. - Theory can drive practice. - Don t be an Instrumentalist.
Greedy Algorithms. CSE 101: Design and Analysis of Algorithms Lecture 9
Greedy Algorithms CSE 101: Design and Analysis of Algorithms Lecture 9 CSE 101: Design and analysis of algorithms Greedy algorithms Reading: Kleinberg and Tardos, sections 4.1, 4.2, and 4.3 Homework 4
Lecture 5. Shearer s Lemma
Stanford University Spring 2016 Math 233: Non-constructive methods in combinatorics Instructor: Jan Vondrák Lecture date: April 6, 2016 Scribe: László Miklós Lovász Lecture 5. Shearer s Lemma 5.1 Introduction
1 Perfect Matching and Matching Polytopes
CS 598CSC: Combinatorial Optimization Lecture date: /16/009 Instructor: Chandra Chekuri Scribe: Vivek Srikumar 1 Perfect Matching and Matching Polytopes Let G = (V, E be a graph. For a set E E, let χ E
Deterministic Finite Automata (DFAs)
Algorithms & Models of Computation CS/ECE 374, Spring 29 Deterministic Finite Automata (DFAs) Lecture 3 Tuesday, January 22, 29 L A TEXed: December 27, 28 8:25 Chan, Har-Peled, Hassanieh (UIUC) CS374 Spring
1 Basic Definitions. 2 Proof By Contradiction. 3 Exchange Argument
1 Basic Definitions A Problem is a relation from input to acceptable output. For example, INPUT: A list of integers x 1,..., x n OUTPUT: One of the three smallest numbers in the list An algorithm A solves
Approximation Basics
Approximation Basics, Concepts, and Examples Xiaofeng Gao Department of Computer Science and Engineering Shanghai Jiao Tong University, P.R.China Fall 2012 Special thanks is given to Dr. Guoqiang Li for
Knapsack. Bag/knapsack of integer capacity B n items item i has size s i and profit/weight w i
Knapsack Bag/knapsack of integer capacity B n items item i has size s i and profit/weight w i Goal: find a subset of items of maximum profit such that the item subset fits in the bag Knapsack X: item set
Monotone Submodular Maximization over a Matroid
Monotone Submodular Maximization over a Matroid Yuval Filmus January 31, 2013 Abstract In this talk, we survey some recent results on monotone submodular maximization over a matroid. The survey does not
U.C. Berkeley CS294: Beyond Worst-Case Analysis Handout 2 Luca Trevisan August 29, 2017
U.C. Berkeley CS94: Beyond Worst-Case Analysis Handout Luca Trevisan August 9, 07 Scribe: Mahshid Montazer Lecture In this lecture, we study the Max Cut problem in random graphs. We compute the probable
NP-Completeness. Andreas Klappenecker. [based on slides by Prof. Welch]
![NP-Completeness. Andreas Klappenecker. [based on slides by Prof. Welch]](/thumbs/79/79291182.jpg "NP-Completeness. Andreas Klappenecker. [based on slides by Prof. Welch]")
NP-Completeness Andreas Klappenecker [based on slides by Prof. Welch] 1 Prelude: Informal Discussion (Incidentally, we will never get very formal in this course) 2 Polynomial Time Algorithms Most of the
An Algorithmic Proof of the Lopsided Lovász Local Lemma (simplified and condensed into lecture notes)
An Algorithmic Proof of the Lopsided Lovász Local Lemma (simplified and condensed into lecture notes) Nicholas J. A. Harvey University of British Columbia Vancouver, Canada nickhar@cs.ubc.ca Jan Vondrák
K-center Hardness and Max-Coverage (Greedy)
IOE 691: Approximation Algorithms Date: 01/11/2017 Lecture Notes: -center Hardness and Max-Coverage (Greedy) Instructor: Viswanath Nagarajan Scribe: Sentao Miao 1 Overview In this lecture, we will talk
Final exam study sheet for CS3719 Turing machines and decidability.
Final exam study sheet for CS3719 Turing machines and decidability. A Turing machine is a finite automaton with an infinite memory (tape). Formally, a Turing machine is a 6-tuple M = (Q, Σ, Γ, δ, q 0,
Deterministic Finite Automata (DFAs)
Algorithms & Models of Computation CS/ECE 374, Fall 27 Deterministic Finite Automata (DFAs) Lecture 3 Tuesday, September 5, 27 Sariel Har-Peled (UIUC) CS374 Fall 27 / 36 Part I DFA Introduction Sariel
CSE101: Design and Analysis of Algorithms. Ragesh Jaiswal, CSE, UCSD
Greedy s Greedy s Shortest path Claim 2: Let S be a subset of vertices containing s such that we know the shortest path length l(s, u) from s to any vertex in u S. Let e = (u, v) be an edge such that 1
Welfare Maximization with Friends-of-Friends Network Externalities
Welfare Maximization with Friends-of-Friends Network Externalities Extended version of a talk at STACS 2015, Munich Wolfgang Dvořák 1 joint work with: Sayan Bhattacharya 2, Monika Henzinger 1, Martin Starnberger
A lower bound for scheduling of unit jobs with immediate decision on parallel machines
A lower bound for scheduling of unit jobs with immediate decision on parallel machines Tomáš Ebenlendr Jiří Sgall Abstract Consider scheduling of unit jobs with release times and deadlines on m identical
Lecture 2: Scheduling on Parallel Machines
Lecture 2: Scheduling on Parallel Machines Loris Marchal October 17, 2012 Parallel environment alpha in Graham s notation): P parallel identical Q uniform machines: each machine has a given speed speed
Announcements. CompSci 102 Discrete Math for Computer Science. Chap. 3.1 Algorithms. Specifying Algorithms
CompSci 102 Discrete Math for Computer Science Announcements Read for next time Chap. 3.1-3.3 Homework 3 due Tuesday We ll finish Chapter 2 first today February 7, 2012 Prof. Rodger Chap. 3.1 Algorithms
More Dynamic Programming
CS 374: Algorithms & Models of Computation, Spring 2017 More Dynamic Programming Lecture 14 March 9, 2017 Chandra Chekuri (UIUC) CS374 1 Spring 2017 1 / 42 What is the running time of the following? Consider
We say that a flow is feasible for G (or just feasible if the graph and capacity function in question are obvious) if
CS787: Advanced Algorithms Lecture 4: Network Flow We devote this lecture to the network flow problem and the max-flow min-cut theorem. A number of other problems can be cast into a maximum flow or minimum
Lecture 13 March 7, 2017
CS 224: Advanced Algorithms Spring 2017 Prof. Jelani Nelson Lecture 13 March 7, 2017 Scribe: Hongyao Ma Today PTAS/FPTAS/FPRAS examples PTAS: knapsack FPTAS: knapsack FPRAS: DNF counting Approximation
Chapter 2. Reductions and NP. 2.1 Reductions Continued The Satisfiability Problem (SAT) SAT 3SAT. CS 573: Algorithms, Fall 2013 August 29, 2013
Chapter 2 Reductions and NP CS 573: Algorithms, Fall 2013 August 29, 2013 2.1 Reductions Continued 2.1.1 The Satisfiability Problem SAT 2.1.1.1 Propositional Formulas Definition 2.1.1. Consider a set of
An Approximate Pareto Set for Minimizing the Maximum Lateness and Makespan on Parallel Machines
1 An Approximate Pareto Set for Minimizing the Maximum Lateness Makespan on Parallel Machines Gais Alhadi 1, Imed Kacem 2, Pierre Laroche 3, Izzeldin M. Osman 4 arxiv:1802.10488v1 [cs.ds] 28 Feb 2018 Abstract
The 2-valued case of makespan minimization with assignment constraints
The 2-valued case of maespan minimization with assignment constraints Stavros G. Kolliopoulos Yannis Moysoglou Abstract We consider the following special case of minimizing maespan. A set of jobs J and
BBM402-Lecture 20: LP Duality
BBM402-Lecture 20: LP Duality Lecturer: Lale Özkahya Resources for the presentation: https://courses.engr.illinois.edu/cs473/fa2016/lectures.html An easy LP? which is compact form for max cx subject to
Methods for finding optimal configurations
CS 1571 Introduction to AI Lecture 9 Methods for finding optimal configurations Milos Hauskrecht milos@cs.pitt.edu 5329 Sennott Square Search for the optimal configuration Optimal configuration search:
Notes for Lecture 11
Stanford University CS254: Computational Complexity Notes 11 Luca Trevisan 2/11/2014 Notes for Lecture 11 Circuit Lower Bounds for Parity Using Polynomials In this lecture we prove a lower bound on the
Lecture 10: Mechanisms, Complexity, and Approximation
CS94 P9: Topics Algorithmic Game Theory November 8, 011 Lecture 10: Mechanisms, Complexity, and Approximation Lecturer: Christos Papadimitriou Scribe: Faraz Tavakoli It is possible to characterize a Mechanism
Operations and Supply Chain Management Prof. G. Srinivasan Department of Management Studies Indian Institute of Technology, Madras
Operations and Supply Chain Management Prof. G. Srinivasan Department of Management Studies Indian Institute of Technology, Madras Lecture - 27 Flow Shop Scheduling - Heuristics - Palmer, Campbell Dudek
Algorithms. NP -Complete Problems. Dong Kyue Kim Hanyang University
Algorithms NP -Complete Problems Dong Kyue Kim Hanyang University dqkim@hanyang.ac.kr The Class P Definition 13.2 Polynomially bounded An algorithm is said to be polynomially bounded if its worst-case
Approximating Submodular Functions. Nick Harvey University of British Columbia
Approximating Submodular Functions Nick Harvey University of British Columbia Approximating Submodular Functions Part 1 Nick Harvey University of British Columbia Department of Computer Science July 11th,
Topics in Theoretical Computer Science April 08, Lecture 8
Topics in Theoretical Computer Science April 08, 204 Lecture 8 Lecturer: Ola Svensson Scribes: David Leydier and Samuel Grütter Introduction In this lecture we will introduce Linear Programming. It was
Dual fitting approximation for Set Cover, and Primal Dual approximation for Set Cover
duality 1 Dual fitting approximation for Set Cover, and Primal Dual approximation for Set Cover Guy Kortsarz duality 2 The set cover problem with uniform costs Input: A universe U and a collection of subsets
Optimization of Submodular Functions Tutorial - lecture I
Optimization of Submodular Functions Tutorial - lecture I Jan Vondrák 1 1 IBM Almaden Research Center San Jose, CA Jan Vondrák (IBM Almaden) Submodular Optimization Tutorial 1 / 1 Lecture I: outline 1
HW Graph Theory SOLUTIONS (hbovik) - Q
1, Diestel 3.5: Deduce the k = 2 case of Menger s theorem (3.3.1) from Proposition 3.1.1. Let G be 2-connected, and let A and B be 2-sets. We handle some special cases (thus later in the induction if these
Maximum Coverage over a Matroid Constraint
Maximum Coverage over a Matroid Constraint Yuval Filmus Justin Ward University of Toronto STACS 2012, Paris Max Coverage: History Location of bank accounts: Cornuejols, Fisher & Nemhauser 1977, Management
1 Maximizing a Submodular Function
6.883 Learning with Combinatorial Structure Notes for Lecture 16 Author: Arpit Agarwal 1 Maximizing a Submodular Function In the last lecture we looked at maximization of a monotone submodular function,
1 Introduction (January 21)
CS 97: Concrete Models of Computation Spring Introduction (January ). Deterministic Complexity Consider a monotonically nondecreasing function f : {,,..., n} {, }, where f() = and f(n) =. We call f a step
Efficient Approximation for Restricted Biclique Cover Problems
algorithms Article Efficient Approximation for Restricted Biclique Cover Problems Alessandro Epasto 1, *, and Eli Upfal 2 ID 1 Google Research, New York, NY 10011, USA 2 Department of Computer Science,
Algorithm Design and Analysis
Algorithm Design and Analysis LECTURE 6 Greedy Algorithms Interval Scheduling Interval Partitioning Scheduling to Minimize Lateness Sofya Raskhodnikova S. Raskhodnikova; based on slides by E. Demaine,