An Improved Exact Algorithm for Least-Squares Unidimensional Scaling

Given n objects and an n × n symmetric dissimilarity matrix D with zero main diagonal and nonnegative off-diagonal entries, the least-squares unidimensional scaling problem asks to find an arrangement of objects along a straight line such that the pairwise distances between them reflect dissimilarities represented by the matrixD. In this paper, we propose an improved branchand-bound algorithm for solving this problem. The main ingredients of the algorithm include an innovative upper bounding technique relying on the linear assignment model and a dominance test which allows considerably reducing the redundancy in the enumeration process. An initial lower bound for the algorithm is provided by an iterated tabu search heuristic. To enhance the performance of this heuristic we develop an efficient method for exploring the pairwise interchange neighborhood of a solution in the search space. The basic principle and formulas of the method are also used in the implementation of the dominance test. We report computational results for both randomly generated and real-life based problem instances. In particular, we were able to solve to guaranteed optimality the problem defined by a 36 × 36Morse code dissimilarity matrix.


Introduction
Least-squares (or  2 ) unidimensional scaling is an important optimization problem in the field of combinatorial data analysis.It can be stated as follows.Suppose that there are  objects and, in addition, there are pairwise dissimilarity data available for them.These data form an  ×  symmetric dissimilarity matrix,  = (  ), with zero main diagonal and nonnegative off-diagonal entries.The problem is to arrange the objects along a straight line such that the pairwise distances between them reflect dissimilarities given by the matrix .Mathematically, the problem can be expressed as min Φ () = where  denotes the vector ( 1 , . . .,   ) and   ,  ∈ {1, . . ., }, is the coordinate for the object  on the line.We note that two (or even more) objects may have the same coordinate.In the literature, the double sum given by ( 1) is called a stress function [1].
Unidimensional scaling and its generalization, multidimensional scaling [1,2], are dimensionality reduction techniques for exploratory data analysis and data mining [3].The applicability of these techniques has been reported in a diversity of fields.In recent years, unidimensional scaling has found new applications in several domains including genetics, psychology, and medicine.Caraux and Pinloche [4] developed an environment to graphically explore gene expression data.This environment offers unidimensional scaling methods, along with some other popular techniques.Ng et al. [5] considered the problem of constructing linkage disequilibrium maps for human genome.They proposed a method for this problem which is centered on the use of a specific type of the unidimensional scaling model.Armstrong et al. [6] presented a study in which they evaluated interest profile differences across gender, racial-ethnic group, and employment status.The authors used two measures of profile similarity, the so-called  correlation and Euclidean distances.In the former case, unidimensional scaling appeared to be a good model for interpreting the obtained results.Hubert and Steinley [7] applied unidimensional scaling to analyze proximity data on the United States Supreme Court time, which is an improvement over a standard ( 3 )-time approach from the literature.The same formulas are also used in the dominance test.We present the results of empirical evaluation of our branch-and-bound algorithm and compare it against the better of the two branch-and-bound algorithms of Brusco and Stahl [13].The largest UDSP instance that we were able to solve with our algorithm was the problem defined by a 36 × 36 Morse code dissimilarity matrix.
The remainder of this paper is organized as follows.In Section 2, we present an upper bound on solutions of the UDSP.In Section 3, we outline an effective tabu search procedure for unidimensional scaling and propose a method for exploring the pairwise interchange neighborhood.Section 4 gives a description of the dominance test for pruning nodes in the search.This test is used in our branch-and-bound algorithm presented in Section 5.The results of computational experiments are reported in Section 6.Finally, Section 7 concludes the paper.

