Randomized and Optimal Algorithms for k-Lifetime Dominating Set in Wireless Sensor Networks

In wireless sensor networks, rotating dominating set is an efficient method for balancing the energy consumption of nodes, and thereby extending the network operational time. This method can be abstracted as <inline-formula> <tex-math notation="LaTeX">$k$ </tex-math></inline-formula>-Lifetime Dominating Set in bipartite graph, that partitions the set of graph vertices representing sensors into <inline-formula> <tex-math notation="LaTeX">$k$ </tex-math></inline-formula> disjoint dominating sets. However, the considered problem has been proven to be NP-hard, and there is no hope of solving it in polynomial time unless P = NP. Existing studies mainly focus on developing approximation or heuristic algorithms, which usually cannot guarantee a solution for a given problem yes instance. In this study, we first propose a randomized algorithm that can generate a solution with guaranteed probability 1-<inline-formula> <tex-math notation="LaTeX">$\varepsilon $ </tex-math></inline-formula> (<inline-formula> <tex-math notation="LaTeX">$0 < \varepsilon < 1$ </tex-math></inline-formula>). Using the color coding method, we show that the randomized algorithm can be improved to guarantee the generation of a solution for a given problem yes instance in exponential time. Based on the idea of randomized partition, we further present a more practical centralized greedy algorithm, and then a distributed implementation. Simulation results indicate that the centralized algorithm can efficiently generate optimal solutions for almost all the given problem instances if the <italic>partition redundancy</italic> is above a certain limit. Compared with existing algorithm, the centralized algorithm increases the number of dominating sets by factors between 0% and 21%.


