# soda by niusheng11

VIEWS: 18 PAGES: 28

• pg 1
The Sensor Cover Problem

Alon Efrat (U. Arizona)
Shaili Jain (Harvard)
Suresh Venkatasubramanian (AT&T Labs)
Ke Yi (AT&T Labs)
AT&T Labs                  1
Sensors

   Low-power devices with sensing capabilities
   Sensors monitoring regions

   We would like to cover a given region for as long as
possible
   Since sensors have limited life, we need to schedule
sensor uptime to maximize coverage time
AT&T Labs                    2
Preemptive and Non-preemptive

   Preemptive: Sensors can be turned on and
off multiple times, and the total duration is
constrained by battery
   Non-preemptive: Each sensor can be turned
on only once, and then it runs till death

AT&T Labs                   3
Problem Definition

   A sensor s is defined by a region R(s)  U and a
duration d(s).
   A schedule for a sensor is an assignment of a start
time t(s), so that the sensor is active for all t(s) t
 t(s) + d(s).
   A point x  U is covered at time t if there is some
active sensor s at time t such that x  R(s).

   Problem: Given n sensors defined by (Ri , di), i  [n],
schedule all sensors so that U is covered for all 0 
t  T, and T is maximized.

AT&T Labs                          4
Prior Work

   Previous work assumes that U is an arbitrary
finite set, Ri’s are arbitrary subsets of U, and
di = 1 (Set Cover Packing)
   (log n)-approximation [Feige et al. 02]
   Various heuristics in the networks community

Does geometry help?

AT&T Labs                   5
1-D: Restricted Strip Covering

   Each sensor covers an
interval
   Problem: Slide rectangles
up and down to cover a                    Load L = 5
rectangular area of
maximum height                        3
3
2                 2

3         5
4             5
5                 2
4

AT&T Labs                     6
Restricted Strip Covering: Related Results

   Packing instead of covering: The dynamic
storage allocation problem
   (2+)-approx. [Buchsbaum et al. ’04]
   Further allow rectangles to move both
vertically and horizontally: Strip packing
   (1+)-approx. [Kenyon and Remila ’00]

AT&T Labs             7
Our Results

Sensor shape        Uniform duration          Variable duration

                              
Intervals            Exact in P                  NP-hard
O(log log log n)-approx.
(2+)-approx. for
non-nested intervals
Disks               NP-hard                   NP-hard
O(log(ndmax/L))-approx.      O(log n)-approx.
O(log(Lmax/L))-approx.
when congruent
Arbitrary sets      (log n)-approx.          (log n)-approx.
[Feige et al. ’02]
AT&T Labs                           8
An Easy Start: Uniform Duration

   A greedy algorithm can achieve optimal
solution of duration L

AT&T Labs              9
Variable Durations: NP-hard

O(log n)   O(log log n)       O(log log log n)
2004         2005                 2006

AT&T Labs                      10

   Dynamic programming for small L
   Find the optimal schedule in O(nLO(L)) time
   Poly time for L = O(log n / log log n)
   (1+)-approx. for L < c1dmin log n / log log n
   The “grouping” technique for large L
   (1+)-approx. for L > c2dmax log n
   Combine the two techniques to get an
O(log log log n)-approx. for L in between

AT&T Labs                     11
Dynamic Programming
i=1   i=2

   Check if T is achievable


   Try all T=1,2,…,L
   At any x-coordinate i,
consider all possible
schedules of sensors
…

covering i.
Mark a state “valid” if
 
there is previous
compatible valid state

AT&T Labs               12
Dynamic Programming Analysis
i=1   i=2

   A crude analysis yields
an nO(n) bound
   Observation 1: at most
2T sensors in any state

…
 
   Observation 2: can skip
x-coordinates where
there are >5T sensors
   # states per step:
   total running time is
O(nLO(L)).

AT&T Labs               13
Dynamic Programming Analysis

   An exact solution for L = O(log n / log log n)
   (1+)-approx. for L < c1dmin log n / log log n
(by truncating)
   Replace di by
   New L’ < c1/  ∙ log n / log log n
   Run the dynamic program