Upper Bounds
In this section, we first briefly recall the bounds used by Brusco and Stahl [13] in their second branch-and-bound algorithm.Then we present a new upper bounding mechanism for the UDSP.We discuss the technical details of the procedure for computing our bound.We choose a variation of this procedure which yields slightly weakened bounds but is quite fast.
Proof.The inequality follows from Proposition 1 and the fact that Ũ ⩾  * .
One point that needs to be emphasized is that   strengthens the first bound proposed by Brusco and Stahl.
The equality in the previous chain of expressions comes from the choice of   and our assumption on (), whereas the inequality is due to the fact that   ⩽ 0 for each  = 1, . . .,  − .
As an example, we consider the following 4 × 4 dissimilarity matrix borrowed from Defays [12]: The same matrix was also used by Brusco and Stahl [13] to illustrate their bounding procedures.From Table 2

Tabu Search
As it is well known that the effectiveness of the bound test in branch-and-bound algorithms depends on the value of the best solution found throughout the search process.A good strategy is to create a high-quality solution before the search is started.For this task, various heuristics can be applied.Our choice was to use the tabu search (TS) technique.It should be noted that it is not the purpose of this paper to investigate heuristic algorithms for solving the UDSP.Therefore, we restrict ourselves merely to presenting an outline of our implementation of tabu search.
For  ∈ Π, let   denote the permutation obtained from  by interchanging the objects in positions  and .The set  2 () = {  | ,  = 1, . . ., ,  < } is the 2-interchange neighborhood of .At each iteration, the tabu search algorithm performs an exploration of the neighborhood  2 ().A subset of solutions in  2 () are evaluated by computing Δ(, , ) = (  ) − ().In order to get better quality solutions we apply TS iteratively.This technique, called iterated tabu search (ITS), consists of the following steps: (1) initialize the search with some permutation of the objects; (2) apply a tabu search procedure.Check if the termination condition is satisfied.If so, then stop.Otherwise proceed to (3); (3) apply a solution perturbation procedure.Return to (2).
In our implementation, the search is started from a randomly generated permutation.Also, some data are prepared to be used in the computation of the differences Δ(, , ).We will defer this issue until later in this section.In step (2) of ITS, at each iteration of the TS procedure, the neighborhood  2 () of the current solution  is explored.The procedure selects a permutation   ∈  2 (), which either improves the best available objective function value so far or, if this does not happen, has the largest value of Δ(, , ) among all permutations   ∈  2 () for which the objects in positions  and  are not in the tabu list.The permutation   is then accepted as a new current solution.The number of iterations in the tabu search phase is bounded above by a parameter of the algorithm.The goal of the solution perturbation phase is to generate a permutation which is employed as the starting point for the next invocation of the tabu search procedure.This is achieved by taking the current permutation and performing a sequence of pairwise interchanges of objects.Throughout this process, each object is allowed to change its position in the permutation at most once.At each step, first a set of feasible pairs of permutation positions with the largest Δ values is formed.Then a pair, say (, ), is chosen randomly from this set, and objects in positions  and  are switched.We omit some of the details of the algorithm.Similar implementations of the ITS technique for other optimization problems are thoroughly described, for example, in [21,22].We should note that also other enhancements of the generic tabu search strategy could be used for our purposes.These include, for example, multipath adaptive tabu search [23] and bacterial foraging tabu search [24] algorithms.
In the rest of this section, we concentrate on how to efficiently compute the differences Δ(, , ).Certainly, this issue is central to the performance of the tabu search procedure.But more importantly, evaluation of pairwise interchanges of objects stands at the heart of the dominance test, which is one of the crucial components of our algorithm.As we will see in the next section, the computation of the Δ values is an operation the dominance test is based on.
Brusco [19] derived the following formula to calculate the difference between (  ) and (): Using (11), Δ(, , ) for all permutations in  2 () can be computed in ( 3 ) time.However, this approach is actually too slow to be efficient.In order to describe a more elaborate approach we introduce three auxiliary  ×  matrices  = (  ),  = (  ), and  = (  ) defined for a permutation  ∈ Π.
Let us consider an object  = ().The entries of the th row of the matrices  and  are defined as follows: if  < , then Turning now to the matrix , we suppose that  = ().Then the entries of  are given by the following formula: Unlike  and , the matrix  is symmetric.We use the matrices , , and  to cast (11) in a form more suitable for both the TS heuristic and the dominance test.
Finally, the third term in (11), ignoring the factor of 4, can be rewritten as It is easy to see that the first sum in ( 14) is equal to  (),+1 , each of the next two sums is equal to  ()() , and the last sum is equal to  (),−1 .After simple manipulations, we arrive at (13).
Formula (13) and the previous described procedure for updating matrices , , and  lie at the core of our implementation of the TS method.The matrices , , and  can be initialized by applying the formulas (15)-( 18) and (12) with respect to the starting permutation.The time complexity of initialization is ( 2 ) for  and , and ( 3 ) for .The auxiliary matrices , , and  and the expression (13) for Δ(, , ) are also used in the dominance test presented in the next section.This test plays a major role in pruning the search tree during the branching and bounding process.