I. INTRODUCTION
Wireless sensor networks provide new applications for environmental monitoring and military surveillance. In some cases, ground access to the monitored area is difficult or dangerous, and the only way to install the sensors is to deploy them from an aircraft. The number of sensors deployed is usually higher than required because of the lack of precise sensor placement.
The sensors are charged with a battery whose energy is limited and placed once. Hence, one of the main issues in sensor networks is prolonging the network lifetime by reducing the energy consumption of the sensor nodes [1]- [3].
The associate editor coordinating the review of this manuscript and approving it for publication was Pietro Savazzi .
Node activity scheduling is a common method for saving energy. This method schedules sensor activity so that for each sensor, the active state, in which it performs its monitoring task, alternates with a low-energy sleep state. Obviously, in the sleep state, the sensor consumes much less energy than in the active state.
The set of sensors is divided into disjoint sets, such that every set completely covers all targets. These disjoint sets are activated successively such that at any moment in time, only one set of sensors is active. The sensors from the active set are in active mode, and all other sensors are in sleep mode.
The approach above can be abstracted into k-Lifetime Dominating Set in bipartite graph. Given a bipartite graph, G = (S ∪ T , E), where S represents the set of sensors and T represents the set of targets. A dominating set D ⊆ S is a subset of sensors S, such that every target t ∈ T has a neighbor in D. A k-lifetime dominating set is a partition {S 1 , S 2 , . . . , S k } of S such that every S i (1 ≤ i ≤ k) is a dominating set of T . S i is called the dominator and k is called the network lifetime. By rotating each dominating set periodically, the energy consumption of the sensors can be greatly balanced and the network lifetime can be prolonged.
This problem has been proven NP-hard. In accordance with state-of-the-art computational complexity theory, we have to consider algorithms with exponential running time to solve it optimally. However, exponential growth quickly becomes prohibitive when algorithms are run in practice. Most previous studies investigated the considered problem from the perspective of centralized approximation or heuristics, which usually cannot generate the optimal solution (a partition {S 1 , S 2 , . . . , S k } of S such that every S i is a dominating set and k is maximized), or guarantee a solution for a given problem yes instance. The study of efficiently generating an optimal solution for a given problem instance is much less developed. Moreover, in large-scale distributed systems, the use of centralized algorithms based on a global view of networks is infeasible. In this study, we mainly investigate the problem from an optimal algorithm perspective and develop algorithms that can find the optimal (not only approximate) solution practically.
First, we present a randomized R-LDSBG algorithm, where each sensor simply assigns itself to a dominator chosen uniformly at random from the set of all possible dominators. The effect of the algorithm is determined by the iteration times of the random assignment process, which can generate a solution for any given yes instance with probability 1 − (0 < < 1) if exponential iterations are permitted. Moreover, the randomized algorithm can be de-randomized and determinately generate a solution for any input yes instance. The de-randomization is obtained using the method of color coding and deterministic construction of the color coding scheme. To the best of our knowledge, this is the first time that the considered problem has been solved optimally.
The proposed de-randomized O-LDSBG algorithm guarantees an optimal solution in theory. However, this is unpractical because of its exponential iterations. Based on the idea of randomized partition, we further propose a more practical centralized greedy algorithm, C-LDSBG, to obtain the optimal solution. The assignment process in the R-LDSBG algorithm is completely random, which increases the assignment conflict and number of assignment iterations. To decrease assignment conflict, we propose two main methods. One method is to introduce an object function to evaluate the attractiveness of dominators. Each sensor assigns itself to the dominator with a probability that is positively proportional to the weight of the intersection between the set of targets monitored by the sensor and the set of targets monitored by the dominator. The intersection is weighted based on how likely it is to be monitored by another sensor during the assignment process and the size of the intersection. Another method is to conduct the assignment process in the order of the degree of sensors, from high to low. Simulation results indicate that the centralized greedy algorithm C-LDSBG can achieve optimal solutions efficiently for almost all the given instances when the redundancy degree for the partition task is more than 10. The average iteration times required to obtain the optimal solutions is approximately 450. Compared with existing algorithm, the C-LDSBG algorithm increases the number of dominators by factors between 0% and 21%.
Further, we present a distributed implementation of the centralized greedy algorithm. Each sensor simply assigns itself, in turn, to a dominator. The algorithm is completely distributed, and communication is only required to allow each sensor to know its neighbors.
The main contributions of this study and the novelty of the proposed methods are as follows.
• Using the method of color coding, we present an exact O-LDSBG algorithm that can find the optimal (not only approximate) solution for a given problem instance in theory. This problem can be solved optimally for the first time.
• Based on the idea of random partition, we develop a randomized algorithm C-LDSBG that can generate optimal solutions for almost all given problem instances in practice when the partition redundancy is above a certain limit.
• We further develop, for the first time, a distributed algorithm, D-LDSBG, for the considered problem, where each sensor can only communicate with its neighbors. The remainder of this paper is organized as follows. In Section II, we provide an overview of relevant literature. In Section III, we describe our computation model and formally define the k-Lifetime Dominating Set problem in bipartite graph. Randomized and optimal algorithms are presented in Section IV. In Section V, a centralized greedy algorithm is presented. Section VI presents a distributed greedy algorithm. In Section VII, a simulation experiment is presented. Finally, Section VIII concludes this paper.

