Approximation Algorithms for Minimizing Maximum Sensor Movement for Line Barrier Coverage in the Plane

TL;DR

This paper introduces three approximation algorithms for the MMSM problem in line barrier coverage, improving maximum movement bounds and providing practical solutions with near-optimal guarantees.

Contribution

It presents three novel approximation algorithms for MMSM, utilizing greedy, LP rounding, and matching techniques, with improved bounds and efficiency.

Findings

The greedy algorithm achieves a maximum movement of D* + 2r_max.

LP rounding and matching algorithms improve the bound to D* + r_max.

A factor-2 approximation algorithm enhances performance when r_max > D*.

Abstract

Given a line barrier and a set of mobile sensors distributed in the plane, the Minimizing Maximum Sensor Movement problem (MMSM) for \textcolor{black}{line barrier coverage} is to compute relocation positions for the sensors in the plane such that the barrier is entirely covered by the monitoring area of the sensors while the maximum relocation movement (distance) is minimized. Its weaker version, decision MMSM is to determine whether the barrier can be covered by the sensors within a given relocation distance bound $D\in\mathbb{Z}^{+}$. This paper presents three approximation algorithms for decision MMSM. The first is a simple greedy approach, which runs in time $O(n\log n)$ and achieves a maximum movement $D^{*}+2r_{max}$, where $n$ is the number of the sensors, $D^{*}$ is the maximum movement of an optimal solution and $r_{max}$ is the maximum radii of the sensors. The second and the third algorithms improve the maximum movement to $D^{*}+r_{max}$ , running in time $O(n^{7}L)$ and $O(R^{2}\sqrt{\frac{M}{\log R}})$ by applying linear programming (LP) rounding and maximal matching tchniques respecitvely, where $R=\sum2r_{i}$, which is $O(n)$ in practical scenarios of uniform sensing radius for all sensors, and $M\leq n\max r_{i}$. Applying the above algorithms for $O(\log(d_{max}))$ time in binary search immediately yields solutions to MMSM with the same performance guarantee. In addition, we also give a factor-2 approximation algorithm which can be used to improve the performance of the first three algorithms when $r_{max}>D^{*}$. As shown in \cite{dobrev2015complexity}, the 2-D MMSM problem admits no FPTAS as it is strongly NP-complete, so our algorithms arguably achieve the best possible ratio.

Equations

