On optimally solving sub-tree scheduling for wireless sensor networks with partial coverage: A branch-and-cut algorithm

Given a wireless sensor network, we consider the problem to minimize its total energy consumption over consecutive time slots with respect to communication activities. Nonempty and disjoint subsets of nodes are required to be active and connected under a tree topology configuration in the different time slots, and each network node must be active in a unique time slot. Moreover, the power required by the same pair of network nodes to communicate on the associated direct channel may vary in the different time slots. The problem has been recently introduced in the literature under the name Sub-Tree Scheduling for Wireless Sensor Networks with Partial Coverage. We focus on the exact solution of the problem. We present a branch-and-cut (BC) algorithm based on a novel integer linear programming formulation which allows avoiding the introduction of symmetries in the solution space. In particular, the algorithm relies on an efficient and nontypical separation algorithm for known valid inequalities, and on an easy-to-implement primal bound heuristic. The effectiveness of the BC algorithm is empirically shown through an extensive experimental analysis involving 300 newly generated benchmark instances with up to 200 network nodes and 8 time slots. Additionally, the experimental results show that the BC algorithm represents a valid computational tool to benchmark the performance of heuristics addressing the problem, and can be used in practice, as an heuristic solver, to tackle problem instances that are not too large.

energy balancing/duty cycling/sleep scheduling are based on the idea that network nodes may be alternatively put in active and sleep mode for a certain time interval, so as to reduce their energy consumptions in sleep mode (mode in which sensing and communication activities are interrupted). To this subclass of approaches belongs those discussed in [1,6,10,12,17,19,22,24,26]. We focus on the optimization problem introduced by [1] under the name Sub-Tree Scheduling for Wireless Sensor Networks with Partial Coverage (STSWSN-PC).
The STSWSN-PC seeks for the minimization of the total energy consumption of a WSN over consecutive time slots with respect to communication activities (e.g., of the total connectivity power costs associated with the use of a WSN over consecutive time slots). Requirements defining the problem are that nonempty and disjoint subsets of nodes have to be active and connected under a tree topology configuration in the different time slots (while the remaining nodes are temporary put into sleep mode), and that each network node must be active in a unique time slot. The operating scenario/policy assumed is the following. Sensors are deployed in the geographic area that has to be monitored. The deployment of the sensors is defined a priori according to the specific practical application at hand. Given a planning horizon T = {1, … , |T|} of |T| time slots, the nodes that are active in time slot t ∈ T perform sensing and communication activities, while the remaining nodes are put in sleep mode to save energy. In an additional round at time slot |T| + 1, all nodes become active and may communicate among themselves so that all the necessary information concerning the monitored area can be collected and elaborated. Then, the whole process is repeated iteratively for the entire lifetime of the network. In particular, the operating policy does not guarantee that the coverage level of sensors is, continuously over time, 100% of the geographic area. This is the concept of partial coverage. However, requiring that a nonempty subset of nodes have to be active in each time slot ensures a minimum level of monitoring/coverage of the area over time. Furthermore, note that the operating policy implies to set the duration of the time slots such that the information collected in time slot 1 do not become obsolete before the additional round in time slot |T| + 1. (A similar operating policy has been considered also in [23] to the aim of maximizing the coverage of the sensed area for each subset of nodes, but without considering the connectivity of the active nodes.) Finally, as for energy consumption, the power required by the same pair of network nodes to communicate on the associated direct channel may vary in the different time slots. Adasme [1] assumed that connectivity power costs may be estimated with effective prediction methods (taking into account all necessary parameters) for relatively long planning horizons (see, i.e., [4]), so that power measurements do not become invalid as soon as they are determined. For a more in-depth discussion about the motivations behind the study of the problem, and an extensive description of its technicalities, we refer the interested readers to [1].
Besides introducing the problem, an additional major contribution of [1] consists of presenting two effective meta-heuristics, based on variable neighbor search [11,18] and simulating annealing [14] paradigm, respectively, and making use of the Kruskal's algorithm [15]. The heuristics are tested on large problem instances, defined by considering up to 400 network nodes and 8 time slots, with a time limit of 2 h. According to the results obtained, the main finding of the author is that the heuristic based on variable neighbor search has to be preferred when relatively high-quality solutions (w.r.t the total (connectivity) power costs) must be computed quickly. Whereas, preference goes to the heuristic based on simulated annealing when minimizing the total power costs is the major issue. Moreover, in order to optimally solve the STSWSN-PC, and/or provide computational tools to benchmark the performance of the heuristics proposed, the author presented mixed integer quadratic/linear programming formulations for the problem, to be solved by means of state-of-the-art commercial solvers. The best results are obtained by solving a Mixed Integer Linear Programming (MILP) formulation by means of the state-of-the-art commercial MILP solver at hand.
In this study, we focus on the exact solution of the STSWSN-PC. Our overall/main contribution is the presentation of a branch-and-cut (BC) algorithm which improves the state-of-the-art w.r.t. existing exact algorithms addressing the problem. Particular contributions are: • We model the problem by means of a novel ILP formulation which allows avoiding the introduction of symmetries in the solution space. Even if the binary variables we consider are polynomial in number, the formulation is defined by an exponential number of constraints. This excludes the possibility to explicitly define the formulation and solve it directly through the MILP solver at hand, and in particular to use the solver as a black-box optimization tool. However, the formulation allows the design of a BC algorithm in which the constraints exponential in number are temporarily ignored at the beginning of the solution process, and then dynamically inserted into the formulation when violated by computed (fractional/integer) solutions. • The constraints exponential in number in the novel ILP formulation are the generalized version of the subtour elimination constraints (GSECs), introduced by [8]. By exploiting the specific features of the STSWSN-PC, we devise an efficient and nontypical separation algorithm for the GSECs that relies only on the computation of connected components. • During the solution process, state-of-the-art commercial MILP solvers usually run internal (primal bound) heuristics in order to compute, as quickly as possible, tight primal bounds and, consequently, speed up the convergence of the whole solution process. When nonredundant constraints are removed from the formulation, like in our case, the solutions computed by the internal heuristics may be infeasible. In order to make the most of the MILP solver at hand, we design an easy-to-implement primal bound heuristic and embed it into the BC algorithm. The heuristic receives in input an integer solution which is infeasible to the original problem, and makes it feasible in polynomial time. The value of the solution computed may eventually improve the current primal bound and restrict the search space.
Experimental results support the validity of the contributions and are briefly illustrated in the following. We tested the BC algorithm on 300 instances generated as described in [1], with up to 200 network nodes and 8 time slots. In particular, we allowed only single-thread runs, so as to get deterministic results, and set the time for each run to 1 h. (i) All the instances with up to 60 (80) network nodes are solved to optimality with a maximum solution time of 44 (510) s. All but 2 instances with 100 network nodes are optimally solved. (For the 2 nonsolved instances, the percentage optimality gap is about 2%.) (ii) Notably enough, the BC algorithm was always able to compute valid upper (primal) and lower (dual) bounds (even with a time limit of 150 s). In [1], with a time limit of 2 h, (i) the largest instances optimally solved consider up to 40 network nodes and 2 time slots, and (ii) feasible solutions are computed only for instances with up 70 network nodes and 4 time slots. Moreover, as discussed in Section 4.2, the experimental results show that the BC algorithm is a valid computational tool to benchmark the performance of heuristics addressing the problem, and can be used in practice, as an heuristic solver, to tackle problem instances that are not too large. The remainder of the article is organized as follows. In Section 2, we formally define the STSWSN-PC and provide the mathematical formulation that leads the basis for the branch-and-cut (BC) algorithm, which is discussed in Section 3. Experimental results are presented in Section 4, before final conclusions are drawn in Section 5.