II. RELATED WORKS
The importance of energy efficiency in wireless sensor networks has led to a plethora of studies on k-Lifetime Dominating Set.
The optimal version of k-Lifetime Dominating Set is known as the domatic partition problem. Poon et al. showed that the 3-domatic partition problem is NP-complete on planar bipartite graphs, and the domatic partition problem is NP-complete on co-bipartite graphs [4].
Based on the graph coloring method, Mahjoub and Matula solved the domatic partition problem in random geometric graph and provided up to ( + 1) disjoint (1 − ε) dominating sets on a large range of experimental graphs, where is the minimum degree of the graph [5]. They carried out further research by proposing a more practical solution to the distributed ( + 1) domatic partition problem based on the localized graph coloring method [6].
Communication in wireless sensor networks is often modeled as the so-called unit disk graph (UDG). In UDG, there is VOLUME 10, 2022 an edge between two nodes if their Euclidean distance is most one. Pemmaraju and Pirwani proposed a method of uniform partition and presented deterministic, distributed algorithms for finding a k-domatic partition of size at least a constant fraction of the largest possible (k-1)-domatic partition for any k > 1 [7]. Pandit et al. first presented a constant-factor distributed algorithm that can be implemented in O(log n) rounds of communication on the UDG of order n [8]. Yu et al. proposed another constant-factor approximation algorithm using the skyline property of uniform radius disks [9]. Misra and Mandal studied a distributed domatic partition based scheme for energy-efficient clusterhead rotation in UDG [10].
Variations of domatic partition have also been studied comprehensively. Liang studied the k-tolerant domatic partition from both algorithmic complexity and graph theoretic points of view. They showed that it is NP-complete to decide whether the k-tolerant domatic number of a bipartite graph is at least three, and presented a polynomial time algorithm that approximates the k-tolerant domatic number of a graph of order n within a factor of ((1/k + o(1)) ln n) [11]. Lee et al. demonstrated that the total 3-domatic partition problem on planar graphs is NP-complete [12]. Misra and Mandal studied the connected domatic partition problem and developed a distributed algorithm to construct a connected domatic partition with a guaranteed size [13]. Based on the connectivity decomposition method, Censor-Hillel et al. Presented a distributed algorithm for a generalization of the connected domatic partition problem [14]. Pino et al. studied domatic partition in wireless sensor networks, and introduced three local search based algorithms to increase the network lifetime, where sensors can have different initial energies [15].
Maximizing the number of disjoint dominating sets to increase the lifetime of networking while guaranteeing complete coverage of the monitored targets was considered in [16] and [17]. The problem can be abstracted into the k-Lifetime Dominating Set problem in bipartite graph. Both studies focused on the design of heuristic algorithms and did not provide any worst-case analysis or stringent bounds. A √ n-approximation algorithm for this problem was proposed in [18], where n denotes the number of targets to be monitored. Later, Pananjady et al. proposed a polynomial time ln n-approximation algorithm through suitably defined hypergraph coloring [19]. They further demonstrated a (1 + ε)-approximation algorithm for the 2-dimensional geometric case, where each sensor can monitor the circular area around itself with a given radius. However, all the above heuristic or approximate algorithms are centralized and hence inappropriate in practice. Pananjady et al. proposed an online algorithm with a competitive ratio of ln n [20] with prior knowledge of the minimum degree of the targets. Emek et al. developed an online algorithm for the problem that guarantees a polylogarithmic (O(ln 2 n)) competitive ratio [21] without prior knowledge of the minimum degree of the targets.
Maximizing the number of non-disjoint dominating sets in bipartite graph is another method to increase the lifetime of the network. Berman et al. provided a 1 + ln n approximation algorithm based on a ln n approximation to the minimum weighted set cover problem [22]. Kasbekar et al. considered a problem with an additional constraint that each sensor has information only about its neighbors [23]. They provided a distributed algorithm with an O(ln n · ln(nB)) approximation ratio, where B is the maximum battery capacity of any sensor. Recently, Ashwin et al. proved that the problem cannot be approximated within a factor of less than ln n using any polynomial time algorithm, where n is the number of targets [24]. Jia et al. considered a variant of the problem in which sensors only sense directionally, and targets require different coverage quality requirements [25]. They proposed an efficient heuristic algorithm and obtained an upper bound of the optimal solution. Table 1 summarizes the main results for k-Lifetime Dominating Set in bipartite graph. To make the running time easier to read, we use the O * -notation allowing us to omit the polynomial factors. The symbol C denotes centralized algorithm, while D denotes distributed algorithm. The symbol n denotes the number of sensors, and n denotes the number of targets, and c denotes a constant.

III. SYSTEM MODEL
In this section, we describe the model and introduce the notation used throughout this paper. Table 2 lists the symbols that are most frequently used throughout the paper.
We model the network as a bipartite graph G = (S ∪ T , E) with |S| = ns and |T | = nt. Herein, a bipartite graph is one whose vertices can be divided into two independent sets, S and T , and every edge of the graph connects one vertex in S to one vertex in T . The nt targets t 1 , t 2 , . . . , t nt with known locations must be continuously observed, and the ns sensors s 1 , s 2 , . . . , s ns are randomly deployed close to the targets. If a target t ∈ T is within the sensing range of a sensor s ∈ S, then there is an edge (s, t) ∈ E between s and t. We call s can dominate (monitor) t. Let D ⊆ S be a subset of S. If every vertex of T is dominated by some vertex of D, then D dominates T .
As we assume that the number of sensors deployed in the field is much greater than the optimum required to perform the monitoring task, an important method of prolonging the network lifetime consists in scheduling the sensor node activity to alternate between active mode and sleep mode [16]- [18]. Assume that each sensor can be active for a unit time of 1. That is, if all sensors are continuously active, then the network lifetime is 1. Assume that all sensors initially have the same amount of power, and their energy depletes at the same rate. To achieve a lifetime of k, the sensors are organized into k disjoint groups (dominators) At any moment in time, only one such group is active for monitoring the targets and consumes energy, while the other groups are in sleep mode with no energy consumption.
The formal definition of the considered problem is described as follows.