Dominance Test
As is well known, the use of dominance tests in enumerative methods allows reducing the search space of the optimization problem of interest.A comprehensive review of dominance tests (or rules) in combinatorial optimization can be found in the paper by Jouglet and Carlier [25].For the problem we are dealing with in this study, Brusco and Stahl [13] proposed a dominance test for discarding partial solutions, which relies on performing pairwise interchanges of objects.To formulate it, let us assume that  = ((1), . . ., ()),  < , is a partial solution to the UDSP.The test checks whether Δ(, , ) > 0 for at least one of the positions  ∈ {1, . . .,  − 1}.If this condition is satisfied, then we say that the test fails.In this case,  is thrown away.Otherwise,  needs to be extended by placing an unassigned object in position  + 1.The first condition in our dominance test is the same as in the test suggested by Brusco and Stahl.To compute Δ(, , ), we use subsets of entries of the auxiliary matrices , , and  defined in the previous section.Since only the sign of Δ(, , ) matters, the factor of 4 can be ignored in (13), and thus Δ  (, , ) = Δ(, , )/4 instead of Δ(, , ) can be considered.From (13) we obtain We also take advantage of the case where Δ  (, , ) = 0. We use the lexicographic rule for breaking ties.The test outputs a "Fail" verdict if the equality Δ  (, , ) = 0 is found to hold true for some  ∈ {1, . . .,  − 1} such that () > ().Indeed,  = ((1), . . ., ( − 1), (), ( + 1), . . ., ()) can be discarded because both  and partial solution   = ((1), . . ., ( − 1), (), ( + 1), . . ., ()) are equally good, but  is lexicographically larger than   .
We note that the entries of the matrices , , and  used in (19) can be easily obtained from a subset of entries of , , and  computed earlier in the search process.Consider, for example,  ()() in (19).It can be assumed that  ∈ {1, . . ., − 2} because if  =  − 1, then  ()() = 0.For simplicity, let () =  and ( − 1) = .To avoid ambiguity, let us denote by   the matrix  that is obtained during processing of the partial solution ((1), . . ., ( − 2)).The entry   () of   is calculated by (temporarily) placing the object  in position  − 1.Now, referring to the definition of , it is easy to see that  () =   () +  ()   .Similarly, using formulas of types (15) and (17), we can obtain the required entries of the matrices  and .Thus (19) can be computed in constant time.The complexity of computing Δ  (, , ) for all  is ().The dominance test used in [13] relies on (11) and has complexity ( 2 ).So our implementation of the dominance test is significantly more time-efficient than that proposed by Brusco and Stahl.In order to make the test even more efficient we, in addition, decided to evaluate those partial solutions that can be obtained from  by relocating the object () from position  to position  ∈ {1, . . .,  − 2} (here position  =  − 1 is excluded since in this case relocating would become a pairwise interchange of objects).Thus, the test compares  against partial solutions   = ((1), . . ., ( − 1), (), (), . . ., ( − 1)),  = 1, . . .,  − 2. Now suppose that  and   are extended to -permutations p ∈ Π and, respectively, p ∈ Π such that, for each  ∈ { + 1, . . ., }, the object in position  of p coincides with that in position  of p .Let us define   to be the difference between ( p ) and ( p).This difference can be computed as follows: The previous expression is similar to the formula (6) in [19].For completeness, we give its derivation in the Appendix.We can rewrite (20) using the matrices  and .
The partial solution  is dominated by   if   > 0. Upon establishing this fact for some  ∈ {1, . . .,  − 2}, the test immediately stops with the rejection of .Of course, like in the case of ( 13), a factor of 4 in ( 21) can be dropped.The computational overhead of including the condition   > 0 in the test is minimal because all the quantities appearing on the right-hand side of ( 21), except  (),1 , are also used in the calculation of Δ  (, , ) (see (19)).Since the loop over  needs to be executed the time complexity of this part of the test is ().Certainly, evaluation of relocating the last added object in  gives more power to the test.Thus our dominance test is an improvement over the test described in the Brusco and Stahl [13] paper.