Problem definition
Let T = {1, … , |T|} be a set of consecutive time slots of arbitrary duration. The STSWSN-PC can be defined over a sequence of undirected, weighted, complete graphs G t = (N, E t ). All the graphs share a common node set N = {1, … , n} representing the nodes of the WSN. Then, each graph G t is defined by its own set of edges E = {(i, j)|i < j, i, j ∈ N}, where edge (i, j) represents the possibility to use a direct communication channel between nodes i and j, in time slot t, at a connectivity power cost p t ij . A solution s to the problem is defined by subsets of active nodes S t ⊂ N, S t ≠ ∅, t ∈ T, such that (i) in each S t nodes are connected under a tree topology, (ii) S t′ ∩ S t′′ = ∅, t ′ ≠ t ′′ , t ′ , t ′′ ∈ T, and (iii) ∪ t∈T S t = N. Given a feasible solution s to the problem, let E t ⊆ E t be the subset of edges selected in the solution w.r.t. time slot t ∈ T, and thus corresponding to the direct communication channels ensuring the connection under a tree topology for the active nodes in S t , t ∈ T. The aim is to find a solution s associated with the minimum total power costs p(s) = ∑ t∈T ∑ (i,j)∈E t p t ij . (It is worth mentioning that the formulation presented in Section 2.2, and the branch-and-cut algorithm presented in Section 3, apply also for sparse graphs G t = (N, E t ). In fact, as pointed out in [1], complete graphs may represent sparse ones by simply penalizing the edges not to be considered in optimal solutions.) A sample instance of the problem is illustrated in Figure 1A, together with a corresponding optimal solution.

