The conditional p-dispersion problem

Abstract

We introduce the conditional p-dispersion problem (c-pDP), an incremental variant of the p-dispersion problem (pDP). In the c-pDP, one is given a set N of n points, a symmetric dissimilarity matrix D of dimensions $n\times n$, an integer $p\ge 1$ and a set $Q\subseteq N$ of cardinality $q\ge 1$. The objective is to select a set $P\subset N\setminus Q$ of cardinality p that maximizes the minimal dissimilarity between every pair of selected vertices, i.e., $z(P\cup Q) {:}{=}\min \{D(i, j), i, j\in P\cup Q\}$. The set Q may model a predefined subset of preferences or hard location constraints in incremental network design. We adapt the state-of-the-art algorithm for the pDP to the c-pDP and include an ad-hoc acceleration mechanism designed to leverage the information provided by the set Q to further reduce the size of the problem instance. We perform exhaustive computational experiments and show that the proposed acceleration mechanism helps reduce the total computational time by a factor of five on average. We also assess the scalability of the algorithm and derive sensitivity analyses.

Appendices

A Impact of the choice of construction strategy for the set Q

In this section, we present three construction strategies (greedy, optimal and random) for the initial set Q. The greedy strategy consists of selecting the set Q in an iterative manner such that, at every iteration, one vertex is added to the solution according to its impact on the objective function. The optimal strategy consists of solving a $\texttt {pDP}{}$ by setting $p = q$ using the algorithm proposed by Contardo [13]. Note that we use one of the optimal solutions even though there might be alternative optimal solutions if there is a lot of symmetry. The third strategy consists of selecting the set Q randomly.

Table 8 presents summarized results for the construction strategies of the set Q. For each construction strategy (greedy, optimal and random), we report the average deviation in percentage from the best known solution computed as ($z^* - z^*_{best}$)/$z^*_{best}$, where $z^*$ is the optimal solution found according to a given initial set Q and $z^*_{best}$ is the best solution for a given instance independently on how Q is generated (Average $\Delta$ $z^*$ (%)), the worst deviation in percentage from the best known solution (Worst (%)), the number of best known solutions (# Best), the average computational time in seconds (Average CPU time (s)), the number of instances solved to optimality within the prescribed time limit (# Solved), and the average percentage of eliminated vertices with our graph reduction technique (Average elim. (%)). In addition, Figs. 14, 15 and 16 present the average time, the average deviation with respect to the best known solution value, and the average percentage of eliminated vertices according to the construction strategy as well as the number of instances, respectively.

By analyzing the results, we can note that randomly constructing the set Q yields the worst solutions ($-$ 74.4% on average compared to less than $-$ 2% on average for the two other strategies). In addition, the total computational time is the slowest which is due to the symmetry between the solutions because the value of the initial lower bound is the worst one. By comparing the greedy and the optimal construction strategies, one can realize that the greedy construction strategy yields better results for our set of instances. In fact, it yields the best average deviation from the best known optimal solution ($-$ 1.4% on average compared to $-$ 1.9% on average with the optimal construction) and its worst solution is better than the worst solutions with the two other construction strategies. In addition, this strategy has the lowest computational time and the highest number of instances solved to optimality within the prescribed time limit. Finally, our graph reduction technique performs best with this strategy. With our set of instances, greedily constructing the set Q outperforms both the optimal construction and the random construction as it yields the best solutions and has the lowest computational time. In practice, obtaining the set Q with a greedy construction algorithm is much faster than obtaining the set Q by solving to optimality the pDP. Therefore, it seems more practical the generate the set Q greedily.

Table 8 Impact of the construction strategy for the set Q

Fig. 14

Impact of the construction algorithm on the average time

Fig. 15

Impact of the construction algorithm on the average deviation from the best known solution

Fig. 16

Impact of the construction algorithm on the percentage of eliminated vertices

B Detailed results

In this section, we presented detailed results. Tables 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 and 24 present the detailed results for the values of $p = \{5, 10, 15, 20\}$ and $q = \{5, 20, 15, 20\}$. In each table, the first column contains the name of the instance (Instance). Then, for each construction strategy for the set Q, i.e., greedy construction, optimal construction, and random construction, we report the total computational time in seconds (Sec), the optimal solution value ($z^*$), and the number of eliminated vertices with our graph reduction technique (Elim). If no solution was found within the prescribed time limit, the cells are left blank.

Table 9 Detailed results with p = 5 and q = 5

Table 10 Detailed results with p = 5 and q = 10

Table 11 Detailed results with p = 5 and q = 15

Table 12 Detailed results with p = 5 and q = 20

Table 13 Detailed results with p = 10 and q = 5

Table 14 Detailed results with p = 10 and q = 10

Table 15 Detailed results with p = 10 and q = 15

Table 16 Detailed results with p = 10 and q = 20

Table 17 Detailed results with p = 15 and q = 5

Table 18 Detailed results with p = 15 and q = 10

Table 19 Detailed results with p = 15 and q = 15

Table 20 Detailed results with p = 15 and q = 20

Table 21 Detailed results with p = 20 and q = 5

Table 22 Detailed results with p = 20 and q = 10

Table 23 Detailed results with p = 20 and q = 15

Table 24 Detailed results with p = 20 and q = 20

C Detailed computational time with the naive algorithm

In this section, we present the total computational time for the naive and the ad hoc algorithms. Tables 25, 26, 27 and 28 present the detailed results for the values of $p = \{5, 10, 15, 20\}$, respectively. In each table, the first column contains the name of the instance (Instance). Then, for each value of q, i.e., $q = \{5, 10, 15, 20\}$, we report the total computational time in seconds used with the proposed ad hoc algorithm (ad hoc) and with the naive algorithm (naive). If no optimal solution was found within the prescribed time limit, the cells are left blank.

Table 25 Time profiles of the naive and ad hoc algorithms (p = 5)

Table 26 Time profiles of the naive and ad hoc algorithms (p = 10)

Table 27 Time profiles of the naive and ad hoc algorithms (p = 15)

Table 28 Time profiles of the naive and ad hoc algorithms (p = 20)

D Detailed computational time with increasing values of q and p

In this section, we present the total computational time for the results obtained with increasing values of q and p, that is $q, p \in \{10, 20, 40, 80\}$, and for the instances with $|N|\le 10{,}000$. Tables 29, 30, 31 and 32 present the detailed results for the values of $p = \{10, 20, 40, 80\}$, respectively. In each table, the first column contains the name of the instance (Instance). Then, for each value of q, i.e., $q = \{10, 20, 40, 80\}$, we report the total computational time in seconds. If no optimal solution was found within the prescribed time limit, the cells are left blank.

Table 29 Time profiles of the algorithm (p = 10)

Table 30 Time profiles of the algorithm (p = 20)

Table 31 Time profiles of the algorithm (p = 40)

Table 32 Time profiles of the algorithm (p = 80)