k-Lifetime Dominating Set in bipartite graph
If a partition (S 1 , S 2 , . . . , S k ) of S exists such that every dominator S i (1 ≤ i ≤ k) can dominate T , then the given problem instance is called a yes instance. (S 1 , S 2 , . . . , S k ) is called a k-partition of S. Finding a partition {S 1 , S 2 , . . . , S k } of S such that every dominator can dominate T and k is maximized is called the optimal version of the considered problem.
If |E| − k * |T | > 0, then partition redundancy exists for the partition task and the redundancy degree is |E| − k * |T |. Suppose that a sensor s is assigned to dominator S i . If N (s) ∩ N (S i − {s}) = ∅, then we say that there exists assignment conflict in the assignment for s, and the conflict degree is See the problem instance of k-Lifetime Dominating Set in bipartite graph in Fig. 2. The instance has eight sensors S = {s 1 , s 2 , s 3 , s 4 , s 5 , s 6 , s 7 , s 8 }, and two targets T = {t 1 , t 2 }. Suppose that k is set to 3. Suppose that s 1 , s 2 , and s 3 are assigned to dominator S 1 , s 4 and s 5 are assigned to dominator S 2 , and s 6 , s 7 , and s 8 are assigned to dominator S 3 . Because is a 3-partition of S and this problem instance is a yes instance. The number of edges |E| is nine, and the number of targets |T | is two. Because |E|−k * |T | = 9−3 * 2 = 3 > 0, partition redundancy exists for the partition task, and the redundancy degree is 3. Because s 1 is assigned to the dominator S 1 and N (s 1 ) ∩ N (S 1 − {s 1 }) = {t 1 } = ∅, there exists assignment conflict in the assignment for s 1 , and the conflict degree is 1.
Herein, we are concerned only with the sensor node scheduling mechanism and do not address the problem of selecting which protocol is used for data gathering or node synchronization.