Mathematical formulation
We model the problem by means of a compact formulation that uses two sets of variables. Binary variables z t i , which are equal to 1 if node i is scheduled to be active in time slot t ∈ T, 0 otherwise, and binary variables x t ij , which model whether a direct communication channel is used between nodes i and j in time slot t ∈ T, x t ij = 1, or not, x t ij = 0. Then, define E t (S) as the subset of edges of E t having both endpoints in S ⊆ N. The formulation is as follows. The objective function (1a) minimizes the total power costs. Constraints (1b) impose that each network node has to be active in a unique time slot. Constraints (1c) ensure that the total number of edges selected for each time slot t ∈ T equals the total number of active nodes minus one. This is the necessary condition to obtain a subtree in each time slot. Consistency among the x t ij and z t i variables are imposed in constraints (1d) for each i ∈ N and t ∈ T. Coefficient (|N| − 1 − (|T| − 1)) comes from the fact that an active node can be connected to at most |N| − 1 additional active nodes in each time slot, and that at least one node has to be active in each time slot. Then, constraints (1e), the generalized version of the subtour elimination constraints (GSECs) introduced by [8], impose that any connected component resulting from an assignment of binary values to variables z t i and x t ij , t ∈ T, does not contain cycles. Thus, for any assignment of binary values to variables z t i and x t ij , t ∈ T, constraints (1e), together with constraints (1c) and (1d), guarantee the definition of subsets of active nodes S t ⊂ N, S t ≠ ∅, connected under a tree topology in each time slot t ∈ T. In particular, S t ≠ ∅ is implied by (1c). Finally, constraints (1f) and (1g) define the domains of the variables.
Modeling the problem directly on graphs G t = (N, E t ), t ∈ T, avoids introducing symmetries in the solution space. Nevertheless, the number of constraints (1e) is exponential in the cardinality of N. This excludes the possibility to explicitly define model (1) and solve it directly through a commercial Mixed-Integer Linear Programming (MILP) solver, even for relatively small instances of the problem. Thus, we designed a branch-and-cut (BC) algorithm, based on model (1), in which constraints (1e) are dynamically inserted into the formulation when violated by fractional/integer solutions.

BRANCH-AND-CUT ALGORITHM
In this section, we present the main components of the branch-and-cut (BC) algorithm we devised for solving the STSWSN-PC.
The BC algorithm considers the initial Linear Programming (LP) relaxation of model (1) defined by (1a), (1b)-(1d), and the linear relaxation of the integrality constraints (1f) and (1g). For the presentation of the components, we denote by s = (z, x) the (fractional) solution to current LP relaxation (the initial LP relaxation, eventually augmented by branching and cutting constraints). Then, we define E t ⊆ E t as the subset of edges corresponding to the direct communication channels to use in time

