Author image John J. Trammell
and 1 contributors


Algorithm::TravelingSalesman::BitonicTour - solve the euclidean traveling-salesman problem with bitonic tours


    use Algorithm::TravelingSalesman::BitonicTour;
    my $bt = Algorithm::TravelingSalesman::BitonicTour->new;
    # ...add other points as needed...

    # get and print the solution
    my ($len, @coords) = $bt->solve;
    print "optimal path length: $len\n";
    print "coordinates of optimal path:\n";
    print "   ($_->[0], $_->[1])\n" for @coords;


From Introduction to Algorithms, 2nd ed., T. H. Cormen, C. E. Leiserson, R. Rivest, and C. Stein, MIT Press, 2001, problem 15-1, p. 364:

    The euclidean traveling-salesman problem is the problem of determining the shortest closed tour that connects a given set of n points in the plane. Figure 15.9(a) shows the solution to a 7-point problem. The general problem is NP-complete, and its solution is therefore believed to require more than polynomial time (see Chapter 34).

    J. L. Bentley has suggested that we simplify the problem by restricting our attention to bitonic tours, that is, tours that start at the leftmost point, go strictly left to right to the rightmost point, and then go strictly right to left back to the starting point. Figure 15.9(b) shows the shortest bitonic tour of the same 7 points. In this case, a polynomial-time algorithm is possible.

    Describe an O(n^2)-time algorithm for determining an optimal bitonic tour. You may assume that no two points have the same x-coordinate. (Hint: Scan left to right, maintaining optimal possibilities for the two parts of the tour.)

