# A Unified Approach to Approximating Resource Allocation and Scheduling by yurtgc548

VIEWS: 10 PAGES: 28

• pg 1
```									                                            www.cs.technion.ac.il/~reuven   1

Approximation Algorithms for
Bandwidth and Storage Allocation

Reuven Bar-Yehuda

Joint work with
Michael Beder, Yuval Cohen and Dror Rawitz
Technion IIT

Slides and paper at:
http://www.cs.technion.ac.il/~reuven
www.cs.technion.ac.il/~reuven   2

The Local-Ratio Technique:
Basic definitions

Given a profit [penalty] vector p.

Maximize[Minimize]         p·x

Subject to:                feasibility constraints F(x)

x is r-approximation if F(x) and p·x [] r · p·x*

An algorithm is r-approximation if for any p, F
it returns an r-approximation
www.cs.technion.ac.il/~reuven   3

The Local-Ratio Theorem:

x is an r-approximation with respect to p1
x is an r-approximation with respect to p- p1   

x is an r-approximation with respect to p

Proof: (For maximization)
p1 · x  r × p1*
p2 · x  r × p2*

p · x  r × ( p1*+ p2*)
 r × ( p1 + p2 )*
www.cs.technion.ac.il/~reuven   4

Special case: Optimization is 1-approximation

x is an optimum with respect to p1
x is an optimum with respect to p- p1   
x is an optimum with respect to p
www.cs.technion.ac.il/~reuven   5
A Local-Ratio Schema for
Maximization[Minimization] problems:

Algorithm r-ApproxMax[Min]( Set, p )

If Set = Φ then return Φ ;
If  I  Set p(I)  0 then return r-ApproxMax( Set-{I}, p ) ;
[If I  Set p(I)=0 then return {I}  r-ApproxMin( Set-{I}, p ) ;]

Define “good” p1 ;

REC = r-ApproxMax[Min]( S, p- p1 ) ;
If REC is not an r-approximation w.r.t. p1 then “fix it”;
return REC;
www.cs.technion.ac.il/~reuven   6

The Local-Ratio Theorem: Applications

Applications to some optimization algorithms (r = 1):
( MST) Minimum Spanning Tree (Kruskal)
( SHORTEST-PATH) s-t Shortest Path (Dijkstra)
(LONGEST-PATH) s-t DAG Longest Path (Can be done with dynamic programming)
(INTERVAL-IS) Independents-Set in Interval Graphs Usually done with dynamic programming)
(LONG-SEQ) Longest (weighted) monotone subsequence (Can be done with dynamic programming)
( MIN_CUT) Minimum Capacity s,t Cut (e.g. Ford, Dinitz)
Applications to some 2-Approximation algorithms: (r = 2)
( VC) Minimum Vertex Cover (Bar-Yehuda and Even)
( FVS) Vertex Feedback Set (Becker and Geiger)
( GSF) Generalized Steiner Forest (Williamson, Goemans, Mihail, and Vazirani)
( Min 2SAT) Minimum Two-Satisfibility (Gusfield and Pitt)
( 2VIP) Two Variable Integer Programming (Bar-Yehuda and Rawitz)
( PVC) Partial Vertex Cover (Bar-Yehuda)
( GVC) Generalized Vertex Cover (Bar-Yehuda and Rawitz)
Applications to some other Approximations:
( SC) Minimum Set Cover (Bar-Yehuda and Even)
( PSC) Partial Set Cover (Bar-Yehuda)
( MSP) Maximum Set Packing (Arkin and Hasin)

Applications Resource Allocation and Scheduling :
….
www.cs.technion.ac.il/~reuven   7

Maximum Independent Set in Interval Graphs

time

Maximize
 p( I )  x
I
I
s.t.   For each instance I:        xI {0,1}

For each time t:          x          I
I :s ( I ) t  e ( I )
1
www.cs.technion.ac.il/~reuven   8
Maximum Independent Set in Interval Graphs:
How to select P1 to get optimization?

P1=0
P1=1
P1=0
P1=0
P1=0
P1=1
P1=0
P1=1
P1=1
Î
time
Let Î be an interval that ends first;
1      if I in conflict with Î
For all intervals I define: p1 (I) =
0 else
For every feasible          x:       p1 ·x      1
Every Î-maximal is optimal.
For every Î-maximal x:           p1 ·x          1
www.cs.technion.ac.il/~reuven   9
Maximum Independent Set in Interval Graphs:
An Optimization Algorithm

P1=P(Î   )
Activity9
P1=0
Activity8
P1=0
Activity7
P1=0
Activity6
P1=0
Activity5    P1=P(Î      )
Activity4                                             P1=0
Activity3    P1=P(Î      )
Activity2
P1=P(Î      )
Activity1                    Î
time
Algorithm MaxIS( S, p )
If S = Φ then return Φ ;
If I  S p(I) 0 then return MaxIS( S - {I}, p);
Let Î  S that ends first;
I  S define: p1 (I) = p(Î)  (I in conflict with Î) ;
IS = MaxIS( S, p- p1 ) ;
If IS is Î-maximal then return IS else return IS  {Î};
www.cs.technion.ac.il/~reuven   10

Maximum Independent Set in Interval Graphs:
Running Example

P(I5) = 3        -4
P(I6) = 6        -4         -2
P(I3) = 5   -5
P(I2) = 3   -5
P(I1) = 5   -5
P(I4) = 9   -5   -4

-5                    -4          -2
www.cs.technion.ac.il/~reuven   11

Bandwidth Allocation Problem (BAP)

banwith

I    w(I)
s(I)           e(I)                                                                                  time

Maximize
 p( I )  x
I
I
s.t.   For each instance I:            xI {0,1}

For each time t:               w( I )  x
I :s ( I ) t  e ( I )
I   1
www.cs.technion.ac.il/~reuven   12

Bandwidth Allocation Problem (BAP)

1987 Arkin and Silverberg: requests have same duration.
2000 Philips Uma Wein: 6
2001 Bar-Noy Bar-Yehuda Freund Naor Schieber: 3
2002 Chen Hassin Tzur: DP for restricted case.
2002 Calinescu, Chakrabarti, Karloff, Rabani: 2 Randomized
Also dynamic programming
2003 Chekuri, Maydlarz, Shepherd: Extentions (e.g. trees)

2005 This talk:  2+1/(e-1)    2.582
www.cs.technion.ac.il/~reuven   13

Bandwidth Allocation for w  1/2
How to select P1 to get 1/3-approximation?

Î

I    w(I)
s(I)       e(I)                                                                time
1      if I = Î
For all intervals I define: p1 (I) =        2*w(I) if I is in conflict with Î
0      else

For every feasible           x: p1 ·x  1+2*1
 Every Î-maximal is 1/3-approximation
For every Î-maximal x: p1 ·x           1
www.cs.technion.ac.il/~reuven   14

Bandwidth Allocation for w  1/2
… A better P1 to get 1/2-approximation?

Î

I    w(I)
s(I)       e(I)                                                           time
1         if I = Î
For all intervals I define: p1 (I) =   w(I)/Ŵ if I is in conflict with Î
0      else
Where Ŵ=1- w(Î)
 feasible        x: p1 ·x  max{ 1+ Ŵ /Ŵ , 1 /Ŵ }
 Î -maximal is 1/2-approximation
 Î-maximal x: p1 ·x  min{1, Ŵ /Ŵ}
www.cs.technion.ac.il/~reuven   15

Bandwidth Allocation:
1/3-approximation in O(nlogn) time

w>½
w>½           w>½

w>½

w>½     w>½

w>½                      w>½    w>½

Algorithm:
1. GRAY         = Find 1-approximation for gray (w>1/2) intervals;
2. COLORED = Find 1/2-approximation for colored intervals
3. Return the one with the larger profit
Analysis:
If GRAY*  33%OPT then GRAY                1*(33%OPT)=33%OPT else
COLORED*  66%OPT thus COLORED  1/2(66%OPT)=33%OPT
www.cs.technion.ac.il/~reuven   16

Bandwidth Allocation: What if we get
R-approx for w >    and r-approx for w ≤  ?

w>
w>           w>

w>

w>   w>

w>                      w>    w>

Algorithm:
1. GRAY         = Find R-approximation for gray (w>) intervals;
2. COLORED = Find r-approximation for colored intervals
3. Return the one with the larger profit
Analysis:
If GRAY*  r/(R+r)×OPT then GRAY               R× r/(R+r)×OPT else
COLORED* R/(R+r)×OPT thus COLORED  r× R/(R+r)×OPT
www.cs.technion.ac.il/~reuven   17

Banwidth Allocation: 1-approx for w > 

Algorithm:

2002 Chen Hassin Tzur
2002 Calinescu, Chakrabarti, Karloff, Rabani

Dynamic Programming  R = 1
www.cs.technion.ac.il/~reuven   18

Bandwidth Allocation:  1-1/e-apx for w ≤ 
Let 1/k2 ≥ 
Î

1/k2
1/k

I     w(I)
s(I)       e(I)                                                                     time

1-1/k            if I = Î
For all intervals I define: p1 (I) =       k×w(I) if I is in conflict with Î
0         else
For every 1-feasible          x: p1 ·x  k*1 +1
   1/k-Î-maximal is  k+3-apx
For every 1/k-Î-maximal x: p1 ·x  1-1/k
www.cs.technion.ac.il/~reuven   19

Bandwidth Allocation: 1-1/e-approx for w ≤ 
Algorithm:
Iteratively: Loose 1/k bandwidth and gain 1/(k+3) fraction from the residual opt

Gain ≥ OPT- Leftk >  (1-1/e)×OPT               Leftk ≤ (1-1/(k+3))k ×OPT

Left3 ≤ (1-1/(k+3))3 ×OPT

Gain2 ≥ (1/(k+3)) ×Left1                     Left2 ≤ (1-1/(k+3))2 ×OPT

Gain1 ≥ (1/(k+3)) ×OPT                       Left1 ≤ (1-1/(k+3)) ×OPT
www.cs.technion.ac.il/~reuven   20

Storage Allocation Problem (SAP)
www.cs.technion.ac.il/~reuven   21

Storage Allocation Problem (SAP)

2000 Philips, Uma, Wein: 35
2000 Leonardi, Marchetti-Spaccamela, Vitaletti: 12
2001 Bar-Noy, Bar-Yehuda, Freund, Naor, Schieber: 7
2002 Chen, Hassin, Tzur: DP

2005 This talk:  2+1/(e-1)  2.582
www.cs.technion.ac.il/~reuven   22

Storage Allocation Problem (SAP) for w> 

Let k = 1/    + Gravity  O(nk) possible values for H
 Dynamic programming in polynomial time for constant 

H
www.cs.technion.ac.il/~reuven   23

For w ≤  R-apx for BAP   R-apx for SAP

Dynamic Storage Allocation (DSA) 
Find Min bandwidth with “perfect” SAP allocation
Run BAP (w ≤  )
If Load ≤ 1/3                     // Load = Max total height at time t
use Gergov 99 to get DSA in bandwidth ≤ 1
Else use
2003 Buchsbaum, Karloff, Kenyon, Reingold and Thorup
to get DSA in bandwidth ≤ 1 +O( 1/7)

Corollary: for w ≤  :
 1-apx randomized
 1.582-apx (deterministic and combinatorial)
Corollary: 2 randomized and 2.582 deterministic
www.cs.technion.ac.il/~reuven   24

Bandwidth Allocation on trees.

2003 Chekuri, Maydlarz, Shepherd:
Input: Capacitated tree, where each edge has an integral capacity, and
a set of paths, each of which has an integral demand and a profit.
Solution: A set of paths such that the demands of the paths can be
simultaneously routed without violating edge capacities.
Results:
 4-approx for the case of unit demands.
 48-approx for the case where max(demand) ≤ min(capacity)

Our results:
 We consider the uniform capacities bounded degree case
Note: in this case max(demand) ≤ min(capacity)
 (2+1/(e1/2-1)+)-approx  3.54 -aprox
 (2+1/(e1/d-1)+)-approx
when we are given a set of trees of degree d (instead of paths).
www.cs.technion.ac.il/~reuven   25

Bandwidth Allocation of uniform capacities
general demands trees on trees.
www.cs.technion.ac.il/~reuven   26

Bounded degress trees:
Bandwidth Allocation: 1-approx for w > 

Dynamic Programming  R = 1
Bandwidth Allocation of uniform capacities
www.cs.technion.ac.il/~reuven   27

general demands trees on trees.

1-1/k         if I = Î
For all intervals I define: p1 (I) =     k×w(I) if I is in conflict with Î
0        else
Let 1/k2 ≥ 
For every 1-feasible       x: p1 ·x  k*d +1
1/k-Î-maximal is  d(k+1)-apx
For every 1/k-Î-maximal x: p1 ·x  1-1/k
www.cs.technion.ac.il/~reuven   28

Bandwidth Allocation:  1 1                     d
e -apx for w ≤ 

Algorithm:
Iteratively: Loose 1/k bandwidth and gain 1/(dk+d) fraction from the residual opt

Gain ≥ OPT- Leftk >  (1-e1/d)×OPT              Leftk ≤ (1-1/(dk+d))k ×OPT

Left3 ≤ (1-1/(dk+d))3 ×OPT

Gain2 ≥ (1/(dk+d)) ×Left1                     Left2 ≤ (1-1/(dk+d))2 ×OPT

Gain1 ≥ (1/(dk+d)) ×OPT                       Left1 ≤ (1-1/(dk+d)) ×OPT

```
To top