Static valid inequalities
In order to strengthen the initial LP relaxation, we include in it constraints (2a) and (2b), bounding respectively the minimum and maximum cardinality of the subsets of active nodes Similarly, we impose constraints bounding the maximum number of direct communication channels that can be established per time slot, (3a), and in total, (3b). ∑

Separation algorithm for the GSECs
The separation algorithm we devised is exact for integer solutions, in the sense that at least one violated GSEC is found if one exists, and heuristic when the solution to the current LP relaxation is fractional. In this latter case, when the algorithm does not compute any violated GSEC, branching is performed to remove the current fractional solution from the search space.
The main steps of the algorithm are discussed in the following.
Step 1 By applying the algorithm described in [9, p. 222], connected components (CCs) are computed for each graph H integer parameter, equal to 2 if the solution is integer, and 1 otherwise.
. This is illustrated in Figure 2, in which the fractional solution represented is relative to the sample instance described in Figure 1A.
Moreover, values (z, x) may allow the definition of CCs (eventually not containing cycles) that do violate the corresponding GSECs. This is shown in Figure 3, in which, always w.r.t. the instance described in Figure 1A, another fractional solution is depicted.
On the contrary, in case (ii), as the number of CCs is greater than 1 for at least one graph H t , t ∈ T, the integer solution is infeasible and, in particular, there must exist a connected component C ) define a cycle and, therefore, for which the corresponding GSEC is violated. In fact, let H t′ be one of the graphs for which the number of associated CCs is greater than 1.
This means that the total number of edges associated with variables x t′ ij equal to 1 should be However, constraints (1c), imposes with variables x t′ ij equal to 1. Each of these edges connect two nodes already (not directly) connected in some C t′ i ∈  t′ , defining thus a cycle. In case (ii), by applying Step 3, the algorithm is always able to compute the connected component C t * . An infeasible integer solution to the instance described in Figure 1A, including a connected component whose edges define a cycle, is illustrated in Figure 4.
Notably enough, by exploiting the specific features of the STSWSN-PC, the separation algorithm relies only on the computation of the CCs for each graph H t = (N t , E t ), t ∈ T.

Primal bound heuristic
In order to speed up the BC algorithm, we embedded into the algorithm a primal bound heuristic. The heuristic is triggered whenever an integer solution violating the GSECs is found. Again, we start from the CCs in each graph For a given t ∈ T, when the number of CCs is greater than 1, we consider the set of CCs sorted in nonincreasing order according to the cardinality of the components themselves, that is, the set we define a minimum cost spanning tree w.r.t. nodes in C t i and edges in E t (C t i ). To this aim, we apply an implementation of the Kruskal's algorithm [15]. Finally, we iteratively merge all the trees associated An infeasible integer solution for the instance described in Figure 1A. Next to the nodes (edges) are reported the nonzero values of the corresponding z t (x t ij ) variables. In time slot 1, the edges of connected components {2, 6, 7, 9} define a cycle: the GSEC associated with the connected component is violated.
with the CCs. More precisely, at iteration i < | t |, we merge the tree associated with the connected component C t i+1 with that resulting from the merge of the trees associated with connected components C t k , k ≤ i. The merge is performed by considering the cheapest edge in E t joining 1-degree nodes of the two trees. The merge is always possible as each tree with n > 1 nodes has at least two 1-degree nodes.
When a single tree spanning all the nodes in N t has been defined for each t ∈ T, a feasible solution s ′ to (1) has been computed. The value p(s ′ ) may eventually improve the current primal bound and restrict the search space.