IV. RANDOMIZED ALGORITHM
In this section, we propose a simple and randomized algorithm for the k-Lifetime Dominating Set problem in bipartite graph, and then show how to de-randomize it.
The randomized R-LDSBG algorithm shown in Fig. 1 just assigns each sensor to a dominator chosen uniformly at random. It makes few assumptions about the networks and is simple enough to be implemented. In addition, the expected performance can be guaranteed because the performance of the algorithm is proportional to the iteration times lt of the random partition process. Let lt be Nk k|T | , with Proof: Let (S 1 ,. . . , S k ) be a partition of the set of sensors S such that every dominator S i dominates T . Note that for We say that the sensors in D are properly partitioned by a k-partition (P 1 , . . . , P k ) of S if for two sensors v 1 , v 2 ∈ D, the following conditions hold: If we partition the sensors in S into k disjoint subsets randomly, then the probability that the sensors in D are properly partitioned is not less than k! k k|T | . The R-LDSBG algorithm, shown in Fig. 1, is based on these ideas. According to the discussion above, each random k-partition of S has a probability of at least k! k k|T | to obtain a solution. Because Step 2 loops Nk k|T | times with a probability of at least 1 − (1 − k! k k|T | ) Nk k|T | , the partition constructed in Step 2.1, is a solution. Since lim n→+∞ (1 + 1/n) n = e, (1 − k! k k|T | ) Nk k|T | < e −N . Note that N = ln(1/ε) . It follows In the following, we illustrate how the R-LDSBG algorithm works with the problem instance shown in Fig. 2. The instance has eight sensors S = {s 1 , s 2 , s 3 , s 4 , s 5 , s 6 , s 7 , s 8 }, and two targets T = {t 1 , t 2 }. Suppose that k is set to three, and the iteration time lt is 1. In Step 2.1, each sensor is randomly assigned to some dominator. Suppose that s 1 , s 2 , and s 5 are assigned to dominator S 1 , s 3 and s 4 are assigned to dominator S 2 , and s 6 , s 7 , and s 8 are assigned to dominator S 3 . Since S 1 cannot dominate all the targets T , the algorithm returns ''no''.
We further show that the random partition process can determinately generate a solution for a given problem yes instance by deterministic construction of the h-color coding scheme. We first briefly introduce this technique.   Consider the execution of Steps 2.1-2.4 on this particular k|T |-coloring f 0 . Given a k-partition P = (P 1 , . . . , P k ) of the k|T | colors, we say that P is a proper partition of k|T | colors if, for any two sensors v 1 , v 2 ∈ D, the following conditions hold: Note that for any two sensors v 1 , v 2 ∈ D, f 0 (v 1 ) = f 0 (v 2 ). Moreover, Step 2.2 enumerates all k-partition of the k|T | colors. Therefore, at least one partition P = (P 1 , . . . , P k ) of the k|T | colors from Step 2.2 is a proper partition. Suppose now we have the proper partition P = (P 1 , . . . , P k ). Then, the corresponding k-partition of S constructed in Step 2.3 is obviously a solution for the considered problem and is returned by Step 2.4 of O-LDSBG algorithm in Fig. 3.
In the following, we show how the O-LDSBG algorithm works using an example in In Step 1, a 6-color coding scheme F for D is constructed. According to Lemma 4.2, at least some 6-color coding f 0 in F colors the sensors in D properly: for any two sensors in D, they will be assigned different colors under f 0 . Suppose that Step 2 is conducted under the 6-color coloring f 0 . Now, we are ready to find a proper partition of the 6 colors into k = 3 disjoint groups: for any two sensors s i , s j in D with i = j and 1 ≤ i, j ≤ 8, if s i , s j belong to the same dominator in {D 1 , D 2 , D 3 }, then the color of s i and the color of s j belong to the same group, otherwise ( s i , s j belong to different dominators), the color of s i and the color of s j belong to different groups. Note that Step 2.2 enumerates all the 3-partition of the 6 colors. Hence, at least one 3-partition P = (P 1 , . . . , P 3 ) of the 6 colors is a proper partition. Suppose that the execution of Step 2.2 is on this proper partition P . Subsequently, the corresponding 3-partition {S 1 , S 2 , S 3 } of S constructed in Step 2.3 satisfies D i ⊆ S i with 1 ≤ i ≤ 3. Clearly {S 1 , S 2 , S 3 } is a solution for the given instance.
Noth that algorithm O-LDSBG takes exponential time and is infeasible in practice.