$$\lambda (i,D,x,x^{\prime })=\{\begin{array}{ll}0& g_i\le x\text{mbox}or{l}_i\ge x^{\prime }\\ \min \{2r_i,\min \{x^{\prime },g_i\}-\max \{x,l_i\}\}& Otherwise\end{array}$$

$$\sigma (i,D,\mathcal{S})=\{\begin{array}{ll}0& g_i\le x\text{mbox}OR{l}_i\ge x^{\prime }\\ \min \{2r_i,{\sum }_{[x,x^{\prime }]\in \mathcal{S}}\lambda (i,D^{\ast },x,x^{\prime })\}& Otherwise\end{array}$$

$$\sum _{j\in \mathcal{I}\setminus \{i\}}\sigma (j,D,x,x^{\prime })=\sum _{j\in \mathcal{I}}\sigma (j,D,[x,x^{\prime }])\ge |x^{\prime }-x|,$$

$$\sum _{j\in \mathcal{I}\setminus \{i\}}\sigma (j,D,[x,x^{\prime }])=\sum _{j\in \mathcal{I}}\sigma (j,D,[x,x^{\prime }])-(\min \{g_i,x^{\prime }\}-x).$$

$$\sum _{j\in \mathcal{I}\setminus \{i\}}\sigma (j,D,[x,x^{\prime }])\ge x^{\prime }-x-(\min \{g_i,x^{\prime }\}-x)=x^{\prime }-\min \{g_i,x^{\prime }\}$$

$$\sum _{j\in \mathcal{I}\setminus \{i\}}\sigma (j,D,[x,x^{\prime }])<x^{\prime }-x-(\min \{g_i,x^{\prime }\}-x)=x^{\prime }-\min \{g_i,x^{\prime }\}.$$

$$\sum _{j\in \mathcal{I}}\sigma (j,D,\{[s,s+2r_i],[x,x^{\prime }]\})\ge 2r_i+x^{\prime }-x.$$

$$\sum _{j\in \mathcal{I}}\sigma (j,D,\{[s,s+2r_i],[x,x^{\prime }]\})-2r_i\ge x^{\prime }-x.$$

$$\sum _{j\in \mathcal{I}\setminus \{i\}}\sigma (j,D,\{[s,s+2r_i],[x,x^{\prime }]\})\ge x^{\prime }-x.$$

$$\sum _{j\in \mathcal{I}\setminus \{i\}}\sigma (j,D,[x,x^{\prime }])$$

$$+\varphi (j,D,[x,\min \{g_i,x^{\prime }\}])$$

$$\sum _{j\in \mathcal{I}\setminus \{i\}}\sigma (j,D,\{[s,s+2r_i],[x,x^{\prime }]\})$$

$$+$$

$$\max \sum _{i\in [n{]}^{+}}\sum _{j\in J_i}{x}_{i,j}$$

$$\sum _{j\in J_i}{x}_{i,j}$$

$$\sum _{i\in [n{]}^{+}}{x}_{i,j}$$

$$0\le x_{i,j}$$

Full text

This paper presents three approximation algorithms for decision MMSM. The first is a simple greedy approach, which runs in time $O(n\log n)$ and achieves a maximum movement $D^{*}+2r_{max}$, where $n$ is the number of the sensors, $D^{*}$ is the maximum movement of an optimal solution and $r_{max}$ is the maximum radii of the sensors. The second and the third algorithms improve the maximum movement to $D^{*}+r_{max}$ , running in time $O(n^{7}L)$ and $O(R^{2}\sqrt{\frac{M}{\log R}})$ by applying linear programming (LP) rounding and maximal matching tchniques respecitvely, where $R=\sum 2r_{i}$, which is $O(n)$ in practical scenarios of uniform sensing radius for all sensors, and $M\leq n\max r_{i}$. Applying the above algorithms for $O(\log(d_{max}))$ time in binary search immediately yields solutions to MMSM with the same performance guarantee. In addition, we also give a factor-2 approximation algorithm which can be used to improve the performance of the first three algorithms when $r_{max}>D^{*}$. As shown in [8], the 2-D MMSM problem admits no FPTAS as it is strongly NP-complete, so our algorithms arguably achieve the best possible ratio.

I Introductions

Barrier coverage and area coverage are two important problems in applications of wireless sensor networks. In both two problems, sensors are deployed in such a way that every point of the target region is monitored by at least one sensor. For area coverage, the target region is traditionally a bounded area in the plane; while in the barrier coverage problem arising from border surveillance for intrusion detection, the target region are the borders and the goal is to deploy sensors along the borders such that at least one sensor will detect if any intruder crosses the border. Unlike area coverage, barrier coverage requires only to cover every points of the borders, rather than every point of the area bounded by the border. So barrier coverage uses much fewer sensors, and hence is more cost-efficient, particularly in practical large-scale sensor deployment.

To accomplish a barrier coverage, sensors are dispersed along the borders. However, there may exist gaps after the dispersal, so the border line might not be completely covered. One approach is to disperse the sensors in multiple rounds, and guarantee the probability of complete coverage by the dispersal density of the sensors [21, 13]. The other approach is to acquire some sensors with the ability of relocation (i.e. mobility), such that after dispersal, the sensors can move to monitor the gaps on the barrier. In this context, since the battery of a sensor is limited, a smart relocation scheme is required to maximize the lifetime of the sensors, and hence ensures a maximum lifetime of the barrier coverage.

I-A Problem Statement

This paper studies the two-dimensional (2-D) barrier coverage problem with mobile sensors, in which the barrier is modeled by a line segment, while the sensors are distributed in the plane initially. The problem is to compute the relocated positions of the sensors, such that the barrier will be completely covered while the maximum relocation distance among all the sensors is minimized.

Formally, we are given a line barrier $[0,M]$ on $x$-axis and a set of sensors distributed in the Euclidean plane, say $\Gamma=\{1,\,\dots,\,n\}$, within which sensor $i$ is with a radii $r_{i}$ and a position $(x_{i},\,y_{i})$. The two dimensional Minimum Maximum Sensor Movement problem (MMSM) is to compute the minimum $D\in\mathbb{Z}_{0}^{+}$ and a new position $(x_{i}^{\prime},\,0)$ for each sensor $i$, such that $\max_{i\in n}\sqrt{(x_{i}-x_{i}^{\prime})^{2}+(y_{i}-0){}^{2}}\leq D$ and each point on the line barrier is covered by at least one sensor (i.e. for each point on the line barrier there exists at least a sensor $i$ within distance $r_{i}$).

The paper finds that, MMSM can be reduced to a discrete version called DMMSM. In DMMSM, we are given a graph $G=(V,\,E)$, where $V=\{v_{0},\,v_{1},\,\dots,\,v_{M}\}$ and $E=\{e_{i}=(v_{i},\,v_{i+1})|i\in V\setminus\{M\}\}$. We say an edge $e_{j}$ is covered by a set of sensors $\Gamma^{\prime}\subseteq\Gamma$ if and only if every point on the edge is in the monitoring area of at least one sensor of $\Gamma^{\prime}$. The goal of DMMSM is also to compute a minimum maximum movement $D\in\mathbb{Z}_{0}^{+}$ and the new relocate position for each sensor, such that every edge of $E$ is covered by the sensors.

We propose several algorithms that are actually first to solve decision MMSM and decision DMMSM, which is to determine, for a given the relocation distance bound $D$, whether the sensors can be relocated within $D$ to cover the line barrier.

I-B Related Works

The MMSM problem in 2D setting was first studied in [8], and shown strongly ${\cal NP}$-complete for sensors with general sensing radii via a reduction from the 3-partition problem which is known strongly ${\cal NP}$-complete. Later, an algorithm with a time complexity of $O(n^{3}\log n)$ has been developed in [14] for the problem where sensors are with identical sensing radii. In the same paper, an approximation algorithm with ratio $\frac{y_{max}}{y_{min}}$ for general radii has also been developed, where $y_{max}$ and $y_{min}$ are respectively the maximum and minimum perpendicular relocation distance from the sensors to the barrier. To the best of our knowledge, there is no any other non-trivial approximation algorithm for MMSM with general radii.

Unlike 2-D MMSM, the MMSM problem has been extensively studied and well understood in 1-D setting, in which the barrier are assumed to be a line segment on the same line where the sensors are initially located. Paper [6] presented an algorithm which optimally solves 1D-MMSM for uniform radius and runs in time $O(n^{2})$, by observing the order preservation property. The time complexity was improved to $O(n\log n)$ later in paper [5], which also gave an $O(n^{2}\log n)$ time algorithm for general radii. Recently, an $O(n^{2}\log n\log\log n)$ time algorithm has been presented in [19] for weighted 1D-MMSM with uniform radii, in which each sensor has a weight, and the moving cost of a sensor is its movement times its weight. Moreover, circle/simple polygon barriers has been studied besides straight lines in [3], in which two algorithms has been developed for MMSM, with an $O(n^{3.5}\log n)$ time against cycle barriers and an $O(mn^{3.5}\log n)$ time against polygon barriers, where $m$ is the number of the edges on the polygon. The later time complexity was then improved to $O(n^{2.5}\log n)$ in [18].

Other problems closely related to MMSM have also been well studied in previous literature. In 1-D setting, the Min-Sum relocation problem, to minimize the sum of the relocation distances of all the sensors, is shown ${\cal NP}$-complete for general radii while solvable in time $O(n^{2})$ for uniform radii [7]. The Min-Num relocation problem of minimizing the number of sensors moved, is also proven ${\cal NP}$-complete for general radii and polynomial solvable for uniform radii [16]. Similar to MMSM, where a PTAS has been developed for the Min-Sum relocation problem against circle/simple polygon barriers [3], which was improved by later paper [18] that gave an $O(n^{4})$ time exact algorithm.

Paper [1] studied a more complicated problem of maximizing the coverage lifetime, in which each mobile sensor is equipped with limited battery power, and the coverage lifetime is the time to when the coverage no longer works because of the death of a sensor. The authors presented parametric search algorithms for the cases when the sensors have a predetermined order in the barrier or when sensors are initially located at barrier endpoints. On the other hand, the same authors present two FPTAS respectively for minimizing sumed and maximum energy consumption when the radii of the sensors can be adjusted [2]. When the sensing radii is fixed, i.e. unadjustable, the same paper showed the min-sum problem can not be approximated within $O(n^{c})$ for any constant $c$ under the assumption of ${\cal P}\neq{\cal NP}$, while the min-max version is known strongly ${\cal NP}$-complete, as it can be reduced to 2-D MMSM which is know strongly ${\cal NP}$-complete [8].

Before deployment of mobile sensors, barrier coverage was first considered deploying stationary sensors [12] for covering a closed curve (i.e. a moat), and an elegant algorithm was proposed by transferring the Min-Sum cost barrier coverage problem to the shortest path problem. It has then been extensively studied for line based employment [17], for better local barrier coverage [4], and for using camera sensors [20, 15]. The most recent result [9] studied line barrier coverage using sensors with adjustable sensing ranges. They show the problem is polynomial solvable when each sensor can only choose from a finite set of sensing ranges, and ${\cal NP}$-complete if each sensor can choose any sensing ranges in a given interval.

I-C Our Results and Technique

In this paper, we present two approximation algorithms for the decision MMSM problem. The first is a simple greedy approach based on our proposed sufficient condition of determining whether there exists a feasible cover for the barrier under the relocation distance bound $D$. If $D<D^{*}$, the algorithm outputs “infeasible”; Otherwise, the algorithm computes new positions for the sensors, resulting a maximum relocation distance $D+2r_{max}$, where $r_{max}=\max_{i}\{r_{i}\}$. The algorithm is so efficient that it runs in time $O(n\log n)$, where $n=|\Gamma|$ is the number of the sensors. The second is generally an linear programming (LP) rounding based approach, which first transfers MMSM to the fractional cardinality matching problem and then solves the LP relaxation we propose for the latter problem. The algorithm approximately solves the decision MMSM problem according to a solution to the LP relaxation. Similar to the case for the first algorithm, we show that the algorithm always outputs “feasible” if $D\geq D^{*}$. Further, for any instance our algorithm returns “feasible”, we give a method to construct a real solution for MMSM, with a maximum relocation distance $D+r_{max}$, by rounding up a fractional optimum solution to the LP relaxation. The algorithm has a runtime $O(n^{7}L)$, which is exactly the time of solving the proposed LP relaxation by Karmakar’s algorithm [10], where $L$ is the length of the input. As a by-product, we give the third algorithm for decision MMSM with a maximum relocation distance $d(OPT)+r_{max}$, and time $O(R^{2}\sqrt{\frac{M}{\log R}})$, where $R=\sum_{i=1}^{n}2r_{i}$ is sum of the radii of the sensors.

Based on the three above algorithms for the decision problem, the paper proposes an unified algorithm framework to actually calculate a solution to MMSM without a given $D$. The time complexity and the maximum relocation distance are respectively $O(n\log n\log d_{\max})$ and $D^{*}+2r_{max}$ if employing the greedy algorithm; $O(n^{7}L\log d_{max})$ and $D^{*}+r_{max}$ if employing the LP based algorithm, where $d_{max}$ is the maximum distance between the sensors and the barriers. The runtime $O(n^{7}L\log d_{max})$ can be improved to $O(R^{2}\sqrt{\frac{M}{\log R}}\log d_{max})$ if $M$ is not large, by using the third algorithm based on matching.

Note that, although our algorithm could compute a near-optimal solution when $D^{*}\gg r_{max}$, the performance guarantee is not as good when $D^{*}<r_{max}$. So in addition we give a simple factor-2 approximation algorithm for MMSM, by extending the optimal algorithm for 1D-MMSM as in paper [5]. Consequently, the ratio of our first three algorithms can be improved for the case $D^{*}<r_{max}$, by combining the factor-2 approximation.

I-D Organization of the Paper

The remainder of the paper is organized as follows: For decision MMSM, Section 2 gives a greedy algorithm as well as the ratio proof; Section 3 gives an approximation algorithm with an improved maximum relocation distance $d(OPT)+r_{max}$ using LP rounding technique; Section 4 gives another approximation algorithm with the same maximum relocation distance guarantee but a different runtime, by using maximum cardinality matching; Section 5 present the algorithm which actually solve MMSM, using the algorithm given in Section 2, 3 and 4; Section 6 extends previous results and develops a factor-2 approximation algorithm with provable performance guarantee; Section 7 concludes the paper.

II A Simple Greedy Algorithm For Decision MMSM

This section presents an approximation algorithm for any instance of decision MMSM wrt a given $D$: if the algorithm returns “infeasible”, then the instance is truly infeasible with respect to $D$; Otherwise, the instance of MMSM is feasible under the maximum movement of $D+2r_{max}$, where $r_{max}=\max_{i}\{r_{i}\}$. To show the performance guarantee of the algorithm, we propose a sufficient condition for the feasibility of decision MMSM against given $D$.

II-A An Approximation Algorithm

Let $[l_{i},\,g_{i}]$ be the possible coverage range for sensor $i$, where $l_{i}$ and $g_{i}$ are respectively the leftmost and the rightmost points of the barrier, i.e. the leftmost and the rightmost points sensor $i$ can cover by relocating within distance $D$. The key idea of our algorithm is to cover the barrier from left to right, using the sensor with minimum $g_{i}$ within the set of sensors which can cover the leftmost uncovered point with a maximum relocation distance $D+2r_{max}$.

More detailed, the algorithm is first to compute for each sensor $i$ its possible coverage range $[l_{i},\,g_{i}]$. Let $s$ be the leftmost point of the uncovered part of the line barrier. Then among the set of sensors $\{i|l_{i}-2r_{max}\leq s\leq g_{i}\}$, the algorithm repeats selecting the sensor with minimum $g_{i}$ to cover an uncovered segment of the line barrier starting at $s$. Note that $\{i|l_{i}-2r_{max}\leq s\leq g_{i}\}$ is exactly the set of sensors, which are with $g_{i}\geq s$ and can monitor an uncovered segment starting at $s$ by relocating at most $D+2r_{max}$ distance. If there is a tie on $g_{i}$, then randomly pick a sensor within the tie. The selection terminates once the line barrier is completely covered, or the instance is found infeasible, i.e. there exists no such $i$ with $l_{i}-2r_{max}\leq s\leq g_{i}$ while the coverage is not done. The algorithm is formally as in Algorithm 1.

For briefness, we will simply say an instance (or the input) of MMSM instead for the input of Algorithm 1 in the following paragraphs. Note that Steps 2-3 take time $O(n)$ to compute $l_{i}$ and $g_{i}$ for all the sensors, Steps 4-7 take $O(n\log n)$ time to assign the sensors to cover the line barrier. Therefore, we have the time complexity of the algorithm:

Lemma 1**.**

Algorithm 1 runs in time $O(n\log n)$.

II-B The Ratio of Algorithm 1

The performance guarantee of Algorithm 1 is as below:

Theorem 2**.**

Let $D^{*}$ be the distance of an optimal solution. If $D\geq D^{*}$, then Algorithm 1 will return a solution with maximum relocation distance $D+2r_{max}$, where $r_{max}=\max_{i}\{r_{i}\}$.

According to Algorithm 1, we never move a sensor out of the range $[l_{i}-2r_{max},\,g_{i}]$. It remains to show Algorithm 1 will always return a feasible solution when $D\geq D^{*}$. For this goal, we will give a sufficient condition for the feasibility of decision MMSM. Below are two notations needed for the tasks:

[TABLE]

and

[TABLE]

where ${\cal S}$ is a set of disjoint segments of the line barrier. Intuitionally $\lambda(i,\,D,\,x,\,x^{\prime})$ is the maximum coverage which sensor $i$ can provide for segment $[x,\,x^{\prime}]$, and $\sigma(i,\,D,\,{\cal S})$ is the sum of the coverage that sensor $i$ can provide for all the segments in ${\cal S}$. Then a simple necessary condition for the feasibility of an instance of MMSM of as below:

Proposition 3**.**

If an instance of decision MMSM is feasible wrt $D$, then $\sum_{i}\sigma(i,\,D,\,{\cal S})\geq\sum_{[x_{j},\,x_{j}^{\prime}]\in{\cal S}}|x_{j}^{\prime}-x_{j}|$ must hold for any set of disjoint segments ${\cal S}=\{[x_{i},\,x_{i}^{\prime}]|0\leq i\leq M\}$.

Intuitionally, the above proposition states that the sum of the sensor coverage length must be not less than the length of the barrier segments to cover. The correctness of the above lemma is obviously, since a feasible relocation assignment must satisfy the condition. However, this is not a sufficient condition for the feasibility of decision MMSM (A counter example is as depicted in Figure 2 (a): For $D=r_{1}$, the necessary condition holds for the given instance while the instance is actually infeasible). However, if $2r_{max}$ more relocation distance is allowed as in Algorithm 1, we have the following lemma:

Lemma 4**.**

If $\sum_{i}\sigma(i,\,D,\,{\cal S})\geq\sum_{[x_{j},\,x_{j}^{\prime}]\in{\cal S}}|x_{j}^{\prime}-x_{j}|$ holds for every disjoint segments set ${\cal S}$, then the instance of decision MMSM is feasible under maximum relocation distance $D+2r_{max}$, $r_{max}=\max_{i}\{r_{i}\}$.

Proof:

We need only to show that if $\sum_{i}\sigma(i,\,D,\,{\cal S})\geq\sum_{[x_{j},\,x_{j}^{\prime}]\in{\cal S}}|x_{j}^{\prime}-x_{j}|$ holds at the beginning of Algorithm 1, then $\sum_{i}\sigma(i,\,D,\,{\cal S})\geq\sum_{[x_{j},\,x_{j}^{\prime}]\in{\cal S}}|x_{j}^{\prime}-x_{j}|$ remains true in each step of Algorithm 1.

Suppose the lemma is not true. Let the step of picking sensor $i$ be the first $\sum_{i}\sigma(i,\,D,\,{\cal S})\geq\sum_{[x_{j},\,x_{j}^{\prime}]\in{\cal S}}|x_{j}^{\prime}-x_{j}|$ becomes false. Then there must exist $x$ and $x^{\prime}$, such that $\sum_{j\in{\cal I}}\sigma(j,\,D,\,x,\,x^{\prime})\geq|x^{\prime}-x|$ and $\sum_{j\in{\cal I}\setminus i}\sigma(j,\,D,\,x,\,x^{\prime})<|x^{\prime}-x|$. We analysis all cases wrt all the possible orders of $g_{i}$, $s+2r_{i}$ and $x$ in the line barrier, and show that contradictions exist in every case.

$g_{i}\leq x$:

In this case, $\sigma(i,\,D,\,[x,\,x^{\prime}])=0$ holds, i.e. sensor $i$ does not cover any portion of $[x,\,x^{\prime}]$. So we have

[TABLE]

which contradicts with $\sum_{j\in{\cal I}\setminus\{i\}}\sigma(j,\,D,\,[x,\,x^{\prime}])<|x^{\prime}-x|$. 2. 2.

$x<g_{i}\leq s+2r_{i}$:

In this case, sensor $i$ will actually cover $[s,\,s+2r_{i}]$, and hence $\sigma(i,\,D,\,[x,\,x^{\prime}])=\min\{g_{i},\,x^{\prime}\}-x$ is the actual coverage that sensor $i$ can contribute to $\sum_{j\in{\cal I}}\sigma(j,\,D,\,[x,\,x^{\prime}])$. So

[TABLE]

Then by combining $\sum_{j\in{\cal I}}\sigma(j,\,D,\,x,\,x^{\prime})\geq x^{\prime}-x$ with Inequality (1), we have

[TABLE]

On the other hand, the length of the portion of $[x,\,x^{\prime}]$ that needs to be covered is apparently $|x^{\prime}-x|-(\min\{g_{i},\,x^{\prime}\}-x)$. From the infeasibility of the remaining sensors in ${\cal I}$, we have

[TABLE]

A contradiction arises by comparing Inequality (2) and (3). 3. 3.

$g_{i}>x$ and $g_{i}>s+2r_{i}$:

Assume that $s+2r_{i}\leq x$. This assumption is without loss of generality, since otherwise from $\sum_{j\in{\cal I}\setminus\{i\}}\sigma(j,\,D,\,x,\,x^{\prime})<|x^{\prime}-x|$ and the fact that $[x,\,s+2r_{i}]$ is already covered by sensor $i$, we have $\sum_{j\in{\cal I}\setminus\{i\}}\sigma(j,\,D,\,s+2r_{i},\,x^{\prime})<x^{\prime}-(s+2r_{i})$. That is, we need only to set $x=s+2r_{i}$, and obtain contractions similar as this case. We will show that $\sum_{j\in{\cal I}\setminus\{i\}}\sigma(j,\,D,\,s+2r_{i},\,x^{\prime})\geq x^{\prime}-(s+2r_{i})$ actually holds and get a construction

By inductions, we have

[TABLE]

That is,

[TABLE]

So

[TABLE]

Assume that sensor $j\neq i$ is a sensor which can contribute to both $\sigma(j,\,D,\,[s,\,s+2r_{i}])$ and $\sigma(j,\,D,\,[x,\,x^{\prime}])$. Let $\phi(j,\,D,\,[s,\,s+2r_{i}])$ and $\phi(j,\,D,\,[x,\,g_{i}])$ be the portion that sensor $j$ actually contributes $[s,\,s+2r_{i}]$ and $[x,\,g_{i}]$, respectively, within $\sum_{j\in{\cal I}}\sigma(j,\,D,\,([s,\,s+2r_{i}],\,[x,\,x^{\prime}]))$. We need only to show that $\sum_{j\in{\cal I}\setminus\{i\}}\phi(j,\,D,\,[s,\,s+2r_{i}])$ is sufficient to be relocated to compensate all the coverage sensor $i$ contributes to $[x,\,g_{i}]$.

Since the chosen sensor $i$ is with smallest $g_{i}$ within all the sensors of $l_{i}-2r_{max}\leq s$, sensor $j\in{\cal I}\setminus\{i\}$ is with $g_{j}\geq g_{i}$. So the potion of sensor $j$ covering $[s,\,s+2r_{i}]$, i.e. $\phi(j,\,D,\,[s,\,s+2r_{i}])$, can all be relocated to cover any portion of $[x,\,g_{i}]$. So $\phi(j,\,D,\,[s,\,s+2r_{i}])+\phi(j,\,D,\,[x,\,\min\{g_{i},\,x^{\prime}\}])$ is actually the portion of the cover that sensor $j$ can contributes to $[x,\,g_{i}]$. Therefore, we have

[TABLE]

On the other hand, we have

[TABLE]

Combining Inequality (4), (5) and (6), we have $\sum_{j\in{\cal I}\setminus\{i\}}\sigma(j,\,D,\,[x,\,x^{\prime}])\geq\sum_{j\in{\cal I}\setminus\{i\}}\sigma(j,\,D,\,\{[s,\,s+2r_{i}],\,[x,\,x^{\prime}]\})\geq x^{\prime}-x$, which contradicts with the assumption.

∎

Now we will prove Theorem 2. If $D\geq D^{*}$, then the decision MMSM is feasible, and hence following Proposition 3 $\sum_{i}\sigma(i,\,D,\,{\cal S})\geq\sum_{[x_{j},\,x_{j}^{\prime}]\in{\cal S}}|x_{j}^{\prime}-x_{j}|$ holds for every ${\cal S}$ at the beginning of Algorithm 1. Then from Lemma 4, we immediately have the instance is feasible under relocation distance bound $D$, which completes the proof of Theorem 2.

Corollary 5**.**

The performance guarantee of Algorithm 1 in Theorem 2 is nearly tight.

As the example depicted in Figure 1, $d(OPT)=2r_{1}$ while the output of the algorithm is with a maximum relocation distance $2r_{2}$. So when $r_{2}\gg r_{1}$, $d(OPT)+2r_{max}\thickapprox 2r_{1}+2r_{2}$, and hence the analysis of Algorithm 1 is nearly tight in Theorem 2.

III An LP-based Approximation for Decision MMSM

This section will give an LP-based approximation algorithm to determine whether an instance of the decision MMSM problem is feasible. The algorithm first transfers the instance to a corresponding instance of decision DMMSM, and then an instance of the fractional cardinality matching problem with a proposed LP relaxation. Our algorithm answers “feasible” or “infeasible” according to the computed optimum solution of the LP relaxation. We show that if our algorithm returns feasible, then a solution to MMSM can be constructed under the maximum relocation distance $D+r_{max}$ by rounding up a fractional optimum solution to the relaxation.

III-A *Transferring to an Instance of DMMSM *

The key idea of the transfer is first to compute $l_{i}$ and $g_{i}$ for each $i$ wrt to the given $D$, and then add $(l_{i},\,0)$ and $(g_{i},\,0)$ to the barrier as two vertices on the line. That is, $V=\{(l_{i},\,0)|i\in[n]^{+}\}\cup\{(g_{i},\,0)|i\in[n]^{+}\}$. W.l.o.g. assume that the vertices of $V$ appear on the line barrier in the order of $v_{0},\,\dots,\,v_{|V|}$, from left to right on the line barrier. Then the algorithm adds an edge between every pair of $v_{i}$ and $v_{i+1}$. So $E=\{e_{i}(v_{i},\,v_{i+1})|i\in[|V|-1]^{+}\}$. Formally the transfer is as in Algorithm 2.

For the time complexity and the size of the graph, we have:

Lemma 6**.**

Algorithm 2 runs in $O(n\log n)$ time, and output a graph $G$ with $|V|=O(n)$ and $|E|=O(n)$.

According to the algorithm, $|V|=O(n)$ and $|E|=O(n)$ hold trivially. Algorithm 2 takes in $O(n\log n)$ time to sort (number) the vertices of $V$ in Step 5, since $|V|=O(n)$. Other steps of the algorithm takes trivial time compared to the sorting. So the total runtime of Algorithm 2 is $O(n\log n)$.

Lemma 7**.**

An instance of MMSM is feasible under $D$ if and only if its corresponding DMMSM instance produced by Algorithm 2 is feasible under $D$.

Proof:

According to Algorithm 2 and following the definition of MMSM and DMMSM, a solution to an instance of MMSM is obviously a solution to the corresponding instance of DMMSM, and vice versa. So an instance of MMSM is feasible, iff its corresponding DMMSM instance is feasible. ∎

III-B Fractional Maximum Cardinality Matching wrt DMMSM

Let $|e_{i}|=v_{i+1}-v_{i}$ be the length of edge $e_{i}$. Assuming that $v_{i_{1}}=l_{i}$ and $v_{i_{2}}=g_{i}$, we set $J_{i}=\{e_{j}|j=i_{1},\,i_{1}+1,\,\dots,\,i_{2}-1\}$. Then the linear programming relaxation (LP1) for DMMSM is as below:

[TABLE]

subject to

[TABLE]

where $\sum_{j\in J_{i}}x_{i,j}\leq 2r_{i}$ is because a sensor $i$ can at most cover length $2r_{i}$ of the barrier, and Inequality (8) is because the covered length of each edge $e_{i}$ (segment) is at most $|e_{j}|$.

Our algorithm determines decision DMMSM according to the computed optimum solution, say $\mathbf{x}$, to LP1: the algorithm outputs “feasible” if $\sum_{i\in[n]^{+}}\sum_{j\in J_{i}}x_{i,\,j}=M$, and outputs “infeasible” otherwise.

It is known that there exist polynomial-time algorithms for solving linear programs. In particular, using Karmakar’s algorithm to solve LP1 will take $O(n^{7}L)$ time [10], since there are $O(n^{2})$ variables totally in LP1.

Lemma 8**.**

Algorithm 3 runs in time $O\left(n^{7}L\right)$.

It is worth to note that the simplex algorithm has a much better practical performance than Karmakar’s algorithm [11]. So using the simplex method the algorithm would be faster than $O(n^{7}L)$ in real world applications.

The performance guarantee of Algorithm 3 is as given in the following theorem, whose proof will be given in next subsection.

Theorem 9**.**

If Algorithm 3 returns “infeasible”, then the instance of DMMSM is truly infeasible under the given $D$; Otherwise, the instance of DMMSM is truly feasible under the maximum relocation distance $D+r_{max}$, where $r_{max}=\max_{i}\{r_{i}\}$.

Corollary 10**.**

The performance guarantee given in Theorem 9 is nearly tight for Algorithm 3.

From Figure 2, an optimal fractional solution to LP1 is with a maximum relocation distance $r_{1}$, while a true optimal solution for MMSM must be with a maximum relocation distance $r_{2}$. Thus, the integral gap for LP1 is $r_{2}-r_{1}\approx r_{max}$ when $r_{2}\gg r_{1}$. That is, for any fixed $\epsilon>0$, the maximum relocation distance increment could be larger than $r_{max}-\epsilon$ for rounding an optimum solution of LP1 to a true solution of MMSM. Therefore, the ratio is nearly-tight for Algorithm 3.

III-C *Proof of Theorem 9 *

This subsection will prove Theorem 9 by showing a fractional optimum solution to LP1 can be rounded up to an integral solution of DMMSM with a maximum relocation distance $D+r_{max}$.

Let $\mathbf{x}$ be an optimum solution to LP1. Recall that $x_{ij}$ is the (fractional) portion sensor $i$ covering edge $j$, the key idea of our algorithm is to aggregate the portions of sensor $i$ covering different $j$s, such that the portions combine to a line segment which $i$ can cover within movement $D+r_{max}$.

Our algorithm is composed by two parts. The first part is called pre-aggregation which rounds $x_{ij}$ to $1$ in a “pseudo” way. More precisely, assume that $0<x_{i_{1},\,j},\,\dots,\,x_{i_{h},\,j}<0$ are the variables shares edge $e_{j}$. Then the pre-aggregation divides $e_{j}$ to a set of sub-edges $\{e_{j,\,i_{1}},\,\dots,e_{j,\,i_{h}}\}$, in which $|e_{j,\,i_{l}}|=|e_{j}|\cdot x_{i_{l},\,j}$. We set $x_{i_{l},\,j,\,l}=1$, which is, edge $e_{j,\,i_{l}}$ completely covered by sensor $i_{l}$.

Let ${\cal S}_{i}$ be the set of sub-edges covered by sensor $i$ accordingly. The second part, which is called aggregation, aggregates the edges of ${\cal S}_{i}$ for each $i$ such that the edges covered by an identical sensor will connect together. The aggregation starts from the following simple observation whose correctness is obviously:

Proposition 11**.**

Let $i$ and $i^{\prime}$ be two sensors. Let ${\cal S}_{i}$ and ${\cal S}_{i}^{\prime}$ be the set of edges covered by sensor $i$ and $i^{\prime}$, respectively. Then, for any sub-edges $j_{1},\,j_{2}\in{\cal S}_{i}$ and $j_{1}^{\prime},\,j_{2}^{\prime}\in{\cal S}_{i^{\prime}}$, w.l.o.g. assuming $j_{1}<j_{1}^{\prime}$, $j_{1}<j_{2}$ and $j_{1}^{\prime}<j_{2}^{\prime}$, then exactly one of the following cases holds: (1) $j_{1}<j_{2}<j_{1}^{\prime}<j_{2}^{\prime}$ ; (2) $j_{1}<j_{1}^{\prime}<j_{2}<j_{2}^{\prime}$ ; (3) $j_{1}<j_{1}^{\prime}<j_{2}^{\prime}<j_{2}$.

The key observation of the aggregation is that if case (2) and (3) in the above proposition can be eliminated, then the set of edges in ${\cal S}_{i}$ are aggregated together that they can be truly monitored by sensor $i$. So the aggregation is accordingly composed by two phases called the swap phase and the exchange step, which are to eliminate case (2) and (3), respectively. Formally, the algorithm is as in Algorithm 4 (An example of such rounding depicted as in Figure 3 and 4).

Note that if two adjacent sub-edges belong to the same ${\cal S}_{i}$, say $e_{j_{1}},\,e_{j_{2}}\in{\cal S}_{i}$ with $v_{j_{1}+1}=v_{j_{2}}$, then we can combine the two sub-edges as one, since they are segments both covered by sensor $i$. So Step 4 of Algorithm 4 is actually to set ${\cal S}_{i}:={\cal S}_{i}\setminus\{e_{j_{1}},\,e_{j_{2}}\}\cup e(v_{j_{1}},\,v_{j_{2}+1})$ for every such pair of adjacent edges of ${\cal S}_{i}$ for every $i$.

The *swap *phase, as in Step 3 of Algorithm 4, will eliminate case (2) (i.e. $j_{1}<j_{1}^{\prime}<j_{2}<j_{2}^{\prime}$) by swapping the coverage sensors of the edges without causing any increment on the maximum relocation distance. The observation inspiring the swap is that for any $j_{1}<j_{1}^{\prime}<j_{2}<j_{2}^{\prime}$, we can swap the two sensors covering $j_{1}^{\prime}$ and $j_{2}$ without increasing the maximum relocation distance. More precisely, we cover a portion of $\min\{|j_{1}^{\prime}|,\,|j_{2}|\}$ of $j_{1}^{\prime}$ with $i$ and cover a portion of $\min\{|j_{1}^{\prime}|,\,|j_{2}|\}$ of $j_{2}$ with $i^{\prime}$. The formal layout of the swap phase is as in Algorithm 5.

Note that Steps 8-13 will add new vertices and edges to the graph, so $\sum_{i=1}^{n}|{\cal S}_{i}|$ may increases. However, we can always guarantee $\sum_{i=1}^{n}|{\cal S}_{i}|\leq n|E|$. Since otherwise, following the pigeonhole principle, there must exist two sub-edges, say $e_{j_{1}}$ and $e_{j_{2}}$ which are in an identical ${\cal S}_{i}$ and within the range of an identical edge of $E$. Then, such two sub-edges $e_{j_{1}},\,e_{j_{2}}$ can be combined as one, by setting $x(v_{j_{1}+1})=x(v_{j_{1}+1})+|e_{j_{2}}|$ and move every sub-edge between $e_{j_{1}}$ and $e_{j_{2}}$ to right with an offset with length $|e_{j_{2}}|$. Clearly, following the meaning of a sensor covering edges as in the definition of DMMSM, these movement does not cause any increment on the relocation distance of each sensor.

In Algorithm 5, the while-loop iterates for $O(n)$ times and the outer for-loop iterates for $O(n)$ times. Since the inner for-loop iterates for at most $O(\sum_{i=1}^{n}|{\cal S}_{i}|)$ times. Then from $\sum_{i=1}^{n}|{\cal S}_{i}|\leq n|E|=O(n^{2})$, the *for-loops iterates at most $O(n^{2})$ time. *So we have the total runtime of the swap phase:

Lemma 12**.**

Algorithm5 runs in time $O(n^{4})$.

For the correctness of Algorithm 5, we have the following lemma:

Lemma 13**.**

After the swap phase of Algorithm 1, there exist no ${\cal S}_{i}$ and ${\cal S}_{i^{\prime}}$ with sub-edges $j_{1},\,j_{2}\in{\cal S}_{i}$ and $j_{1}^{\prime},\,j_{2}^{\prime}\in{\cal S}_{i^{\prime}}$, such that $j_{1}<j_{1}^{\prime}<j_{2}<j_{2}^{\prime}$ holds.

Proof:

After the procession of ${\cal S}_{i}$, any ${\cal S}_{i^{\prime}}\in{\cal S\setminus{\cal S}}_{i}$ must have all its sub-edges appear between the two edges $e_{j_{h}}\in{\cal S}_{i}$ and $e_{j_{h+1}}\in{\cal S}_{i}$ for some $h$. Then, after ${\cal S}_{i}$ is processed, Case (2) can not hold for any edge pair within ${\cal S}_{i}$ in any other latter iterations. Therefore, the algorithm guarantees that one set contains no sub-edges of Case (2) at one iteration, and hence after $n$ iterations, sub-edges of Case (2) are eliminated. ∎

The exchange phase, invoked in Step 5 in Algorithm 4, is to eliminate case (3) (i.e. $j_{1}<j_{1}^{\prime}<j_{2}^{\prime}<j_{2}$). The key idea of the exchange is to move $j_{1}$ to the place exactly before $j_{2}$ (or to move $j_{2}$ to the place exactly after $j_{1}$), and then move the edges between $j_{1}$ and $j_{2}$ accordingly. The choosing of movements (move $j_{1}$ to $j_{2}$, or $j_{2}$ to $j_{1}$) depends on the current *offset *of the sub-edges between $j_{1}$ and $j_{2}$, as well as the length of the edge $j_{1}$ and the length sum of the other edges in ${\cal S}_{i}\setminus\{j_{1}\}$, where the offset of an sub-edge $j$ is the distance from the current position of $j$ to its original position. Formally, the *exchange *phase is as in Algorithm 6.

In Algorithm 6, the function Mover (${\cal E}$, ${\cal O}$, $i$, $i+\delta$) actually decides whether to move $C_{i+\delta}$ or $C_{i}$, according to which one of the two values $|C_{i}|-o_{i}$ and $\sum_{j:\,C_{j}\in{\cal S}_{j_{i}}\setminus\{C_{i}\}}|C_{j}|+o_{i}$ is larger. Intuitionally, without considering offsets, if we move $C_{i}$ then the moving distance of $C_{l}$ between $C_{i}$ and $C_{i+\delta}$ will be $|C_{i}|$; if move $C_{i+\delta}$, the moving distance will be $\sum_{j:\,C_{j}\in{\cal S}_{j_{i}}\setminus\{C_{i}\}}|C_{j}|$ instead of $|C_{i+\delta}|$, since not only $C_{i+\delta}$ but every $C_{j}\in{\cal S}_{j_{i}}\setminus\{C_{i}\}$ will be moved to adjacent to $C_{i}$. Then considering the offsets, we have the criteria of moving $C_{i}$ or $C_{i+\delta}$. The moving algorithm is as in Algorithm 7.

Lemma 14**.**

In Algorithm 4, a sensor needs only at most $D+r_{max}$ movement to cover $C_{1},\,\dots,\,C_{k}$ when the given instance is feasible wrt $D$.

Proof:

Clearly, after the swap phase sensor $i$ needs at most $D$ to any edges of $S_{i}$. It remains to analysis the exchanging phase. We will show that for a component $C_{i}$, its offset satisfies $-r_{max}\leq o_{i}\leq r_{max}$.

Let $o_{i_{1}}$ be the first non-zero value of $o_{i}$. Clearly $-r_{max}\leq o_{i_{1}}\leq r_{max}$ holds, since $o_{i_{1}}$ is actually $\min\{|C_{i_{1}}|,\,|C_{i_{1}+\delta_{1}}|\}$, and $|C_{i_{1}}|+|C_{i_{1}+\delta_{1}}|\leq 2r_{max}$, where $\delta_{1}>1$ is minimum that $C_{i_{1}}$ and $C_{i_{1}+\delta_{1}}$ shares an identical ${\cal S}_{j}\in{\cal S}$. Then after the $t$th times that $o_{i}$ changes, we have $o_{i_{t}}=\min\{|C_{i_{t}}|-o_{i_{t-1}},\,|C_{i_{t}+\delta_{t}}|+o_{i_{t-1}}\}$ according to Algorithm 7. So $o_{i_{t}}\leq\frac{(|C_{i_{t}}|-o_{i_{t-1}})+(|C_{i_{t}+\delta_{t}}|+o_{i_{t-1}})}{2}\leq r_{max}$. On the other hand, from the induction hypothesis, $-r_{max}\leq o_{i_{t-1}}\leq r_{max}$ holds. So $o_{i_{t}}\geq-r_{max}$, since $|C_{i_{t}}|,\,|C_{i_{t}+\delta_{t}}|\geq 0$. ∎

Lemma 15**.**

Algorithm 4 terminates in time $O(n^{7}L)$.

Proof:

The algorithm takes $O(n^{7}L)$ to solve LP1 by Karmakar’s algorithm [10], since there are $O(n^{2})$ variables in LP1. The swap phase in the algorithm 4 takes at most $O(n^{4})$ time as in Lemma 12, while the exchange phase iterates at most $O(k)=O(n^{2})$ times, each iteration takes $O(k)=O(n^{2})$ time to run Mover (${\cal E}$, ${\cal O}$, $i$, $i+\delta$). Other steps takes trivial time compared to the above time, so the time complexity of the algorithm is $O(n^{7}L)$. ∎

IV A Matching-Based Solution to Decision MMSM

This subsection gives a pseudo polynomial algorithm for decision MMSM. The key idea of the algorithm is to consider MMSM as DMMSM with uniform edge length, where the barrier to cover is composed by $M$ edges of length one. Then our algorithm is similar to the case in Section 3, excepting that we use maximum cardinality matching instead of fractional cardinality matching to compute an initial solution. Using a similar algorithm as in Subsection 3.3, we can round the initial solution, i.e. the maximum cardinality matching, to a solution to MMSM.

To model a given instance of MMSM as maximum cardinality matching, we will construct an equivalent bipartite graph $H=(U,\,V,\,E)$ in which the vertex set $V$ corresponds to the sensors, the vertex set $U$ corresponds to the edge set $\cup_{i}J_{i}$, where $J_{i}$ contains exactly the edges that can be completely sensed by sensor $i$ within maximum movement $D$, and the edge set $E_{H}$ corresponds to the coverage of the sensors to the edge of $\cup_{i}J_{i}$. Then we check whether there exists a maximal cardinality matching with size $M$ in $H$. If no such matching exists, the instance of DMMSM is infeasible under maximum relocation distance $D$. Otherwise, similarly as in Subsection 3.3, we can aggregate the vertices of $U$ that are fractionally covered by an identical sensor, such that the sensors can relocate within distance $D+r_{max}$ to cover all the edges. The formal layout of the algorithm is as in Algorithm 8.

Lemma 16**.**

Let $R=\sum_{i\in{\cal I}}r_{i}$. Algorithm 8 terminates in time $O\left(R^{2}\sqrt{\frac{M}{\log R}}\right)$.

Proof:

The maximal cardinality matching problem is known can be solved in time $O(|V_{H}|\sqrt{\frac{|V_{H}||E_{H}|}{\log|V_{H}|}})$, where $|V_{H}|$ is the number of vertices and $|V_{H}|$ is number of edges. Following Algorithm 8, $|V_{H}|=M+2R$ and $|E_{H}|\leq M\cdot 2R$. So the time needed to compute the matching as in Step 10 is actually $O\left(R\sqrt{\frac{MR^{2}}{\log R}}\right)=O\left(R^{2}\sqrt{\frac{M}{\log R}}\right)$. Other steps of the algorithm take trivial time compared to compute the matching. ∎

Theorem 17**.**

Let $D^{*}$ be the minimum movement under which a given instance of MMSM is feasible. If Algorithm 8 returns “infeasible”, then $D<D^{*}$; Otherwise, the computed matching ${\cal Y}$ can be transferred to a true solution to MMSM, with a maximum relocation distance $D_{SOL}\leq D+r_{max}$.

Firstly and apparently, if the DMMSM is feasible wrt a given $D$, there must exist a matching with size $M$ in the corresponding graph $H$. So if no such matching exists wrt $D$, then the instance DMMSM must be infeasible wrt $D$. Secondly, similar to Algorithm 4, the computed matching ${\cal Y}$ can be rounded to a true solution to MMSM using swap and exchange.

V The Complete Algorithm for Solving MMSM

The key idea of computing approximately a minimum $D$ is to use binary search and call Algorithm 1 (Or equivalently Algorithm 3 or Algorithm 8) as a subroutine. Let $d_{i}$ be the minimum distance between sensor $i$ and any point on the line barrier, and $d_{max}$ be the maximum distance between the sensors and the barriers. Then clearly every sensor of $\Gamma$ can cover any point of the barrier within movement distance $d_{max}$. That is, within movement distance $d_{max}$ the line barrier can be covered successfully by the sensors of $\Gamma$; Or the sensors in $\Gamma$ is not enough to cover the barrier. Then, to find the minimum $D$ for MMSM, we need only to use binary search within the range from 0 to $d_{max}$. Apparently, this takes at most $O(\log(d_{max}))$ calls of Algorithm 1 (Or 3, 8) to find the min-max feasible relocation distance bounded $D_{SOL}$. Formally, the complete algorithm is as in Algorithm 9.

From Theorem 2, we immediately have the time complexity and ratio for the algorithm as follows:

Lemma 18**.**

Algorithm 9 terminates in time $O(M\log d_{max})$, and output the relocation positions for the sensors, within a maximum relocation distance $D+2r_{max}$.

Note that, if using Algorithm 3 instead of Algorithm 1 in Step 8, the runtime and the maximum relocation distance of Algorithm 9 will be $O(n^{7}L)$ and $D_{SOL}=D+r_{max}$, respectively.

VI A Simple Factor-2 Approximation Algorithm for MMSM

Following paper [5], MMSM is solvable in time $O(n^{2}\log n)$ if all the sensors are on the line containing the barrier. Then a natural idea to solve 2D-MMSM is firstly to perpendicularly move (some of) the sensors to the line barrier, and secondly solve the consequent 1D-MMSM by using the algorithm in paper [5].

Let $d_{p,\,i}$ be the perpendicular distance between sensor $i$ and the line barrier. Without loss of generality we assume that $0=d_{p,\,0}\leq d_{p,\,1}\leq\dots\leq d_{p,\,i}\leq\dots\leq d_{p,\,n}$, where sensor [math] is a virtual sensor with radii 0. Let $S(d_{p,\,i})=\{j|d_{p,\,j}\leq d_{p,\,i}\}$ be the set of sensors whose perpendicular distance to the line barrier is not larger than $d_{p,\,i}$. Let $D_{h}(S(d_{p,\,i}))$ be the maximum horizontal relocation distance of the sensors in $S(d_{p,\,i})$ covering the barrier. Our algorithm will first simply compute $D_{h}(S(d_{p,\,i}))$ for every $i\in[n]^{+}$, and then select $\min\{d_{p,\,i}+D_{h}(S(d_{p,\,i}))|i\in[n]^{+}\}$ as the maximum relocation distance.

Lemma 19**.**

$\min\{d_{p,\,i}+D_{h}(S(d_{p,\,i}))|i\in[n]^{+}\}\leq 2D^{*}$.

Proof:

For an optimum relocation solution to 2D-MMSM, assume that $d_{p,\,i^{*}}$ is the maximum perpendicular distance of the relocated sensors. Then $d_{p,\,i^{*}}\leq D^{*}$, since sensor $i^{*}$ has to move at least distance $d_{p,\,i^{*}}$ to cover the barrier. On the other hand, apparently we have $D_{h}(S(d_{p,\,i^{*}}))\leq D^{*}$ i.e. the optimum maximum horizontal relocation distance is not larger than $D^{*}$. Therefore, we have $\min\{d_{p,\,i}+D_{h}(S(d_{p,\,i}))|i\in[n]^{+}\}\leq d_{p,\,i^{*}}+D_{h}(S(d_{p,\,i^{*}}))\leq 2D^{*}$. ∎

Clearly, the above naive algorithm has to run the 1D-MMSM algorithm for $O(n)$ times to compute $\min\{d_{p,\,i}+D_{h}(S(d_{p,\,i}))|i\in[n]^{+}\}$. Hence, it runs in time $O(n^{3}\log n)$. Note that the binary search cannot be immediately applied here, since $f(i)=d_{p,\,i}+D_{h}(S(d_{p,\,i}))$ is neither monotonously increasing nor monotonously decreasing on $i$. Anyhow, we will give an improve algorithm in which the number of times of solving 1D-MMSM is improved to $O(\log n)$. We will show the ratio of the improved algorithm remains two by giving further observations.

The key idea of our improved algorithm is, instead of finding an $i$ such that $d_{p,\,i}+D_{h}(S(d_{p,\,i}))$ attends minimum, to find an $i_{alt}$, such that $D_{h}(S(d_{p,\,i_{alt}})\leq d_{p,\,i_{alt}}$ and $D_{h}(S(d_{p,\,i_{alt}-1})\geq d_{p,\,i_{alt}-1}$ both hold. Note that such $i_{alt}$ can be found with solving the 1D-MMSM problem only for $O(\log n)$ times, via a binary search in which a set of values $[lwr,\,upp]$, $lwr\leq i_{alt}\leq upp$, is maintained. The formal layout of the algorithm is as in Algorithm 10.

The basic observation of our algorithm is that $f(i)=D_{h}(S(d_{p,\,i}))$ will not increase while $i$ increases.

Proposition 20**.**

$f(i)=D_{h}(S(d_{p,\,i}))$* is monotonously decreasing on $i$.*

The correctness of the above proposition immediately follows from the fact that $S(d_{p,\,i})\supseteq S(d_{p,\,i-1})$. Then the performance guarantee of the algorithm is as in the following lemma:

Lemma 21**.**

$\min\{d_{p,\,i_{alt}}+D_{h}(S(d_{p,\,i_{alt}}),\,d_{p,\,i_{alt}-1}+D_{h}(S(d_{p,\,i_{alt}-1})\}\leq 2D^{*}$.

Proof:

Assume that $d_{p,\,i^{*}}$ is the maximum perpendicular distance of the relocated sensors in an optimum relocation solution to 2D-MMSM. Then we show that $\min\{d_{p,\,i_{alt}}+D_{h}(S(d_{p,\,i_{alt}}),\,d_{p,\,i_{alt}-1}+D_{h}(S(d_{p,\,i_{alt}-1})\}\leq 2D^{*}$ holds for either $i^{*}\geq i_{alt}$ or $i^{*}<i_{alt}$.

$i^{*}\geq i_{alt}$:

Obviously, we have $d_{p,\,i_{alt}}\leq d_{p,\,i^{*}}\leq D^{*}$. Then since $D_{h}(S(d_{p,\,i_{alt}})\leq d_{p,\,i_{alt}}$, we have $d_{p,\,i_{alt}}+D_{h}(S(d_{p,\,i_{alt}})\leq 2D^{*}$. 2. 2.

$i^{*}<i_{alt}$:

Since $i^{*}\leq i_{alt}$ and that $f(i)=D_{h}(S(d_{p,\,i})$ is monotonously decreasing on $i$, we have $D_{h}(S(d_{p,\,i_{alt}-1})\leq D_{h}(S(d_{p,\,i^{*}})\leq D^{*}$. Then since $D_{h}(S(d_{p,\,i_{alt}-1})\geq d_{p,\,i_{alt}-1}$ according to the algorithm, we have $d_{p,\,i_{alt}-1}\leq D^{*}$. Therefore, $d_{p,\,i_{alt}-1}+D_{h}(S(d_{p,\,i_{alt}-1})\leq 2D^{*}$ holds.

∎

Since Algorithm 10 iterates the while-loop for at most $O(\log n)$ times, we have the following theorem:

Theorem 22**.**

MMSM admits a factor-2 approximation algorithm with runtime $O(n^{2}(\log n)^{2})$.

VII Conclusion

This paper developed three algorithms for MMSM via solving decision MMSM, which are respectively with runtime $O(n\log n\log d_{max})$, $O(n^{7}L\log d_{max})$ and $O\left(R^{2}\sqrt{\frac{M}{\log R}}\log d_{max}\right)$, and maximum relocation distance $d(OPT)+2r_{max}$, $d(OPT)+r_{max}$ and $d(OPT)+r_{max}$, where $n$ is the number of sensors, $L$ is the length of input, $M$ is the length of the barrier, $d(OPT)$ is the maximum relocation distance in an optimum solution to MMSM, $d_{max}$ is the maximum distance between the sensors and the barriers, and $r_{max}=\max_{i}\{r_{i}\}$ is the maximum sensing radii of the sensors. We proved the performance guarantee for the first algorithm by giving a sufficient condition to check the feasibility of an instance of decision MMSM, and for the second (and hence the third) algorithm by rounding up an optimum fractional solution against the according LP relaxation, to a real solution of DMMSM. To the best of our knowledge, our method of rounding up a fractional LP solution is the first to round an LP solution by aggregation, and has the potential to be applied to solve other problems. In addition, we developed a factor-2 approximation by extending a previous result in paper [5]. Consequently, the performance of our first three algorithms can be improved when $r_{max}>d(OPT)$. We note that our proposed algorithms can only work for MMSM with only one barrier, and are currently investigating approximation algorithms for MMSM with multiple barriers.