EXPERIMENTAL ANALYSIS
We tested the BC algorithm on instances generated as described in [1]. Problem instances are completely defined by undirected, weighted, complete graphs G = (N, E t ), t ∈ T [1, section 1]. Thus, for each instance, we generated complete undirected graphs G = (N, E t ) by associating with each edge (i, j) ∈ E t an integer power connectivity cost p t ij randomly drawn form the interval (0; 1000] Ws. The magnitude of the interval allows to fairly compare the performance of the presented BC algorithm with those of the exact algorithms proposed in [1]. We considered 10 instances for each |N| ∈ {20, 40, 60, 80, 100, 120, 140, 160, 180, 200} and |T| ∈ {2, 4, 8}, for a total of 300 instances. The BC algorithm has been implemented in C++, by using CPLEX 20.1 Concert Technology, and compiled in release mode with MS Visual Studio Community 2022. The experiments have been carried out on a 64-bit Windows PC, with the Intel Xeon processor W-1250P, 4.10 GHz, and 32 GB of RAM. CPLEX built-in cuts have been used in all experiments. Due to numerical instability we set IloCplex::NumericalEmphasis = CPX ON. Moreover, we set IloCplex::ParallelMode to 1 in order to force CPLEX to always use deterministic algorithms, and parameter IloCplex::Threads has been set to 1 in order to get deterministic results. In fact, due to threads synchronization, by embedding user defined components into CPLEX, its behavior become nondeterministic. For all the other CPLEX's parameters, we kept their default values.
In order to assess the impact of the main components of the BC algorithm, and finalize its design, we have initially run some preliminary experiments on a subset of the generated instances. Then, the performance of the final version of the BC algorithm has been assessed on the full set of instances. The analysis of the results obtained is reported thereafter. Instances and instance-wise detailed results concerning the experiments discussed in Section 4.2 are publicly available [5].

Preliminary experiments
We first compared the performance of the BC algorithm by allowing or not the separation of fractional solutions by means of the algorithm described in Section 3.2, that is, the algorithm for the separation of the GSECs. We limited the performance comparison to what concerns the solution of the LP relaxation at the root node of the branch-and-bound tree. To this aim, only for this specific subset of preliminary experiments, we temporarily set IloCplex::HeurFreq = -1, preventing CPLEX to run its internal primal bound heuristics.
For the subsets of instances considered, we report in Figure 5A the geometric means of the ratios of lower bounds taken over the 10 instances of each subset. For a given subset, we computed instance by instance the ratio LB GSECs ∕LB NO-GSECs , and provided the graphical representation of the geometric mean over the 10 instances of the subset. For example, the fourth bar associated with an average ratio LB GSECs ∕LB NO-GSECs of about 1.06, above 1, means that, for the subset of instances |N| = 40; |T| = 2, lower bounds computed by applying the separation of the GSECs are consistently greater (by a factor 1.06 on average) than those computed without separating the GSECs. The results reported show that it is beneficial applying the separation of the GSECs for all the subsets but subset |N| = 20; |T| = 2. In particular, the impact of GSECs on the tightening of the lower bounds seems to decrease with the increase of |T|, allowing however to improve the bounds by about a factor of at least 1.04, on average, for |N| ≥ 60. Then, in Figure 5B we show the corresponding geometric means of the ratios of solution times needed to solve the linear relaxation of model (1) plus constraints (2) and (3). The ratios are reported only for subset of instances for which the BC algorithm, running under at least one of the two settings, required more than 1 s, on average, to solve the instances in the subset. The results depicted show that the average solution time may double by applying the separation of Computational results on instances with 40 ≤ |N| ≤ 100 -TL = 300 s. the GSECs. However, it is worth mentioning that the average solution time remains less than 7.5 s for the instances of subset |N| = 100; |T| = 8, that is, the instances associated with the greatest solution times.