A Branch-and-Bound Algorithm
Our approach to the UDSP is to start with a good initial solution provided by the iterated tabu search heuristic invoked in the initialization phase of the algorithm and then proceed with the main phase where, using the branch-and-bound technique, a search tree is built.For the purpose of pruning branches of the search tree, the algorithm involves three tests: (1) the upper bound test (based on   ); (2) the dominance test; (3) the symmetry test.The first two of them have already been described in the prior sections.The last one is the most simple and cheap to apply.It hinges on the fact that the values of the objective function  at a permutation  ∈ Π and its reverse p defined by p() = ( −  + 1),  = 1, . . ., , are the same.Therefore, it is very natural to demand that some fixed object in , say , being among those objects that are assigned to the first half of the positions in .More formally, the condition is  ⩽ ⌈/2⌉ where  is such that () = .If this condition is violated for  = ((1), . . ., (⌈/2⌉)) , then the symmetry test fails, and  is discarded.Because of the requirement to fulfill the previous condition, some care should be taken in applying the dominance test.In the case of Δ  (, , ) = 0 and () > () (see the paragraph following (19)), this test in our implementation of the algorithm gives a "Fail" verdict only if either  ⩽ ⌈/2⌉ or () ̸ = .Through the preliminary computational experiments, we were convinced that the upper bound test was quite weak when applied to smaller partial solutions.In other words, the time overhead for computing linear assignmentbased bounds did not pay off for partial permutations  = ((1), . . ., ()) of length  that is small or modest compared to .Therefore, it is reasonable to compute the upper bound   (described in Section 2) only when  ⩾ (), where () is a threshold value depending on the UDSP instance matrix  and thus also on .The problem we face is how to determine an appropriate value for ().We combat this problem with a simple procedure consisting of two steps.In the first step, it randomly generates a relatively small number of partial permutations  1 , . . .,   , each of length ⌊/2⌋.For each permutation in this sample, the procedure computes the upper bound   .Let   1 , . . .,    be the values obtained.We are interested in the normalized differences between these values and ( heur ), where  heur is the solution delivered by the ITS algorithm.So the procedure calculates the sum  = ∑  =1 100(   − ( heur ))/( heur ) and the average  = / of such differences.In the second step, using , it determines the threshold value.This is done in the following way: if  <  1 , then () = ⌊/3⌋; if  1 ⩽  <  2 , then () = ⌊/2⌋; if  >  2 , then () = ⌊3/4⌋.The described procedure is executed at the initialization step of the algorithm.Its parameters are  1 ,  2 , and the sample size .
Armed with tools for pruning the search space, we can construct a branch-and-bound algorithm for solving the UDSP.In order to make the description of the algorithm more readable we divide it into two parts, namely, the main procedure B&B (branch-and-bound) and an auxiliary procedure SelectObject.The former builds a search tree with nodes representing partial solutions.The task of SelectObject is either to choose an object, which can be used to extend the current permutation, or, if the current node becomes fathomed, to perform a backtracking step.In the description of the algorithm given in the following, the set of objects that can be used to create new branches is denoted by .The main procedure goes as follows.B&B (1) Apply the ITS algorithm to get an initial solution  * to a given instance of the UDSP.
(3) Initialize the search tree by creating the root node with the empty set  attached to it.
Set  := 0 ( denotes the tree level the currently considered node belongs to).
(7) Calculate the coordinates for the objects by applying formula (4) with respect to the permutation  * and stop.
Steps (1) and (2) of B&B comprise the initialization phase of the algorithm.The initial solution to the problem is produced using ITS.This solution is saved as the best solution found so far, denoted by  * .If later a better solution is found,  * is updated.This is done within the SelectObject procedure.In the final step, B&B uses  * to calculate the optimal coordinates for the objects.The branch-and-bound phase starts at Step (3) of B&B.Each node of the search tree is assigned a set .The partial solution corresponding to the current node is denoted by .The objects of  are used to extend .Upon creation of a node (Step (3) for root and Step (6) for other nodes), the set  is empty.In SelectObject,  is filled with objects that are promising candidates to perform the branching operation on the corresponding node.SelectObject also decides which action has to be taken next.If  = , then the action is "branch, " whereas if  < , the action is "backtrack." Step (4) helps to discriminate between these two cases.If  = , then a new node in the next level of the search tree is generated.At that point, the partial permutation  is extended by assigning the selected object V to the position  + 1 in  (see Step (6)).If, however,  <  and  is positive, then backtracking is performed by repeating Steps (4) and (5).We thus see that the search process is controlled by the procedure SelectObject.This procedure can be stated as follows. SelectObject() (1) Check whether the set  attached to the current node is empty.If so, then go to (2).If not, then consider its subset   = { ∈  |  is unmarked and   () >  * }.If   is nonempty, then mark an arbitrary object V ∈   , and return with it as well as with  = .
(4) Mark an arbitrary object V ∈ , and return with it as well as with  = .
(  In the previous description, () denotes the set of unassigned objects, as before.The objects included in  ⊆ () are considered as candidates to be assigned to the leftmost available position in .At the root node,  = ().In all other cases, except when |()| = 1, an object becomes a member of the set  only if it passes two or, for longer , three tests.The third of them, the upper bound test, amounts to check if   >  * .This condition is checked again on the second and subsequent calls to SelectObject for the same node of the search tree.This is done in Step (1) for each unmarked object  ∈ .Such a strategy is reasonable because during the branch-and-bound process the value of  * may increase, and the previously satisfied constraint   >  * may become violated for some  ∈ .To be able to identify such objects, the algorithm stores the computed upper bound   as   () at Step (3) of SelectObject.
A closer look at the procedure SelectObject shows that two scenarios are possible: (1) when this procedure is invoked following the creation of a new node of the tree (which is done either in Step (3) or in Step (6) of B&B); (2) when a call to the procedure is made after a backtracking step.The set  initially is empty, and therefore Steps (2) to (5) of SelectObject become active only in the first of these two scenarios.Depending on the current level of the tree, , one of the three cases is considered.If the current node is the root, that is,  = 0, then Step (2) is executed.Since in this case the dominance test is not applicable, the algorithm uses the set  comprising all the objects under consideration.An arbitrary object selected in Step (4) is then used to create the first branch emanating from the root of the tree.If  ∈ [1, . . .,  − 2], then the algorithm proceeds to Step (3).The task of this step is to evaluate all partial solutions that can be obtained from the current partial permutation  by assigning an object from () to the ( + 1) th position in .In order not to lose at least one optimal solution it is sufficient to keep only those extensions of  for which all the tests were successful.Such partial solutions are memorized by the set .One of them is chosen in Step (4) to be used (in Step (6) of B&B) to generate the first son of the current node.If, however, no promising partial solution has been found and thus the set  is empty, then the current node can be discarded, and the search continued from its parent node.Finally, if  =  − 1, then Step (5) is executed in which the permutation  is completed by placing the remaining unassigned object in the last position of .Its value is compared with that of the best solution found so far.The node corresponding to  is a leaf and, therefore, is fathomed.In the second of the above-mentioned two scenarios (Step (1) of the procedure), the already existing nonempty set  is scanned.The previously selected objects in  have been marked.They are ignored.For each remaining object , it is checked whether   () >  * .If so, then  is included in the set   .If the resulting set   is empty, then the current node of the tree becomes fathomed, and the procedure goes to Step (6).Otherwise, the procedure chooses a branching object and passes it to its caller B&B.Our implementation of the algorithm adopts a very simple enumeration strategy: branch upon an arbitrary object in   (or  when Step (4) is performed).
It is useful to note that the tests in Step (3) are applied in increasing order of time complexity.The symmetry test is the cheapest of them, whereas the upper bound test is the most expensive to perform but still effective.

Computational Results
The main goal of our numerical experiments was to provide some measure of the performance of the developed B&B algorithm as well as to demonstrate the benefits of using the new upper bound and efficient dominance test throughout the solution process.For comparison purposes, we also implemented the better of the two branch-andbound algorithms of Brusco and Stahl [13].In their study, this algorithm is denoted as BB3.When referring to it in this paper, we will use the same name.In order to make the comparison more fair, we decided to start BB3 by invoking the ITS heuristic.Thus, the initial solution from which the branch-and-bound phase of each of the algorithms starts is expected to be of the same quality.
6.1.Experimental Setup.Both our algorithm and BB3 have been coded in the C programming language, and all the tests have been carried out on a PC with an Intel Core 2 Duo CPU running at 3.0 GHz.As a testbed for the algorithms, three empirical dissimilarity matrices from the literature in addition to a number of randomly generated ones were considered.The random matrices vary in size from 20 to 30 objects.All off-diagonal entries are drawn uniformly at random from the interval [1,100].The matrices, of course, are symmetric.
We also used three dissimilarity matrices constructed from empirical data found in the literature.The first matrix is based on Morse code confusion data collected by Rothkopf [26].In his experiment, the subjects were presented pairs of Morse code signals and asked to respond whether they thought the signals were the same or different.These answers were translated to the entries of the similarity matrix with rows and columns corresponding to the 36 alphanumeric characters (26 letters in the Latin alphabet and 10 digits in the decimal number system).We should mention that we found small discrepancies between Morse code similarity matrices given in various publications and electronic media.We have decided to take the matrix from [27], where it is presented with a reference to Shepard [28].Let this matrix be denoted by  = (  ).Its entries are integers from the interval [0, 100].Like in the study of Brusco and Stahl [13], the corresponding symmetric dissimilarity matrix  = (  ) was obtained by using the formula   = 200 −   −   for all off-diagonal entries and setting the diagonal of  to zero.We considered two UDSP instances constructed using Morse code confusion data-one defined by the 26 × 26 submatrix of  with rows and columns labeled by the letters and another defined by the full matrix .
Based on the results of preliminary experiments with the B&B algorithm, we have fixed the values of its parameters:  = 10,  1 = 0, and  2 = 5.In the symmetry test,  was fixed at 1.The cutoff time for ITS was 1 second.

Results.
The first experiment was conducted on a series of randomly generated full density dissimilarity matrices.The results of B&B and BB3 for them are summarized in Table 1.The dimension of the matrix  is encoded in the instance name displayed in the first column.The second column of the table shows, for each instance, the optimal value of the objective function  * and, in parentheses, two related metrics.The first of them is the raw value of the stress function Φ().The second number in parentheses is the normalized value of the stress function that is calculated as Φ()/ ∑ <   .The next two columns list the results of our algorithm: the number of nodes in the search tree and the CPU time reported in the form hours : minutes : seconds or minutes : seconds or seconds.The last two columns give these measures for BB3.
As it can be seen from the table, B&B is superior to BB3.We observe, for example, that the decrease in CPU time over BB3 is around 40% for the largest three instances.Also, our algorithm builds smaller search trees than BB3.
In our second experiment, we opt for three empirical dissimilarity matrices mentioned in Section 6.1.Table 2 summarizes the results of B&B and BB3 on the UDSP instances defined by these matrices.Its structure is the same as that of Table 1.In the instance names, the letter "M" stands for the Morse code matrix, "J" stands for the journal citations matrix, and "F" stands for the food item data.As before, the number following the letter indicates the dimension of the problem matrix.Comparing results in Tables 1 and 2, we find that for empirical data the superiority of our algorithm over BB3 is more pronounced.Basically, B&B performs significantly better than BB3 for each of the three data sets.For example, for the food-item dissimilarity matrix of size 30 × 30, B&B builds almost 10 times smaller search tree and is about 5 times faster than BB3.
Table 3 presents the results of the performance of B&B on the full Morse code dissimilarity matrix as well as on larger submatrices of the food-item dissimilarity matrix.Running BB3 on these UDSP instances is too expensive, so this algorithm is not included in the table.By analyzing the results in Tables 2 and 3, we find that, for  ∈ {22, . . ., 35}, the CPU time taken by B&B to solve the problem with the  ×  food-item submatrix is between 196 (for  = 30) and 282 (for  = 27) percent of that needed to solve the problem with the ( − 1) × ( − 1) food-item submatrix.For the submatrix of size 35 × 35, the CPU time taken by the algorithm was more than 14 days.In fact, a solution of value 120526370 was found by the ITS heuristic in less than 1 s.The rest of the time was spent on proving its optimality.We also see from Table 3 that the UDSP with the full Morse code dissimilarity matrix required nearly 21 days to solve to proven optimality using our approach.
In Table 4, we display optimal solutions for the two largest UDSP instances we have tried.The second and fourth columns of the table contain the optimal permutations for these instances.The coordinates for objects, calculated using (4), are given in the third and fifth columns.The number in parenthesis in the fourth column shows the order in which the food items appear within Table 5.1 in the book by Hubert et al. [30].From Table 4, we observe that only a half of the signals representing digits in the Morse code are placed at the end of the scale.Other such signals are positioned between signals encoding letters.We also see that shorter signals tend to occupy positions at the beginning of the permutation .
In Table 5, we evaluate the effectiveness of tests used to fathom partial solutions.Computational results are reported for a selection of UDSP instances.The second, third, and fourth columns of the table present 100 sym /, 100 dom /, and 100 UB /, where  sym (respectively,  dom and  UB ) is the number of partial permutations that are fathomed due to symmetry test (respectively, due to dominance test and due to upper bound test) in Step (3) of SelectObject, and  =  sym + dom + UB .The last three columns give the same set of statistics for the BB3 algorithm.Inspection of Table 5 reveals that  dom is much larger than both  sym and  UB .It can also be seen that  dom values are consistently higher with BB3 than when using our approach.Comparing the other two tests, we observe that  sym is larger than  UB in all cases except when applying B&B to the food-item dissimilarity submatrices of size 20 × 20 and 25 × 25.Generally, we notice that the upper bound test is most successful for the UDSP instances defined by the food-item matrix.
We end this section with a discussion of two issues regarding the use of heuristic algorithms for the UDSP.From a practical point of view, heuristics, of course, are preferable to exact methods as they are fast and can be applied to large problem instances.If carefully designed, they are able to produce solutions of very high quality.The development of exact methods, on the other hand, is a theoretical avenue for coping with different problems.In the field of optimization, exact algorithms, for a problem of interest, provide not only a solution but also a certificate of its optimality.Therefore, one of possible applications of exact methods is to use them in the process of assessment of heuristic techniques.Specifically, optimal values can serve as a reference point with which the results of heuristics can be compared.However, obtaining an optimality certificate in many cases, including the UDSP, is very time consuming.In order to see the time differences between finding an optimal solution for UDSP with the help of heuristics and proving its optimality (as it is done by the branch-and-bound method described in this paper), we run the two heuristic algorithms, iterated tabu search and simulated annealing (SA) of Brusco [19], on all the problem instances used in the main experiment.For two random instances, namely, p21 and p25, SA was trapped in a local maximum.Therefore, we have enhanced our implementation of SA by allowing it to run in a multi start mode.This variation of SA located an optimal solution for the abovementioned instances in the third and, respectively, second restarts.Both tested heuristics have proven to be very fast.In particular, ITS took in total only 2.95 seconds to find the global optima for all 30 instances we experimented with.Performing the same task by SA required 5.44 seconds.Such times are in huge contrast to what is seen in Tables 1-3.Basically, the long computation times recorded in these tables are the price we have to pay for obtaining not only a solution but also a guarantee of its optimality.We did not perform additional computational experiments with ITS and SA because investigation of heuristics for the UDSP is outside the scope of this paper.
Another issue concerns the use of heuristics for providing initial solutions for the branch-and-bound technique.We have employed the iterated tabu search procedure for this purpose.Our choice was influenced by the fact that we could adopt in ITS the same formulas as those used in the dominance test, which is a key component of our approach.Obviously, there are other heuristics one can apply in place of ITS.As it follows from the discussion in the preceding paragraph, a good candidate for this is the simulated annealing algorithm of Brusco [19].Suppose that B&B is run twice on the same instance from different initial solutions, both of which are optimal.Then it should be clear that in both cases the same number of tree nodes is explored.This essentially means that any fast heuristic capable of providing optimal solutions is perfect to be used in the initialization step of B&B.An alternative strategy is to use in this step randomly generated permutations.The effects of this simple strategy are mixed.For example, for problem instances F25 and F27, the computation time increased from 148.3 and, respectively, 1169.8 seconds (see Table 2) to 413.3 and, respectively, 2062.5 seconds.However, for example, for p25 and M26, a somewhat different picture was observed.In the case of random initial solution, B&B took 407.5 and 468.7 seconds for these instances, respectively.The computation times in Table 1 for p25 and Table 2 for M26 are only marginally shorter.One possible explanation of this lies in the fact that, as Table 5 indicates, the percentage of partial solutions fathomed due to bound test for both p25 and M26 is quite low.However, in general, it is advantageous to use a heuristic for obtaining an initial solution for the branchand-bound algorithm, especially because this solution can be produced at a negligible cost with respect to the rest of the computation.around 35 × 35.We also remark that optimal solutions for all UDSP instances used in our experiments can be found by applying heuristic algorithms such as iterated tabu search and simulated annealing procedures.The total time taken by each of these procedures to reach the global optima is only a few seconds.An advantage of the branch-and-bound algorithm is its ability to certify the optimality of the solution obtained in a rigorous manner.
Before closing, there are two more points worth of mention.First, we proposed a simple, yet effective, mechanism for making a decision about when it is useful to apply a bound test to the current partial solution and when such a test most probably will fail to discard this solution.For that purpose, a sample of partial solutions is evaluated in the preparation step of B&B.We believe that similar mechanisms may be operative in branch-and-bound algorithms for other difficult combinatorial optimization problems.Second, we developed an efficient procedure for exploring the pairwise interchange neighborhood of a solution in the search space.This procedure can be useful on its own in the design of heuristic algorithms for unidimensional scaling, especially those based on the local search principle.

Table 1 :
Performance on random problem instances.

Table 5 :
Relative performance of the tests.Percentage of partial solutions fathomed due to dominance test.c Percentage of partial solutions fathomed due to bound test. b