V. CENTRALIZED GREEDY ALGORITHM
In this section, based on the idea of randomized algorithm, we provide a more practical centralized and randomized algorithm to obtain the optimal solution for a given instance of the k-Lifetime Dominating Set problem in bipartite graph.
Assume that each sensor has location determination capabilities and can determine which targets of interest it will be capable of monitoring. The sensors send to the base station (BS) their ID numbers and the targets monitored. Then, the BS executes the sensor scheduling algorithm and broadcasts the schedule information. Finally, every sensor schedules itself for active/sleep modes.
The pseudocode of the greedy algorithm, C-LDSBG, is shown in Fig. 4. This algorithm is based on the idea of the random algorithm shown in Fig. 1. The random algorithm indicates that the probability of obtaining a solution is proportional to the iteration times of the partition process. If exponential iterations of the partition process are permitted, a solution can be determinately constructed. But, to generate a solution determinately, the iteration times must be huge, which is unpractical. In the greedy algorithm, we use the iteration times lt as the input. The value of lt is balanced between the running times and solution effectiveness. Moreover, the assignment process in the random algorithm is completely random, which increases the number of iterations required to obtain the right partition. In the greedy algorithm, an object function is introduced to evaluate the attractiveness of each dominator to unassigned sensors. The key point is that an unsigned sensor is favored to be assigned to a dominator achieving covering more sparsely uncovered targets.
The algorithm takes as the input parameters S−the set of sensors, T −the set of targets, k−the number of dominators, and lt−the iteration times of the random partition process. The greedy algorithm returns the set of dominators (S 1 , . . . , S k ).
At the beginning of each recursion of the algorithm, all the sensors in S are selected into C, the set of available sensors, and every dominator S i is set to be empty. The greedy algorithm iteratively executes the process of random partition from Step 1.2. Once a right partition is obtained, the algorithm exits the recursion and returns the set of dominators in Step 1.3. One sensor is assigned to some dominator from the set of sensors S in each iteration of Step 1.2. All sensors from S are assigned to some dominator S i after the iteration of Step 1.2. The assignment process for sensors is conducted in the order of the degree of sensors, from high to low, which is helpful for decreasing the assignment conflict.
At each iteration of Step 1.2, a sensor s ∈ C whose degree is the highest in C is assigned to some dominator S j . The sensor with the highest degree is found at the beginning of each iteration of Step 1.2. Every variable a[i] is set to zero, which is used to store a value representing the contribution of the unassigned sensor s to the dominator S i . In Step 1.2.3, for all dominators S i and the given unassigned sensor s, the values of the objective function f are calculated. The objective function for dominator S i and sensor s is given by Step 1.2.9, the sensor s is assigned to some dominator S j according to the probability using the roulette method.
In Step 1.3, if every dominator S i can dominate all targets, then the algorithm returns the right partition (S 1 , . . . , S k ). If Step 1 cannot generate a right partition, then we assume that the input instance is a no instance, and return ''no such partition exists''.
For given s and S i , f (s, S i ) can be calculated in time |S||T |. Hence, Step 1.2.3 can be finished in time k|S||T |. It follows that Step 1.2 can be finished in time k|S| 2 |T |. Therefore, the C-LDSBG algorithm requires O(lt · k · ns 2 · nt) time, where ns is the number of sensors, and nt is the number of targets.