|N| |T| Time Nodes Opt Gap Time Nodes Opt Gap Time Nodes Opt Gap
Having empirically shown the usefulness of applying the separation algorithm of the GSECs to cut off fractional solutions, in order to finalize the design of the BC algorithm we proceeded as follows. We derived four different variants from the BC algorithm, BC-S-H, BC-S-H, BC-S-H, and BC-S-H, by switching off: • the possibility to apply the separation algorithm of the GSECs to cut off fractional solutions at nonroot nodes of the branch-and-bound tree (S); • the possibility to apply the primal bound heuristic described in Section 3.3 (H).
For every variant, we solved the 150 instances with |N| ≤ 100 nodes. The time limit (TL) for each run was set to 300 s. Each algorithmic variant was able to solve all the instances with |N| = 20 nodes by exploring in most of the cases only the root node of the tree, and with an average computing time less than 1 s. The average results for the remaining instances with 40 ≤ |N| ≤ 100 nodes are reported in Table 1.
For each combination of number of nodes (|N|) and time slots (|T|), and each algorithmic variant, we report the average solution time (Time) in seconds, the average number of branch-and-bound nodes explored (Nodes), and the number of feasible instances solved to the optimality (Opt). Then, if any, for instances not optimally solved for which valid lower/dual and upper/primal bounds have been found, we report the average percentage optimality gap (Gap (%)) and, in brackets, the number of instances over which the average gap is computed. In particular, the gap is computed according to the formula 100 * (UB * − LB * )∕UB * , where UB * (LB * ) is the best upper (lower) bound value computed during the search. Note that each row of the table reports the aggregate results for the subset of 10 instances associated with the same values of |N| and |T|. Additionally, note that the average number of nodes explored in column "Nodes" is reported in thousands.
Looking at the results reported for instances with |N| ≥ 60, especially at the average solution times and number of instances solved to optimality, we can observe that the problem becomes more difficult to solve at the increase of the number of nodes in the network (|N|) and the number of time slots (|T|). The average number of instances solved to optimality decreases with the increase of |N| and/or |T|. Accordingly, the average solution time grows steadily. The average percentage optimality gap follows a trend similar to that of the average solution time. These considerations apply to all the algorithmic variants.
Comparing the average number of nodes explored for BC-S-H and BC-S-H against the corresponding values for BC-S-H and BC-S-H, respectively, we can see that, by always applying the separation of the GSECs, the time required to solve each node of the branch-and-bound tree increases substantially. In fact, the average number of nodes explored decreases by about one order of magnitude. This makes BC-S-H and BC-S-H more effective than the respective counterparts (BC-S-H and BC-S-H), especially w.r.t. the number of optimal solutions found. This latter consideration seems to be slightly in contrast with the average results for specific subsets of instances. For example, for instances of subset |N| = 80; |T| = 2, BC-S-H and BC-S-H compute respectively 9 and 10 optimal solutions. Similarly, BC-S-H computes one more optimal solution than BC-S-H for instances of subset |N| = 80; |T| = 8 and |N| = 100; |T| = 2. Additionally, w.r.t. subset |N| = 80; |T| = 8, BC-S-H is slightly better than BC-S-H as for both the average solution time and average percentage optimality gap (for the same number of instances not solved). Nevertheless, these small deviations from the general trend substantially depend on the different branch-and-bound trees explored by the algorithms. The overall results support the greater efficacy of BC-S-H and BC-S-H over BC-S-H and BC-S-H, respectively. Furthermore, thanks to the possibility of applying the primal bound heuristic, BC-S-H is slightly better than BC-S-H with respect to both the number of instances optimally solved and the average solution time, halving in addition the average percentage gap for the instances not solved to optimality. To some extent, when the size of the problem instances is not too large, this makes BC-S-H also suitable to be used in practice as an heuristic. We elaborate more on this in the next section.
We conclude our preliminary analysis briefly reporting on the average results that BC-S-H computes when constraints (2) and (3) are not included into the model. By considering again the instances with 40 ≤ |N| ≤ 100 nodes, and a time limit of 300 s for each run, we get the following overall results:

Global assessment
We run BC to solve the full set of generated instances with a TL of 1 h.
Results are reported in Table 2. The structure of Table 2 is similar to that of Table 1, but now the aggregate results for each combination of number of nodes (|N|) and time slots (|T|) are reported for the unique algorithmic variant BC. In particular, the average percentage optimality gap (Gap (%)) is computed over all the instances in each subset. Moreover, column (Root | Gap (%)) and (Root | Time) report the average percentage optimality gap and the average computing time, respectively, after the solution of the linear relaxation of model (1), plus constraints (2) and (3), at the root node of the branch-and-bound tree. Values in column (Root | Gap (%)) are computed according to the formula 100 * (UB * − LB root )∕UB * .
Thus, BC outperforms the exact algorithms proposed in [1] that, with a time limit of 2 h, were able to optimally solve only instances with up to 40 network nodes and 2 time slots, and to compute feasible solutions only for instances with up 70 network nodes and 4 time slots.
The average computing time required to solve the root node of the branch-and-bound tree is less than 44.2 s (see subset of instances |N| = 200; |T| = 8). Already after the solution of the root node, the average percentage optimality gap is less than 5.5% (8.5%) for instances solved to optimality with up to 100 network nodes and 4 (8) time slots. With respect to all the instances optimally solved, the average and maximum percentage optimality gap (after the solution of the root node) are respectively 3.44% and 10.47%. Therefore, BC, besides being an effective exact solution algorithm, represents a valid computational tool to benchmark the performance of heuristics addressing the problem.
Results concerning average percentage optimality gap are further elaborated in Figure 6 for instances with |N| ≥ 80 (for each subset of instances with |N| ≤ 80, the average percentage optimality gap is always less than 0.7% already with a TL of 300 s). For each value of |T| ∈ {2, 4, 8}, and each subset of instances with |N| ≥ 80, we illustrate the variation of the average percentage optimality gap at the increase of the available computing time. Even by setting the time limit to 150 s, BC is always able to compute valid primal and dual bounds. Already with a TL of 900 s, by considering all the subsets of instances with |N| ≤ 100, the average percentage optimality gap is above 0.2% only for subset |N| = 100; |T| = 8, with a value of 3.5%. Always by considering a TL of 900 s, as for the average percentage optimality gap concerning all the instances: • for |T| = 2, it is slightly above 7% only for instances with |N| = 180 nodes; • for |T| = 4, it is above 5% only for instances with |N| equal to 160, 180, and 200, respectively equal to 12.25%, 15.99%, and 15.73%; • for |T| = 8, it is less than 3.5% (24%) for all instances with |N| ≤ 100 (|N| ≤ 120).
This makes BC also suitable to be used in practice, as an heuristic solver, to address problem instances that are not too large.

CONCLUSIONS
In this study, we considered the problem to minimize the total connectivity power costs associated with the use of a wireless sensor network over consecutive time slots. Nonempty and disjoint subsets of nodes are required to be active and connected under a tree topology configuration in the different time slots, and each network node must be active in a unique time slot. Moreover, the power required by the same pair of network nodes to communicate on the associated direct channel may vary in the different time slots. The problem has been recently introduced in the literature to the aim of extending the lifetime of WSNs. We focused on the exact solution of the problem. We presented a branch-and-cut (BC) algorithm which improves the state-of-the-art w.r.t. existing exact solution algorithms, as shown by means of extensive computational experiments on 300 newly generated benchmark instances with up to 200 network nodes and 8 time slots. The BC algorithm is based on a novel Integer Linear Programming formulation which allows avoiding the introduction of symmetries in the solution space, on an efficient and nontypical separation algorithm for the generalized subtour elimination constraints, and on an easy-to-implement primal bound heuristic to restrict the search space. To the best of our knowledge, the largest problem instances optimally solved so far in the literature (with a time limit of 2 h) consider up to 40 network nodes and 2 time slots. By forcing single-thread runs, the presented BC algorithm solves to optimality instances with up to 60 (80) network nodes and 8 time slots with a maximum solution time of 44 (510) s. With a time limit of 1 h, the algorithm is able to optimally solve instances with up to 200, 200, and 140, network nodes for a number of time slots respectively equal to 2, 4, and 8. Additionally, being able to compute tight dual bounds, the BC algorithm may represent a valid computational tool to benchmark the performance of heuristics addressing the problem. Finally, even by setting the time limit to 150 s, the BC algorithm is always able to compute valid primal and dual bounds. With a time limit of 900 s, the average optimality gap is less than 3.5% for instances with up 100 network nodes and 8 time slots. In particular, when the number of time slots is 2 (4), the average percentage optimality gap is always less than 7.5% (16%). When the number of time slots is 8, the gap is less than 3.5% (24%) for instances with up to 100 (120) network nodes. This makes the BC algorithm also suitable to be used in practice, as an heuristic solver, to address problem instances which are not too large.