Docstoc

A Unified Approach to Approximating Resource Allocation and Scheduling

Document Sample
A Unified Approach to Approximating Resource Allocation and Scheduling Powered By Docstoc
					                                            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

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:10
posted:11/24/2012
language:Unknown
pages:28