AT&T Labs           14

   Dynamic programming for small L
   Solves the problem in O(nLO(L)) time
   (1+)-approx. for L < c1dmin log n / log log n
   The “grouping” technique for large L
   (1+)-approx. for L > c2 / 5 ∙ dmax log n
   Combine the two techniques to get an
O(log log log n)-approx. for L in between

AT&T Labs                     15
The Grouping Algorithm

   Basic idea: group short sensors into longer
sensors, then apply the greedy algorithm

wasted

   Need to bound the amount wasted

AT&T Labs                  16
Grouping Sensors Stabbed by a Common
Anchor

AT&T Labs              17
Grouping Sensors Stabbed by a Common
Anchor

Lnew(x) = Lold(x) / (1+) - 4D/
D: height of new sensors

AT&T Labs                         18
Partitioning

   A -grouping is a partition of sensors into a
number of subsets such that:
   Sensors in a subset are stabbed by a common
anchor
   For any x-coordinate i, the set of sensors live at i
are drawn from no more than  subsets
   Lemma: We can group a set of unit-duration
sensors into sensor with duration D such that
Lnew(x) > Lold(x) / (1+) - O(D / )

AT&T Labs                         19
Partitioning for a Set of Intervals

    = (log n) for a general set of intervals
    = 2 for non-nested intervals

AT&T Labs                 20
The Algorithm

AT&T Labs   21
The Algorithm

   By repeatedly applying the lemma to make all
sensors have equal duration
   Theorem: For sufficiently small positive , there is a
poly-time algorithm that gives a schedule of duration
at least
L/(1 + ) - O(dmax / 4).

   Corollary: There is a constant c2, such that the
algorithm gives a schedule of duration at least L/(1 +
) when L > c2dmax / 5.

AT&T Labs                     22

   Dynamic programming for small L
   Solves the problem in O(nLO(L)) time
   (1+)-approx. for L < c1dmin log n / log log n
   The “grouping” technique for large L
   (1+)-approx. for L > c2dmax / 5        ( =
O(log n))
   Combine the two techniques to get an
O(log log log n)-approx. for L in between

AT&T Labs                     23
Putting Pieces Together
   Consider the case when  = O(1).
   Fix parameter  = 5/(c2). Partition sensors into blue set of
those with duration >L (large) and red set of the rest (small).
   For each x-coordinate, one of the sets has load at least L/2. Use
each set to cover those x-coordinates where it has the load.
   Dynamic programming for the blue set gives solution of duration
L/(2(1 + )).
   Grouping for the red set gives same result.
   Putting solutions together gives a schedule of duration L/(2 +
2).

AT&T Labs                               24
The General Case
   Set h = L log log n / log n; fix parameter l .
   Partition sensors:
 R0 gets large sensors, of duration > h.
 Ri for i = 1, …, l gets middle sensors, of duration  [h/2i, h/2i-1);
truncate to h/2i .
 R +1 gets small sensors, of duration < h/2l = L log log n/(2l log n).

   For each x-coordinate, one of the sets has load at least L/(l + 2).
Use each set to cover those x-coordinate where it has the load.
   Dynamic programming for R0 gives solution of duration
L/((1 + )(l + 2)).
   Greedy on the middle Ri ’s gives solution of duration L/(2(l + 2)).
   Grouping for Rl +1 with  = 1 gives solution of duration

Choose l = O(log log log n)

AT&T Labs                               25
Conclusion and Open Problems

   1D:
   For non-nested intervals, (2 + )-approx.
   General case: O(log log log n)-approx. We
conjecture that constant approx is possible.
   2D:
   O(log(ndmax / L))-approx.
   Not much better than the O(log n)-approx. for the
arbitrary-set version
   Can we improve?

AT&T Labs                       26
More Open Problems

   Preemptive Schedules
   1D: Can be solved exactly using max-flow
   Load = Duration of optimal preemptive schedule
   2D: NP-hard
   No approximation known
   Sensor networks connectivity

AT&T Labs                    27
Thank you!

AT&T Labs   28

To top