From Wikipedia (

    In computational geometry, a bitonic tour of a set of point sites in the Euclidean plane is a closed polygonal chain that has each site as one of its vertices, such that any vertical line crosses the chain at most twice.



Points are numbered from left to right, starting with "0", then "1", and so on. For convenience I call the rightmost point R.

Key Insights Into the Problem

1. Focus on optimal open bitonic tours.

Optimal open bitonic tours have endpoints (i,j) where i < j < R, and they are the building blocks of the optimal closed bitonic tour we're trying to find.

An open bitonic tour, optimal or not, has these properties:

 * it's bitonic (a vertical line crosses the tour at most twice)
 * it's open (it has endpoints), which we call "i" and "j" (i < j)
 * all points to the left of "j" are visited by the tour
 * points i and j are endpoints (connected to exactly one edge)
 * all other points in the tour are connected to two edges

For a given set of points there may be many open bitonic tours with endpoints (i,j), but we are only interested in the optimal open tour--the tour with the shortest length. Let's call this tour T(i,j).

2. Grok the (slightly) messy recurrence relation.

A concrete example helps clarify this. Assume we know the optimal tour lengths for all (i,j) to the right of point 5:

    T(0,2)  T(1,2)
    T(0,3)  T(1,3)  T(2,3)
    T(0,4)  T(1,4)  T(2,4)  T(3,4)

From this information, we can find T(0,5), T(1,5), ... T(4,5).

Finding T(0,5)

From our definition, T(0,5) must have endpoints 0 and 5, and must also include all intermediate points 1-4. This means T(0,5) is composed of points 0 through 5 in order. This is also the union of T(0,4) and the line segment 4-5.

Finding T(1,5)

T(1,5) has endpoints at 1 and 5, and visits all points to the left of 5. To preserve the bitonicity of T(1,5), the only possibility for the tour is the union of T(1,4) and line segment 4-5. I have included a short proof by contradiction of this in the source code.

Finding T(2,5)-T(3,5)

Our logic for finding T(1,5) applies to these cases as well.

Finding T(4,5)

Tour T(4,5) breaks the pattern seen in T(0,5) through T(3,5), because the leftmost point (point 4) must be an endpoint in the tour. Via proof by contradiction similar to the above, our choices for constructing T(4,5) are:

    T(0,4) + line segment from 0 to 5
    T(1,4) + line segment from 1 to 5
    T(2,4) + line segment from 2 to 5
    T(3,4) + line segment from 3 to 5

All of them meet our bitonicity requirements, so we choose the shortest of these for T(4,5).

To summarize the recurrence, and using function delta() to calculate the distance between points:

if i < j-1:

T(i,j) = T(i,j-1) + delta(j-1,j)

if i == j-1:

T(i,j) = min{ T(k,i) + delta(k,j) }, for all k < i

3. The base case.

The open tour T(0,1) has to be the line segment from 0 to 1.

Dynamic Programming

This problem exhibits the classic features suggesting a dynamic programming solution: overlapping subproblems and optimal substructure.

Overlapping Subproblems

The construction of tour T(i,j) depends on knowledge of tours to the left of j:

    to construct:   one must know:
    -------------   --------------
    T(0,5)          T(0,4)
    T(1,5)          T(1,4)
    T(2,5)          T(2,4)
    T(3,5)          T(3,4)
    T(4,5)          T(0,4), T(1,4), T(2,4), T(3,4)

We also see that a given optimal tour is used more than once in constructing longer tours. For example, T(1,4) is used in the construction of both T(1,5) and T(4,5).

Optimal Substructure

As shown in the above analysis, constructing a given optimal tour depends on knowledge of shorter "included" optimal tours; suboptimal tours are irrelevant.


These exercises may clarify the above analysis.

Exercise 1.

Consider the parallelogram ((0,0), (1,1), (2,0), (3,1)).

    a. Draw it on graph paper.
    b. Label points "0" through "3"
    c. Draw t[0,1].  Calculate its length.
    d. Draw t[0,2] and t[1,2].  Calculate their lengths.
    e. Draw t[0,3], t[1,3], and t[2,3].  Calculate their lengths.
    f. What is the optimal bitonic tour?
    g. Draw the suboptimal bitonic tour.
    h. Why does the above algorithm find the optimal tour,
       and not the suboptimal tour?
Exercise 2.

Repeat Exercise 1 with pentagon ((0,2), (1,0), (2,3), (3,0), (4,2)).



Constructs a new solution object.


    my $ts = Algorithm::TravelingSalesman::BitonicTour->new;


Adds a point at position ($x, $y) to be included in the solution. Method add_point() checks to make sure that no two points have the same x-coordinate. This method will croak() with a descriptive error message if anything goes wrong.


    # add point at position (x=2, y=3) to the problem


Returns the number of points that have been added to the object (mnemonic: number).


    print "I have %d points.\n", $ts->N;


Returns the index of the rightmost point that has been added to the object (mnemonic: rightmost). This is always one less than $ts->N.


Returns an array of points sorted by increasing x-coordinate. The first ("zeroth") array element returned is thus the leftmost point in the problem.

Each point is represented as an arrayref containing (x,y) coordinates. The sorted array of points is cached, but the cache is cleared by each call to add_point().


    my $ts = Algorithm::TravelingSalesman::BitonicTour->new;
    my @sorted = $ts->sorted_points;
    # @sorted contains ([0,0], [1,1], [2,0])


Returns an array containing the coordinates of point $n.


    my ($x0, $y0) = $ts->coord(0);   # coords of leftmost point
    my ($x1, $y1) = $ts->coord(1);   # coords of next point
    # ...
    my ($xn, $yn) = $ts->coord(-1);  # coords of rightmost point--CLEVER!


Solves the problem as configured. Returns a list containing the length of the minimum tour, plus the coordinates of the points in the tour in traversal order.


    my ($length, @points) = $ts->solve();
    print "length: $length\n";
    for (@points) {
        my ($x,$y) = @$_;
        print "($x,$y)\n";


Find the length of the optimal complete (closed) bitonic tour. This is done by choosing the shortest tour from the set of all possible complete tours.

A possible closed tour is composed of a partial tour with rightmost point R as one of its endpoints plus the final return segment from R to the other endpoint of the tour.

    T(0,R) + delta(0,R)
    T(1,R) + delta(1,R)
    T(i,R) + delta(i,R)
    T(R-1,R) + delta(R-1,R)


Populates internal data structure tour($i,$j) describing all possible optimal open tour costs and paths for this problem configuration.


Determines the optimal open tour from point $i to point $j, based on the values of previously calculated optimal tours to the left of $j.

As discussed above, there are two distinct cases for this calculation: when $i == $j - 1 and when $i < $j - 1.

    # determine the length of and points in the tour
    # starting at point 20 and ending at point 25
    my ($length,@points) = $ts->optimal_open_tour(20,25);


Uses information about optimal open tours to the left of <$j> to find the optimal tour with endpoints ($i, $j).

This method handles the case where $i and $j are adjacent, i.e. $i = $j - 1. In this case there are many possible bitonic tours, all going from $i to "$x" to $j. All points $x in the range (0 .. $i - 1) are examined to find the optimal tour.


Uses information about optimal open tours to the left of <$j> to find the optimal tour with endpoints ($i, $j).

This method handles the case where $i and $j are not adjacent, i.e. $i < $j - 1. In this case there is only one bitonic tour possible, going from $i to $j-1 to $j.


Returns the data structure associated with the optimal open bitonic tour with endpoints ($i, $j).

$b->tour_length($i, $j, [$len])

Returns the length of the optimal open bitonic tour with endpoints ($i, $j). If $len is specified, set the length to $len.

$b->tour_points($i, $j, [@points])

Returns an array containing the indices of the points in the optimal open bitonic tour with endpoints ($i, $j).

If @points is specified, set the endpoints to @points.


Returns the euclidean distance from point $p1 to point $p2.


    # print the distance from the leftmost to the next point
    print $b->delta(0,1);
    # print the distance from the leftmost to the rightmost point
    print $b->delta(0,-1);



John Trammell, <johntrammell at gmail dot com>


Please report any bugs or feature requests to bug-cormen-bitonic at, or through the web interface at I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.


You can find documentation for this module with the perldoc command.

    perldoc Algorithm::TravelingSalesman::BitonicTour

You can also look for information at:


Copyright 2008 John Trammell, all rights reserved.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.