1. Algorithms on Minimizing the Maximum Sensor Movement for Barrier Coverage of a Linear Domain
Danny Z. Chen1, Yan Gu2, Jian Li2, and Haitao Wang1
1University of Notre Dame
2Tsinghua University
SWAT 2012

2. Motivation
A sensor has a sensing range r, detecting objects within the range r
a sensor

3. Motivation A region can be protected by sensors
Full coverage of region

4. Motivation Barrier coverage: only covering its border
The border is the barrier
intruder

5. Mobile sensors

6. Our problem: the segment barrier
A barrier B, represented by a line segment, and n sensors on the line containing B
Each sensor has a covering interval
Move the sensors such that
Barrier coverage: the barrier is covered by all sensors
Min-max: the maximum sensor movement is minimized

7. Previous work and our result
The uniform case: covering intervals of all sensors have the same size
O(n2) time, Czyzowicz et al. 09’
Our result: O(nlog n) time
The non-uniform case: different ranges
Open problem: polynomial solvable?
Our result: O(n2 logn) time (a recent result)
O(n2 logn loglogn) time in the paper

8. Related work Min-Sum Min-Number: minimize the number of moving sensors
Uniform: O(n2) time, Czyzowicz et al. 10’
Non-uniform: NP-hard, Czyzowicz et al. 10’
Min-Number: minimize the number of moving sensors
Uniform: O(n3) time, Mehrandish et al. 11’
Non-uniform: NP-hard, Mehrandish et al. 11’

9. The decision versions
Given a value d, determine whether it is possible to cover the barrier such that the maximum sensor movement is at most d
The uniform case
O(n) time, Czyzowicz et al. 09’
The non-uniform case
Our result: O(nlog n) time
Optimization versions: the original problems

10. The uniform case Why is it easier?
The following order preserving property holds
The order of the sensors in an optimal solution is the same as that in the input 4 1 2 3

11. Our algorithm for the uniform case
d* : the maximum sensor movement in an optimal solution
Determine a set D of candidate values, such that
d* is in D and |D|=O(n2)
Determine D implicitly
First attempt: arrange D in a sorted list, and then do binary search using the decision algorithm
Difficulty: It is unclear how to arrange D in a sorted list
Our approach
arrange D in O(n) sorted lists
a technique: binary search on sorted lists

12. The non-uniform case The difficulty The key The decision version
The order preserving property does not hold!!!
The key
Determine the order of sensors in an optimal solution
The decision version
The optimization version
Parameterize the decision algorithm
Similar to parametric search
but no parallel scheme is involved
the algorithm is practical

13. The decision algorithm
Problem: given a value d, determine whether d* ≤ d
A greedy approach
try to cover the barrier from left to right as much as possible
Initially, move each sensor to the right for distance d
Later, we only consider moving sensors to the left for distance at most 2d

14. The decision algorithm
Use a vertical line L sweeping from left to right on B
Each step determines a sensor for covering B from the current position of L to the right as much as possible
The rule:
S1 : the set of intervals intersecting L
If S1 is not empty,
take the interval in S1 with rightmost right endpoint
sweeping line L

15. The decision algorithm
The rule (S1 is empty):
Consider the line L’ with distance 2d right of L
S2 : intervals with left endpoints between L and L’
If S2 is empty, d* ≤ d is not true
Else, take the interval in S2 with the leftmost right endpoint L’
sweeping line L 2d

16. The decision algorithm
The rule (S1 is empty):
Consider the line L’ with distance 2d right of L
S2 : intervals with left endpoints between L and L’
If S2 is empty, d* ≤ d is not true
Else, take the interval in S2 with the leftmost right endpoint L’
sweeping line L

17. The decision algorithm
The rule (S1 is empty):
Consider the line L’ with distance 2d right of L
S2 : intervals with left endpoints between L and L’
If S2 is empty, d* ≤ d is not true
Else, take the interval in S2 with the leftmost right endpoint L’
sweeping line L

18. The algorithm implementation
Running time: O(nlog n)
sweeping
With O(n log n) time preprocessing (sorting)
for each value d,
determine whether d* ≤ d in O(n) time (a recent result)
O(n loglog n) time in the paper

19. The optimization algorithm
Key: find an order for sensors
Every step determines a sensor
by simulating the decision algorithm for d = d*
The i-th step
Input: an interval (xi-1, yi-1)
d* is in (xi-1, yi-1)
Goal: determine the sensor which is the one in the i-th step of the decision algorithm when d=d*
Output: d* or a sub-interval (xi , yi) of (xi-1, yi-1)
d* is in (xi , yi)

20. The first step i=1, (xi-1, yi-1)=(-∞,+∞)
Determine the set S1
Move all sensors rightwards, find a set of distance values d1 d2 d3 … such that
for any two consecutive di and di+1, when the moving distance is d with di < d < di+1, the set S1 is the same
Find index i such that di < d* ≤ di+1
Determine whether d* = di+1 d1 d2 d3

21. The first step (cont.) If d* = di+1, output d*
If d* ≠ di+1, (di,di+1) and S1 are available
If S1 is not empty,
determine the sensor
output (di , di+1) as (xi , yi) and proceed on the next step
If S1 is empty,
determine the set S2 similarly

22. Time analysis Each step takes O(n log n) time
Dominated by the binary search
Overall running time: O(n2 log n)

23. Conclusion The uniform case The non-uniform case
An improved algorithm: O(n logn) time
Previous work: O(n2)
The non-uniform case
First-known polynomial-time algorithm: O(n2 logn) time
Open problem answered!

24. Thank you