VI. DISTRIBUTED GREEDY ALGORITHM
In this section, we give a distributed implementation of the centralized greedy algorithm.
The distributed algorithm makes some assumptions about the network: 1. Sensor synchronization has been realized by MAC protocol; 2. Every sensor knows the the parameter k; 3. Every sensor can determine the set of targets it is able to monitoring and recognize them by geographic coordinate; 4. Every sensor has a unique ID number taken from the set of integers {1, 2, . . . , ns}, where ns is the number of sensors; 5. Every sensor can communicate with its neighbors. For two sensors s 1 , s 2 ∈ S, if s 1 and s 2 dominate a common target, then s 1 is the neighbor of s 2 and vice versa.  Each sensor s stores two tables. Table 1 is a matrix of k × |N (s)|, and Table 2 is a matrix of 1×|N (s)|. Herein, N (s) denotes the set of targets that are dominated by s. Table 1 for sensor s stores the domination information of every target t ∈ N (s). If the value of entry in row i ∈ {1, . . . , k} and column j ∈ {1, . . . , |N (s)|} is 1, then it indicates that the target j is dominated by the dominator S i . All entries are initialized to 0 and refreshed in the D-LDSBG algorithm (Fig. 6). Table 2 stores the degree d(t) of every target t monitored by s. All entries are set to 0 and then updated by algorithm Initialization in Fig. 5. At Step 1.1.1 in the algorithm Initialization, the sensor s receives message from its neighbor sensor ss. The message includes the ID number of sensor ss, and the targets i monitored by ss. According to the message, the sensor s renews its Table 2: the value of the entry in column i is added by one. The D-LDSBG algorithm is initiated at time tm = 0. When tm < s indicating that it is not the time slot of s for assignment, sensor s receives a message from its neighbor ss. The message includes the ID number of sensor ss, targets i monitored by ss, and dominator j assigned to ss. According to the message, sensor s renews its Table 2: the value of the entry in column i is subtracted by one. Table 1 is renewed using the following method: change the entry in row j, column i, from 0 to 1. When it is the time slot of sensor s for assignment, for all dominators S i , the values of the objective function f are calculated. The object function for the dominator S i is given by f (s, The sensor s is assigned to the dominator S i such that f (s, S i ) is the largest over all dominators (S 1 , . . . , S k ).
Note that d(t), N (s), and N (S i ) can be obtained directly from Table 2 or Table 1. Hence, it is easy to see that the algorithm requires |S| 2 |T | 2 time. After the assignment phase, every sensor s is assigned to some dominator S i (1 ≤ i ≤ k) and knows the number i. Sensor s will schedule itself for the active mode from time i-1 to time i and communicate with other sensors by broadcasting.

VII. SIMULATION
In this section, we evaluate the performance of our centralized greedy algorithm, C-LDSBG, for k-Lifetime Dominating Set in bipartite graph. The evaluation is conducted on a PC with a 2.67GHz Inter Core i5 CPU and 8GB main memory.
The problem instances are created as follows. Given the number of sensors |S|, number of targets |T |, and number of edges |E|, a bipartite graph G(S ∪ T , E) is created, where the edges are chosen uniformly at random from all possible sensor-target pairs. A sensor s can dominate a target t if s has an edge connecting it with t. If the degree of some vertex s ∈ S is zero, then the topology G is discarded, and a new topology is generated. We choose this approach for generating topology as opposed to an approach where nodes are in Euclidean space and sensor nodes sense target nodes within a radius of their location because the latter limits the variety of applications.
In the simulation, we consider the following tunable parameters: ns, the number of sensor nodes; nt, the number of target nodes; md, minimum degree of sensor nodes; m, the number of edges; k, the preset number of dominators for a given problem instance; lt, the iteration times.

A. PERFORMANCE IN ACHIEVING OPTIMAL SOLUTION
The effectiveness of the proposed algorithm is proportional to the number of iterations. Thus, we focus on showing how the iteration times needed to generate one solution are affected by different parameters and the average iteration times for different network instances. For any given instance, we set the number of dominators k equal to the minimum degree of the target nodes. Because the optimum number of dominators for any problem instance cannot be larger than the minimum degree of the target nodes, our algorithm actually returns the optimal solution for any given instance in the simulation.
In the first experiment, we provide an intuition of the iteration times needed to obtain an optimal solution in 50 network instances. The number of sensor nodes ns is 100, number of target nodes nt is 10, and number of edges m is set to 250. Fig. 7 plots the iteration times when k does not exceed 22. As can be observed, the iteration times vary between 1 and 7. In most cases, our algorithm can return the optimal partition with iteration time of 1. When k is 23, as shown  in Fig. 8, the iteration times increase. In most instances, the iteration times are more than 1, and the average iteration times is approximately 8. In the worst case, the iteration times are 49. Fig. 9 shows the distribution of iteration times when k is 24. It can be saw that the iteration times increase dramatically. The average iteration times is approximately 450, and 3160 iteration times are required to obtain the optimal partition for the hardest instance. Fig. 10 shows the impact of iteration times lt on the probability of getting an optimal solution successfully. For every value of the iteration times, we repeat the experiment 20 times and count the times of returning an optimal solution successfully. As we can observe, the probability of generating an optimal partition increases as the iteration times of partition process increase. When the iteration time is bounded by 1, three instances return optimal solutions, and the average probability of getting one solution is 0.15. When the iteration times are bounded by 50, only one instance cannot return one solution.
In the following set of experiments, several factors are studied determining the minimum iteration times guaranteeing an optimal solution for a given instance. For each parameter setup, we generate ten network topologies and report the average results. Fig. 11 plots the iteration times when the number of dominators k is changed. As we can see, the iteration times increase slowly when the value of k is no more than 22. But  after k exceeds 22, the iteration times needed to generate an optimal solution increase rapidly. The increase in iteration times is proportional to k. This is expected, since with the increase of the value of k, the algorithm has less partition redundancy that can be utilized to get the right partition for given instance.
In Fig. 12, we present the average iteration times when the number of sensors changes between 90−110 in increments of 5. As shown in Fig. 6, the decrease in iteration times is proportional positively to the number of sensor nodes. With an increase in the number of sensor nodes, the average degree of the sensor nodes decreases. Thus, the probability of having assignment conflict decreases, which makes it easier for the random partition procedure to obtain a right partition.
In Fig. 13, we measure the iteration times when the number of targets varies between 8 and 12. The iteration times increase as the number of targets increases. With an increase in the number of target nodes, for each dominator, more sensor nodes are required to realize full domination. Thus, the probability of having assignment conflict increases, which makes it more difficult for the random partition process to obtain a right partition. Fig. 14 shows the convergence of the iteration times with the number of edges in the network instances. As we can see, the iteration times decrease with the increase of number of edges. The reason is that, with the increase of edges, the   algorithm has more partition redundancy that can be utilized to get the right partition. Fig. 15 plots the iteration times when the minimum degree of the sensors changes. As we can see, the iteration times increase with the increase of minimum degree of sensors. This is can be expected, since with the increase of minimum degree of the sensors, the probability of having assignment conflict is increased. Consequently, it is more difficult for the random partition procedure to get a right partition.

B. PERFORMANCE COMPARED WITH R-LDSBG
The performance of the centralized greedy algorithm C-LDSBG in obtaining the problem solution is compared  with the performance of the random algorithm R-LDSBG. Because the iteration times lt are decisive for the effectiveness of obtaining a solution for both C-LDSBG and R-LDSBG, we use iteration times to evaluate the performance.
We provide an overview of the iteration times lt required to obtain the problem solution in 200 network instances. The number of sensors is set to 100, and the number of targets is set to 10, and number of edges is set to 250. The minimum degree of the target nodes mt is set to 15, and the number of dominators k is set to mt − 5. The upper bound on iteration times is set to 5000. For every instance, Algorithm C-LDSBG returns the problem solution successfully with iteration time of 1. The R-LDSBG algorithm successfully returns problem solutions for 53 instances, but fails to get problem solutions for the other 147 instances. For the 53 instances, the average iteration times required to obtain the solution is 2774.

C. BENCHMARKING THE HEURISTIC ALGORITHM MCCH
Our algorithm, C-LDSBG, serves for benchmarking the heuristic algorithm MCCH by Slijepcevic and Potkonjak [16], indicating the quality of their solutions. The MCCH approach favors to select a sensor into current dominator that dominates the largest number of sparsely dominated targets. The heuristic algorithm MCCH is effective and easy to be implemented. It has time complexity O(n 2 ), where n is the number of sensors in the network. Compared to other heuristic algorithms for k-Lifetime Dominating Set in bipartite graph, MCCH has lower execution time.
For a given problem instance, we compare the number of dominators produced by the MCCH algorithm with the maximum number of dominators (optimal solutions) produced by our C-LDSBG algorithm. We provide an intuition of the quality of the solutions produced by the MCCH algorithm in 250 network instances. For a given instance, the parameter k is set to the minimum degree of the target nodes. Hence, the proposed C-LDSBG algorithm returns the optimal solution for any given instance. The results are shown in Fig. 16. For almost 30 percent of the 250 problem instances, the heuristic algorithm MCCH returns optimal solutions. In the worst case, the number of dominators computed by the heuristic algorithm MCCH is four less than the maximum number of dominators.

VIII. CONCLUSION
We concentrate on the design of efficient algorithms that generate optimal solutions determinately for the k-Lifetime Dominating Set problem in bipartite graph both in theory and in practice. We provide a simple algorithm that just partitions the sensors into groups randomly. We prove that the random algorithm can guarantee a solution using color coding. However, it takes exponential time, which is unpractical. Based on the idea of random partition, we then present a more practical centralized greedy algorithm which keep a balance between the running time and solution effectiveness. We further present a distributed version of the centralized algorithm where each sensor can only communicate with its neighbors. To the best of our knowledge, this is the first distributed algorithm for the considered problem. Simulation findings demonstrate that the centralized algorithm can achieve optimal solutions for almost all given instances efficiently when the redundancy degree is no less than 10. Finally, our algorithms also serve for benchmarking heuristic algorithms. However, the proposed centralized algorithm is unpractical when partition redundancy is below a certain limit.
One challenge is to efficiently achieve optimal solutions for problem instances when partition redundancy is below a certain limit. Another interesting direction for further work is to conduct research on the application of evolutionary computation algorithms [27], [28] to the considered problem.