Search for an Immobile Entity on a Unit Graph:

A Mathematical Programming Approach

byWanyan Yu and Rajan Batta

Department of Industrial and Systems Engineering, 438 Bell HallUniversity at Buffalo (SUNY), Buffalo, NY 14260, USA

May 2010

Abstract

We consider the problem of finding an immobile entity on a unit graph with the

objective of minimizing the expected search time. The problem was introduced and

discussed by Jotshi and Batta [15] in a recent paper. They did not provide a formu-

lation but instead focused on developing graph-theory based heuristics. In contrast,

we develop a formulation and use a mathematical programming-based approach. Our

algorithm named SIEUG is based on several proven properties of an optimal solution.

We are able to establish that it indeed finds an optimal solution for many medium-size

problem instances (up to 100 nodes and 20 odd-degree nodes). For larger instances,

we only use the first stage of the SIEUG algorithm and confirm that this approach is

empirically superior to that developed by Jotshi and Batta. A thorough computational

study is conducted and results in suggested solution strategies that are a function of

graph size and structure.

Keywords: Search theory; Eulerian path; Mixed integer programming

1 Introduction and Literature Review

This paper discusses the problem of finding an immobile entity on a unit graph with the

objective of minimizing the expected search time. The entity is assumed to be uniformly

distributed on the graph and to be of infinitesimal size. The searcher is free to start from any

vertex of the network and needs to plan a route which covers all of the edges of the graph

at least once because there is no a priori knowledge about the position of the immobile

entity. To discover the entity, the searcher must be at the same point as the entity. It is

assumed that there is no communication between the entity and the searcher during the

search process. Given all of these assumptions, it is evident that the expected search time

is uniquely determined by the searcher’s starting vertex and search path.

The problem described above is essentially the same as the Utilitarian Postman (UP)

Problem discussed in [3] in the context of rendezvous search game. The UP problem’s

objective is to minimize the mean time of delivery of mail to all customers. More generally,

a UP path is the one which minimizes the expected time required to find a random (uniformly

distributed) point on a network. We note that UP is different from the well-known Chinese

Postman Problem (CPP) which finds the shortest length path which visits all of the edges

of the network. The optimal UP path is one of the open Eulerian paths (an open Eulerian

path is a path covers all the edges of the network and the shortest open Eulerian path is

the CP path) but may be longer than the CP path. Furthermore, unlike a CP path whose

length is bounded by twice of the length of the whole network[13], a UP path may traverse

on an edge more than twice[5] and therefore no similar bound exists for a general network.

Before we present a discussion on the specific problem in this paper, we briefly review

the general topic of search theory. Search theory came into being as a major discipline

of the operations research field during World War II. A commonly considered objective is

minimizing the expected time of detection. According to the nature of the problem[16],

work in the literature can be classified into two areas: One-Sided Search and Search Games

(Two-Sided Search Problem). For one-sided search, the position of the target is independent

from the searcher’s strategy. The target is either immobile or its motion is determined

stochastically by known rules. On the other hand, Search Games can be further divided

into two cases based on whether the target wants to be found or not. It is formulated as a

zero-sum game if the target is hiding from the searcher. If the target wants to be found, the

problem is called “Rendezvous Search”. The problem discussed in this paper falls into the

category of One-Sided Search.

The first set of models in search theory related to our problem is searching for an immobile

hider in search games. Alpern et al. [4] proved that any random CP path is optimal for

1

a simply searchable network with an arbitrary starting point for the searcher. This paper

gives sufficient conditions for simple searchability and shows that it is not a topological

property. In another paper [8], the same authors conjectured that an optimal strategy to

search for an immobile hider on any network will never use trajectories that visit some (or

part of) edges more than twice. In a related paper, Alpern [3] introduced the Utilitarian

Postman (UP) path problem in which the average delivery time is minimized. A follow-up

to this paper is [8] in which it is proved that the uniform hiding strategy is optimal for some

special structured graphs (easily hideable networks). Sufficient conditions for a network to

be easily hideable are also provided in this paper. Finally Alpern et al. [5] concluded that

for arbitrary-start search games, the optimal hiding strategy on a symmetric network is the

uniform distribution and therefore the UP path is the optimal search strategy. They also

provided a construction for such paths for a symmetric network of odd degrees.

Another set of search theory models that related to our problem are known as Rendezvous

Search problems. In Rendezvous Search the entity wants to be found. For such problems,

the min-max objective in the searcher and hider problem can be converted to a min-min

objective in which two players both wish to meet in the least expected time. A rendezvous

search problem “telephone coordination game” was first proposed by Alpern in a talk given

in 1976 (Institute of Advanced Studies, Vienna). It deals with the minimization of the

meeting for two unit speed searchers, randomly placed in a known search network. For this

special case, Anderson and Weber[9] developed a discrete location formulation and found the

optimal strategy for a symmetric rendezvous search (in which players I and II adopt identical

strategies) on a completely connected graph on 2 vertices. The extension of the problem to

a 3 vertex network is shown in [17]. It was not until Alpern[1] proposed a general continuous

formulation that the rendezvous search field started to draw research attention. The upper

bounds for various rendezvous values for the circle and an arbitrary network are given in

[1]. Continuing this research direction, the upper bound on the symmetric rendezvous value

was improved by Anderson and Essegaier [10] and Baston [11]. After that, the rendezvous

search problem was continuously studied by Alpern and Beck [6]- [7] and Howard [14] under

different assumptions regarding network structure. Readers are referred to the survey paper

[2] for a comprehensive review of the recent results on rendezvous search for two unit speed

searches.

We note that the vast majority of the search literature focuses on finding the optimal

solution for the case of a special-structured graph. Departing from this trend, Jotshi and

Batta[15] developed heuristic algorithms for finding an immobile entity on a general struc-

tured network. The major drawback of their approach is that the heuristic algorithms are

not based on a mathematical programming formulation and hence do not provide any form

2

of performance guarantee. In this paper we focus on the same problem as in Jotshi and

Batta[15], except that we adopt a mathematical programming approach. Our approach is

computationally tested versus the heuristic procedure presented in Jotshi and Batta[15].

The structure of this paper is as follows. Section 2 presents our mathematical model.

Section 3 discusses some observations and properties of an optimal solution for the mathe-

matical model, which lead to our solution methodology and heuristics in section 4. Section

5 provides some computational results and performance comparison with other heuristic

methods. Conclusions and future search directions are provided in Section 6.

2 Model Formulation

We restrict our attention to simple graphs, i.e., graphs with no loops and no more than one

edge between two different vertices. All of the edges presented are assumed to have unit

length. We also assume that the immobile entity is uniformly distributed on the graph. Fur-

thermore, we assume the following characteristics of the searcher – start vertex for searcher

is not specified and search speed is constant and equal to unity. It turns out that a unit

search speed can be easily relaxed. However, relaxing the constant search speed assumption

is difficult. Finally, the immobile entity is assumed to be of infinitesimal size, implying that

the locations of the searcher and the entity have to coincide for the entity to be discovered.

Under the above set of assumptions, we develop two separate formulations for the prob-

lem of finding a path for the searcher that minimizes the expected search time. The first

formulation is a MIQCP model and is presented in Section 2.1. Because the computational

time to solve this model is prohibitively large for reasonable-size problems, a second MIP

model is developed in Section 2.2.

2.1 Mixed Integer Quadratic Constraint Problem (MIQCP) Model

2.1.1 Notation and formulation

Consider a labeled graph G(V,A) represented by a set of vertices V and a set of edges A,

where V = {1, 2, · · · , n} and A = {E1, E2, · · · , Em}. Let P be an open Eulerian path on

graph G represented as a sequence of r traversed edges Eli , i.e. P = (El1 , El2 , · · · , Elr) , li ∈{1, · · · ,m}. Each edge Eli is represented by a vector of dimension n whose entries are

0 except for two entries which are 1. The entries that are 1 indicate the end vertices of

edge Eli . More formally, let the vector that represents the ith edge on path P be ZPi =

3

(c1i , c2i , · · · , cni )

T. For example, if the second edge on path P connects vertices 3 and 4,

and n = 5, we have ZP2 = (0, 0, 1, 1, 0)T . Armed with this notation, we proceed with the

formulation.

Output

An open Eulerian path P = (El1 , El2 , · · · ,Elr) , li ∈ {1, · · · ,m} which minimizes expected

search time

Data Requirements

n number of vertices on graph G(V,A)m number of edges on graph G(V,A)

bjk =

{1 if vertex j is an end vertex of edge Ek on graph G0 otherwise

for k = 1, ...,m; j = 1, ..., n.

Decision Variables

r number of traversed edgesEli ith edge on the path, i = 1, 2, ..., r.

cji =

{1 if vertex j is an end vertex of Eli

0 otherwisefor i = 1, ..., r; j = 1, ..., n.

Zki =

0 if edge Ek and edge Eli are not adjacent1 if edge Ek and edge Eli are adjacent2 if edge Ek and edge Eli are identical

for k = 1, ...,m; i = 1, ..., r.

Pki =

{1 if Ek = Eli

0 otherwisefor k = 1, ...,m; i = 1, ..., r.

tki =

0 if edge Elk and edge Eli are not adjacent1 if edge Elk and edge Eli are adjacent2 if edge Elk and edge Eli are identical

for i = 2, ..., r; k = 1, ..., i− 1.

wki =

{1 if edge Elk and edge Eli are identical0 otherwise

for i = 2, ..., r; k = 1, ..., i− 1.

yi =

{1 if edge Eli is first time traversed0 otherwise

for i = 1, ..., r.

We present a Mixed Integer Quadratic Constrained Problem (MIQCP) formulation for

a known value of r (number of traversed edges). Later (in Sections 3 and 4) we will discuss

the determination of the appropriate value of r. This formulation is labeled (P r1 ).

4

(P r1 ) MinimizeE(Ts) =

1

m

∑r

i=1(i− 1

2)yi (1)

subject to:

n∑j=1

cij = 2 for i = 1, · · · , r. (2)

n∑j=1

cijci+1

j ≥ 1 for i = 1, · · · , r − 1. (3)

cji−1+cji+c

ji+1−

(w(i−1)i+wi(i+1)

)≤ 2 for i = 2, · · · , r−1; j = 1, · · · , n. (4)

cji−1cji−c

ji+1c

ji+2−wi(i+1) ≥ −1 for i = 2, · · · , r−2; j = 1, · · · , n. (5)

cji−1cji−c

ji+1c

ji+2+wi(i+1) ≤ 1 for i = 2, · · · , r−2; j = 1, · · · , n. (6)

w(i−1)i+wi(i+1) ≤ 1 for i = 2, · · · , r−1. (7)

r∑i=1

yi = m, y1 = 1. (8)

m∑k=1

Pki= 1 for i = 1, · · · , r. (9)

r∑i=1

Pki ≥ 1 for k = 1, · · · , m. (10)

Zki=n∑

j=1

bjkcji for k = 1, · · · , m; i = 1, · · · , r. (11)

tki=n∑

j=1

cjkcji for i = 2, · · · , r; k = 1, · · · , i−1. (12)

Zki−1 ≤ Pki ≤1

2Zki for k = 1, · · · , m; i = 1, · · · , r. (13)

tki−1 ≤ wki ≤1

2tki for i = 2, · · · , r; k = 1, · · · , i−1. (14)

0 < yi+

∑i−1k=1wki

i−1≤ 1 for i = 2, · · · , r. (15)

cji ∈ {0, 1}, P ki ∈ {0, 1} , wki ∈ {0, 1}, yi ∈ {0, 1} .

5

2.1.2 Explanation of the formulation

We now establish the correctness of formulation (P r1 ).

Objective function

It is assumed that the entity is uniformly distributed on a unit graph G(V,A). Besides,

the searcher’s speed is assumed to be unity. Let Ai be the event that the entity is found on

edge Eli , and Ts be the search time; then the expected search time can be written as:

E (Ts) =r∑

i=1

(Ts|Ai)Pr(Ai) (16)

We know that the probability of finding the entity on a first time traversed edge is 1m

,

and the probability of finding the entity on a repeated edge is 0. On the other hand, the

average search time given the entity is found on any point of Eli equals the length of edges

traversed in front of Eli plus half of the length of Eli . Then (16) can be written as:

E (Ts) =r∑

i=1

(i−1+1

2)

1

myi =

1

m

r∑i=1

(i−1

2)yi

Constraints

There are two sets of constraints in the formulation.

Set 1: Constraints which make the solution a valid open Eulerian path.

We claim that if constraints (2) – (10) are satisfied, then the solution is an open Eulerian

path. Constraint (2) simply enforces the fact that there needs to be exactly two end vertices

of each edge Eli . The additional constraints (3), (4), (5) and (6), enforces path continuity.

To see this, we note that constraint (3) ensures that all two successively traversed edges are

either adjacent or identical. Constraint (4) indicates that all three successively traversed

edges must not form a claw (a claw is a star graph with three edges, three leaves, and

one central vertex). This inequality constraint comes from a linearization of the following

condition:

cji−1+cji+c

ji+1 6= 3 if w(i−1)i+wi(i+1)= 0 for i= 2, · · · , r−1; j= 1, · · · , n. (17)

6

Constraints (5) and (6) are supplementary requirements of constraint (4). It considers

the continuity of four successive edges if in the segment the third edge repeats the second

edge. If the third edge repeats the second edge, the four edges must have one common end

vertex. These two constraints is a linear representation of the following condition:

cji−1cj

i+cji+1c

ji+2

{6= 1 if wi(i+1)= 1

6= 2 if wi(i+1)= 0for i= 2, · · · , r−2; j= 1, · · · , n. (18)

Ensuring path continuity is not enough. We also need to concern ourselves with repeated

edges to properly evaluate the objective function. An edge cannot be successively repeated

more than 2 times – constraint (7) ensures that this happen. Constraint (8) ensures that

the number of first-time traversed edges on path P has to be equal to the number of edges

on the graph. Furthermore, the first edge on the path must be a first-traversed edge.

The next thing we have to ensure is to establish a relationship between edges on the

selected path and edges on the graph. Constraint (9) does this.

Another factor is that each edge on the graph has to be covered. This is ensured by

constraint (10).

Set 2: Constraints that ensure the correct relationships between decision variables.

Equation (11) defines the relationship between Ek and Eli . If Ek and Eli have no common

end vertex,∑n

j=1 bjkc

ji= 0; if Ek and Eli have one common end vertex,

∑nj=1 b

jkc

ji= 1; if Ek

and ei are identical,∑n

j=1 bjkc

ji= 2. Similarly, the relationship between edge ci and ck is

defined by Equation (12).

The inequality constraints (13), (14), (15) are a linear representation of the following

relationship in (19), (20) and (21), respectively.

Pki=

{0 if Zki= 2

1 if Zki= 0 or 1for k= 1, · · · , m; j= 1, · · · , r. (19)

yki=

{0 if tki= 2

1 if tki= 0 or 1for i= 2, · · · , r; k= 1, · · · , i−1. (20)

yi=

{0 if

∑i−1k=1wki ≥ 1

1 if∑i−1

k=1wki= 0for i= 2, · · · , r. (21)

7

The MIQCP model can be solved by CPLEX 11.2 using the barrier optimizer when the

graph size is small. A solved example is presented in the appendix. However, when the size of

graph increases, CPLEX is not able to find a feasible solution for the MIQCP model within

a reasonable time. Therefore, we seek an approach to linearize the quadratic constraints

in the model in order to use the MIP optimizer in CPLEX. This enhanced MIP model is

presented in the next section.

2.2 Enhanced MIP Model

In this section, the MIQCP model is revised to a MIP model for the sake of computational

efficiency. We introduce a new binary variable sjki=cjkc

ji ; the bilinear relationship between

sjki, cjk and cji is given by the linear constraints (22) – (24):

sjki ≤ cjk for i= 2, · · · ,r; k= 1, · · · ,i−1; j= 1, · · · , n, (22)

sjki ≤ cji for i= 2, · · · ,r; k= 1, · · · , i−1; j= 1, · · · , n, (23)

sjki ≥ cjk+cji−1 for i= 2, · · · , r; k= 1, · · · , i−1; j= 1, · · · , n, (24)

where sjki ≥ 0. Then constraints (3), (5), (6) and (12) can be rewritten as:

n∑j=1

sji(i+1) ≥ 1 for i= 1, · · · , r−1. (25)

sj(i−1)i−sj(i+1)(i+2)−wi(i+1) ≥ −1 for i= 2, · · · , r−1; j= 1, · · · , n. (26)

sj(i−1)i−sj(i+1)(i+2)+wi(i+1) ≤ 1 for i= 2, · · · , r−1; j= 1, · · · , n. (27)

tki =n∑

j=1

sjki for i = 2, · · · , r; k = 1, · · · , i− 1. (28)

Substituting the quadratic constraints in (P r1 ) , we obtain an enhanced MIP model formu-

lation (P r2 ) for a known value of r:

(P r2 ) Minimize E (Ts) = 1

m

∑ri=1 (i−1

2)yi

subject to:

8

n∑j=1

cji= 2 for i= 1, · · · , r.

sjki ≤ cjk for i= 2, · · · ,r; k= 1, · · · , i−1; j= 1, · · · , n.

sjki ≤ cji for i= 2, · · · ,r; k= 1, · · · , i−1; j= 1, · · · , n.

sjki ≥ cjk+cji−1 for i= 2, · · · , r; k= 1, · · · , i−1; j= 1, · · · , n.n∑

j=1

sji(i+1) ≥ 1 for i= 1, · · · , r−1.

cji−1+cji+c

ji+1−

(w(i−1)i+wi(i+1)

)≤ 2 for i= 2, · · · , r−1; j= 1, · · · , n.

sj(i−1)i−sj(i+1)(i+2)−wi(i+1) ≥ −1 for i= 2, · · · , r−2; j= 1, · · · , n.

sj(i−1)i−sj(i+1)(i+2)+wi(i+1) ≤ 1 for i= 2, · · · , r−2; j= 1, · · · , n.

w(i−1)i+wi(i+1) ≤ 1 for i= 2, · · · , r−1.

r∑i=1

yi=m, y1= 1.

m∑k=1

Pki= 1 for i= 1, · · · , r.

r∑i=1

Pki ≥ 1 for k= 1, · · · , m.

Zki=n∑

j=1

bjkcji for k= 1, · · · , m; i= 1, · · · , r.

tki=n∑

j=1

sjki for i= 2, · · · , r; k= 1, · · · , i−1.

Zki−1 ≤ Pki ≤1

2Zki for k= 1, · · · , m; i= 1, · · · , r.

tki−1 ≤ wki ≤1

2tki for i= 2, · · · , r; k= 1, · · · , i−1.

0 < yi+

∑i−1k=1wki

i−1≤ 1 for i= 2, · · · , r.

cji ∈ {0, 1},P ki ∈ {0, 1} , wki ∈ {0, 1}, yi ∈ {0, 1} , sjki ∈ {0, 1} .

9

A solved example to compare the MIQCP and MIP models is provided in the appendix.

3 Properties

There are two main issues related to the MIP formulation which needs to be resolved. First,

the optimal value of r, that is, the number of traversed edges (length) of the optimal path

P is unknown. Second, the number of variables cjis becomes unmanageable when the size of

the graph increases. Due to these two issues, this formulation cannot be solved directly by

a MIP solver, for large-size graphs. In this section, we establish some special properties of

our MIP model. These properties help us develop our solution methodology in Section 4.

The value of the objective function is determined by the values of r and yi’s. Let variable

r and vector −→yr = (y1, · · · , yr) be a feasible partial solution to the problem, where yi = 0

indicates that the ith edge on path P is a repeated edge, and r is the length of path P.

Furthermore, we define an optimal UP path, optimal r and optimal −→yr below.

Definition. An optimal UP path is one which yields the minimum expected search time

with the minimum number of repeated edges. An optimal r, denoted as r*, is the value of

r corresponding to the optimal path. An optimal solution for −→yr , denoted as −→yr∗

, is the

value of −→yr corresponding to the optimal UP path.

We now explore properties related to the values of r and r* and the structure of −→yr and−→yr∗.

3.1 Properties for r and r*

Property 1. The length of a UP path, r, is no less than the length of the CP path, i.e.,

r ≥ µ, where µ is the length of the CP path. In other words, let rl and r∗l be the lower

bound of r and r* respectively, then rl = µ, r∗l= µ.

Explanation of Property 1: Based on its definition, a UP path is an open Eulerian path

which covers the graph at least once. On the other hand, a CP path is such an open Eulerian

path with a minimum length. Therefore, r ≥ µ. An example where r = µ is the case of a

Eulerian graph, in which case the CP path becomes a UP path and the lower bound for r*

becomes the same as the lower bound for r.

Property 2. The upper bound of the length of a UP path, r, is not necessarily equal to

the upper bound of the length of the CP path.

10

Explanation of Proeprty 2: It is known that a CP path will never utilize an edge more

than twice [3]. Therefore the upper bound of a CP length is twice the length of the graph.

However, a similar result does not hold for a UP path. A counterexample can be found in

[13]. This counterexample has a bridge, i.e., an edge whose removal causes the graph to be

split into two disconnected graphs.

Conjecture: For an almost bridgeless symmetric graph, there exists a length of path, r∗u,

such that no UP path with length greater than r∗u yields a less expected search time. That

is, ∀r > r∗u, E∗ (Ts (r∗u)) ≤ E∗ (Ts(r)).

Explanation of rationale for conjecture: Property 2 states that an upper bound of r

is not easy to find for a general structured graph with a counterexample of a bridge. Here

we conjecture that there is an upper bound of r for an almost bridgeless symmetric network

(symmetric network means unit graph). An almost bridgeless graph is defined as a graph

such that every cut edge is incident with a vertex of degree 1. With this conjecture, we can

restrict our search on r∗ in the range of [r∗l, r∗u]. A construction approach to find r∗u is

introduced in Section 4.

3.2 Properties for ~yr and ~yr∗

The following contents focus on the issue of reducing the solution space of −→yr and −→yr∗.

Property 3. It is beneficial to have the 0 entries of −→yr appear towards the end of the path.

Furthermore, with an unknown number of traversed edges, an optimal UP path is the one

on which the last edge is an non-repeated edge, that is, yr∗ = 1.

Explanation of Property 3: Intuitively, the expected search time increases when non-

repeated edges appear at the end of UP path. In other words, for a fixed path length of r,

E (Ts) is minimized if yi = 0 for large i, which implies having the repeated edges towards

the end of path. On the other hand, any UP path with the minimum expected search time

and longer length is dominated by the optimal UP path because it can be converted to the

optimal UP path by removing the repeated edges after the last unrepeated edge.

Definition. A matching is a set of edges such that no two of the edges share the same

vertex. A perfect matching is a matching which matches all vertices of the graph. If the

graph is a weighted graph, the minimum weight perfect matching problem is to find a perfect

matching of minimum weight.

The minimum weight perfect matching over odd vertices is used to find the CP path.

With the above definition, we establish the following lemma.

11

Lemma 1. Let nodd be the number of odd vertices on graph G (nodd ≥ 2) and nm be the

dimension of minimum weight perfect matching over odd vertices. If n0 is the number of 0

entries of vector −→yr , then n0 ≥ nm ≥ nodd−22

.

Proof. From Property 1 we know that the length of UP path is no less than the length of the

CP path. In other words, the number of repeated edges on the optimal UP path is no less

than the dimension of the minimum weight perfect matching over the odd vertices of graph

G, i.e., n0 ≥ nm. On the other hand, at most two odd vertices become even vertices by

repeating one edge, and an open Eulerian path must have all the vertices even degree except

for 2 vertices as the starting and ending vertices. Therefore, the dimension of minimum

weight perfect matching must satisfy:

nm ≥ nodd − 2

2(29)

The lemma follows.

We note that the second equality in the statement of Lemma 1 holds when each repeated

edge connects two odd vertices. An example of this is a graph with a Hamiltonian path

connecting all the odd vertices.

Lemma 2. Let n1i be the number of 1s after the ith 0 entry of vector −→yr ; then n1

i ≥ nodd

2− i,

for i ≤ n0.

Proof. Suppose −→yr = (1, 1, · · · , 0, · · · , 1) is a feasible solution. By removing n1i 1s that follows

the ith 0, there are at most 2n1i odd vertices which become even vertices. On the other hand,

because there are (i − 1) repeated edges in front of the ith repeated edge, at most 2(i − 1)

odd vertices become even vertices by those repeats. Therefore, the number of odd vertices

nodd must satisfy the following inequality:

2n1i + 2(i− 1) + 2 ≥ nodd

n1i ≥

nodd

2− i (30)

The lemma follows.

From Lemma 1, Lemma 2 and Property 3, we obtain the following theorem.

12

Theorem 1. Given the number of 0 entries of vector −→yr , n0 , not less than nodd−22

, the solu-

tion for −→yr = (y1, · · · , yr) which yields the minimum expected search time has the following

structure: there are n1 leading 1’s followed by n2 (0,1) pair, where n1 = m− nodd−22

and n2 =nodd−4

2. That is, the best possible solution for−→yr

∗is: −→yr

∗= (1, 1, · · · , 1︸ ︷︷ ︸

n1

, 0, 1, · · · , 0, 1︸ ︷︷ ︸n2 (0,1)pair

, 0, 0, · · · , 0︸ ︷︷ ︸n0−n2

,

1). In particular, −→yr∗

= (1, 1, · · · , 1︸ ︷︷ ︸n1

, 0, 1, · · · , 0, 1︸ ︷︷ ︸n2 (0,1)pair

) if n0 = nodd−22

.

Proof. We obtain the following inequalities by using Lemma 2:

n11 ≥

nodd

2−1, n1

2 ≥nodd

2−2, · · · , n1

nodd−42

≥ 2, n1nodd−2

2

≥ 1. (31)

On the other hand, from Property 3, the last entry of −→yr∗

must be 1. Therefore, there is

at least one entry of 1 after each entry of 0, that is,

n1nodd

2≥ 1, · · · , n1

n0 ≥ 1. (32)

From Property 3 we also know that it is desirable to have the 0 entries of −→yi appear

towards the end of the path. The total number of unrepeated edges equals to m. Therefore,

the minimum expected search time is obtained when the equalities in (31) and (32) are all

equalities. That is,

−→yr∗

= ( 1, 1, · · · , 1,︸ ︷︷ ︸n1

0, 1, · · · , 0, 1︸ ︷︷ ︸n2 (0,1)pair

, 0, 0, · · · , 0︸ ︷︷ ︸n0−n2

, 1) (33)

where n1=m−nodd−22

and n2=nodd−4

2.

We know from Lemma 1 that n0 ≥ nodd−22

. Given n0=nodd−22

, we can conclude that−→yr∗= ( 1, 1, · · · , 1︸ ︷︷ ︸

n1

,

0, 1, · · · , 0, 1︸ ︷︷ ︸n2 (0,1)pair

), where n1=m−nodd−22

and n2=nodd−4

2.

The theorem follows.

Note that this structure of −→yr∗

is achieved only when the equality holds in Lemma 2.

Such a UP path is not guaranteed to be found for a general graph. This structure of −→yr∗

is

the best solution given the value of n0, without any information about the structure of the

13

graph. It can be used as the starting search point in the solution space of −→yr∗.

If a path satisfies the structure of −→yr∗

in Theorem 1 it is optimal. However, an optimal

path does not necessarily satisfy Theorem 1. So Theorem 1 is a sufficient but not a necessary

condition for optimality. We illustrate the lack of necessity of this condition via an example

shown in Figure 1.

Figure 1: An Example of Lack of Necessity of Condition in Theorem 1

The graph in Figure 1 has 6 odd nodes. Therefore the number of 0 entries of vector −→yris at least n0=nodd−2

2= 2. Given n0=2, we solve model (P r

2 ) by setting r = n0+m = 12. The

optimal path found by CPLEX is 2-9-5-7-4-6-8-3-8-9-7-9-1 with a corresponding partial so-

lution −→yr = (1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1). The optimal objective value is 5.4. Given n0=3, the

optimal path found by CPLEX is 7-9-5-7-4-6-8-9-2-9-1-9-8 with a corresponding partial solu-

tion −→yr = (1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1)which satisfies Theorem 1. The corresponding optimal

objective value is also 5.4. Therefore we can conclude that the optimal objective function

value is 5.4, and both paths yield an minimum expected search time. It is obvious that the

optimal partial solution −→yr corresponding to the former path does not satisfy Theorem 1.

Property 4. The value of r∗u equals to the length of a realized path of which the partial so-

lution −→yr=(1, 1, · · · , 1︸ ︷︷ ︸n1

, 0, 1, · · · , 0, 1︸ ︷︷ ︸n2 (0,1)pair

, 0, 0, · · · , 0︸ ︷︷ ︸n0−n2

, 1), where n1=m−nodd−22

and n2=nodd−4

2, and

n0=r−m.

Proof. First, given a path P(r) of which the partial solution −→yr=(1, 1, · · · , 1︸ ︷︷ ︸n1

, 0, 1, · · · , 0, 1︸ ︷︷ ︸n2 (0,1)pair

,

0, 0, · · · , 0︸ ︷︷ ︸n0−n2

, 1), where n1=m−nodd−22

and n2=nodd−4

2, we need to prove that a path P

′(r′:r′>r)

does not yield a smaller objective function value.

Suppose r′ = r + 1. From Theorem 1, we know that a partial solution −→yr′ = (1, 1, · · · , 1︸ ︷︷ ︸n′1

,

14

0, 1, · · · , 0, 1︸ ︷︷ ︸n′2 (0,1)pair

, 0, 0, · · · , 0︸ ︷︷ ︸n′0−n′2

, 1) yields the minimum expected search time. Here

n1′=m−nodd−2

2=n1,

n2′ =

nodd−4

2= n2,

n0′ − n2

′ = r′ −m− n2′ = r + 1−m− n2

′ = r −m− n2′ + 1 = n0 − n2 + 1.

Therefore, E (Ts (P ′))−E (Ts (P )) = 2m> 0, and we can conclude that path P ′ does not

yield a smaller objective function value. By application of induction, it is easy to establish

that the objective function cannot decrease for any given r′ > r. The theorem follows.

If such a path P can be realized, the upper bound of r∗ is the corresponding length of

path P. In Section 4 we will discuss in detail how to obtain a feasible path which has a

structure similar to P.

4 Solution Methodology

We develop a solution methodology to find a UP path using the properties discussed in

Section 3. We restrict the graph to be a simple, almost bridgeless, unit graph. Our strategy

for solving the problem is as follows. We first develop a heuristic that finds a good solution

and provides an upper bound for the path length. This upper bound is needed to define the

mathematical programming model (P r2 ). The solution from the heuristic will also be used

in Step 3 to define an upper bound for the optimal solution of (P r2 ). The next step is to

use the properties developed in Section 3 to reduce the size of the formulation by creating

a partial solution. The last step uses CPLEX on this reduced size formulation to solve the

model. If a feasible solution exists, then the solution is optimal to (P r2 ). If a feasible solution

does not exist, then we change the partial solution and resolve using CPLEX till feasibility

is resolved. For the sake of brevity, we label our methodology as the SIEUG (search for an

immobile entity on a unit graph) algorithm.

SIEUG algorithm:

1. Obtain an upper bound for r* (denoted as r∗u), the length of the optimal path, by

constructing a feasible path P.

2. Set the value of r equal to µ ( µ is the length of the CP path). Construct a partial

15

solution −→yr = (y1, · · · , yr) to the problem (P r2 ) which has the following property: all possible

solutions which have a smaller objective value than this partial solution are infeasible to

(P r2 ).

3. Use CPLEX to find the value of the cji variables that correspond to the partial solution−→yr = (y1, · · · , yr).

If no feasible cji ’s can be found by CPLEX, let µ = µ+ 1, then go to Step 2. Otherwise,

stop with the current values of cji ’s.

The SIEUG algorithm guarantees a termination before or when r reaches the value r∗u.

The rest of this section contains the details necessary to execute the steps of the SIEUG

algorithm and to establish that it yields an optimal solution to (P r2 ), if µ ≤ r ≤ r∗u. In

Section 4.1, we discuss a heuristic procedure to find an upper bound for r*. In Section 4.2,

we show how to construct a partial solution −→yr = (y1, · · · , yr). In Section 4.3, we describe

the mechanics of using CPLEX to find a feasible solution to (P r2 ). In Section 4.4, we define

the conditions under which the SIEUG algorithm is optimal with respect to (P r2 ) and the

UP problem.

4.1 Details of Step 1 of the SIEUG algorithm

In order to obtain our upper bound, we need to construct a path P that has a corresponding

partial solution −→yr which satisfies or is close to the structure defined in Property 4. Our

procedure, labeled Heuristic A, constructs such a path P. We note that the application of

Heuristic A is not restricted to unit graphs; however, in this paper we are only interested

in its result on unit graphs. It is a refinement of the algorithm presented in Jotshi and

Batta[15].

Heuristic A

Input: A simple undirected graph G(V,E ) with non-negative weights.

Output: A path P covering all edges on graph G which provides an upper bound for r*.

Procedure:

Step 0:

Initialize V′, V

′′, E′, E′′, M

′, E1, E2, P, P1, P2 to be empty.

16

Step 1:

If graph G is Eulerian or has only two odd vertices, a UP path is simply a CP path.

If graph G is Eulerian, use any vertex as the starting vertex and apply the End-Pairing

algorithm by Edmonds and Johnson[12] to obtain a CP path. If G has only two odd vertices,

add one virtual edge with a suitably large weight between the two odd vertices and then

obtain a CP path by applying the End-Pairing algorithm. A UP path of G is the resulting

CP path with the removal of the added virtual edge. Otherwise go to Step 2.

Step 2:

If graph G has more than two odd vertices, derive graph G′(V ′,E ′) from graph G(V,E )

defined over set of odd vertices V ′⊆V. Apply the minimum weight perfect matching algorithm

on the set of odd vertices V ′. The minimum weight perfect matching algorithm we use is

written in a function of LEDA library, which is a C++ class library providing various pre-

defined data types and algorithms for graph and network problems. The matching algorithm

gives a set of edges M in which each edge connects two odd vertices on the original graph

except for two edges with negative weight which are not in the original set of edges. Let these

two edges be l1 = (n1, o1) and l1 = (n2, o2), where o1, o2 are vertices on the original graph

and n1, n2 are virtual vertices for the algorithm. Delete edge l1 and l2 from the matching

set M and let the new set of edges be M ′. Delete o1 and o2 from the set of odd vertices V ′

and let the new set of odd vertices be V ′′. Denote o1 and o2 as the temporary starting and

ending vertex of path P, respectively.

Step 3:

Find a Hamiltonian path connecting the vertices in V ′′ and covering the edges in M ′.

This step is accomplished by revising Steps 2 and 3 of the heuristic proposed by Jotshi and

Batta[15]. A minimum spanning tree (MST) of vertices in V ′′ is found first by applying

Kruskal’s Algorithm. We enforce the usage of edges in M ′ in the tree by assuming the

length of those edges to be 0. If the MST is not a Hamiltonian path, revise the tree by

replacing a non-bridge edge with another edge so that the increase in overall weight of the

MST is the least until the tree becomes Hamiltonian. Let the resulting path be P1. Denote

the starting and ending vertices of P1as s1 and s2, respectively (the direction of the path is

determined arbitrarily). Suppose P1 contains the temporary starting or ending vertices of

path P. Without loss of generality, suppose P1 contains o1, denote s2 as the marked vertex,o2

as the final starting vertex and s1 as the final ending vertex. Go to Step 5. If P1 contains

the temporary starting or ending vertices of path P, then go to Step 4.

17

Step 4:

Find the shortest path for the following four pair vertices: o1 and s1, o2 and s1, o1 and

s2, and o2 and s2. Without loss of generality, let the length of the shortest path between

o1 and s1 be the smallest of the four pairs. Extend the Hamiltonian path P1 by inserting

the shortest path between o1 and s1 in front of o1. The new starting vertex of P1 becomes

s1. Denote s1 as the marked vertex, o2 as the final starting vertex and s2 as the final ending

vertex.

Step 5:

Partition the edges on path P1 into two sets (E1 and E2) as follows: starting from the first

edge on P1, partition the sequence of edges between each two successive odd vertices into

different sets. For example, assign the sequence of edges between the first two odd vertices

to set E1, assign the sequence of edges between the second and the third odd vertices to

set E2, and so on. Let E′′

be the set {E − E2}, which means E′′

contains edges in set E

excluding edges in set E2. Then the graph G′′

(V, E′′) becomes a graph with only two odd

vertices. Construct an Eulerian Path on G′′

using the same approach as in Step 1. Let the

resulting Eulerian path be P2. Note that the starting and ending vertex of P2 should be o2

and s1, respectively.

Step 6:

Add path P1 after path P2 and remove the marked vertex. The resulting path is the

desired path P.

Solved examples for Heuristic A are contained in the Appendix.

Explanation of Heuristic A

The structure of −→yr in Property 4 in Section 3 implies that the last edge traversed on the

path can be far away from the last untraversed edge without a large increase in the expected

search time. Therefore, instead of having the minimum Hamiltonian path connecting all

the odd vertices at the end of the path as described in Jotshi and Batta’s heuristic[15], one

odd vertex can be taken out of consideration. Hence we only need to construct a shortest

Hamiltonian path connecting all other odd vertices. We select this odd vertex by taking

either the starting or ending vertex of the CPP tour on the same graph obtained from the

minimum weight perfect matching algorithm. From the graph theory point of view, the

starting vertex of path P does not have to be close to the other odd vertices because the

18

partial path connecting this vertex and the Hamiltonian ending vertex is Eulerian due to our

Heuristic and placed at the beginning of P. It is desirable that this path is long, meaning

that we want to cover as much of the network without repeating edges.

Another idea is that we utilize the edges in the minimum weight perfect matching set to

construct the Hamiltonian path connecting all but one odd vertex. The reason is that we

want to have a scenario in which the minimum weight perfect matching set minimizes the

total repeated length. This enforcement is valid when the resulting Hamiltonian path does

not include the temporary starting and ending vertices in Step 2 of Heuristic A. Since a CP

path does not necessarily lead to an UP path, as explained in Section 3, this approach may

not always find a better solution than Jotshi and Batta’s heuristic. A computational study

is therefore conducted in Section 5.1 to verify the effectiveness of the approach.

Heuristic A is developed to provide a solution with a structure of −→yr that is shown to be

desirable in Section 3. We therefore use the value of the total length corresponding to the

optimal path P from Heuristic A as the upper bound value of r* to continue to the second

step of the SIEUG algorithm.

4.2 Details of Step 2 of SIEUG Algorithm

After obtaining an upper bound for r*, we proceed as follows. It is known from Lemma 1

that the lower bound of the number of 0s appearing in −→yr is nm, where nm is the dimension of

the minimum weight perfect matching over odd vertices. Furthermore, Theorem 1 provides

the optimal structure of −→yr given the number of zeros n0 in −→yr . The construction of −→yr =

(y1, · · · , yr) is thus as follows:

Iteration 1:

Let n0=nm and −→yr= ( 1, 1, · · · , 1︸ ︷︷ ︸

n1

, 0, 1, · · · , 0, 1︸ ︷︷ ︸n2 (0,1)pair

, 0, 0, · · · , 0︸ ︷︷ ︸n0−n2

, 1), where n1 and n2 are defined

in the theorem.

Iteration N (2 ≤ N ≤ r∗u − n0 − n1 − 1 ):

Let −→yr= ( 1, 1, · · · , 1︸ ︷︷ ︸n1

, 0, 1, · · · , 0, 1︸ ︷︷ ︸n2 (0,1)pair

, 0, 0, · · · , 0︸ ︷︷ ︸n0−n2+N

, 1), where n1 and n2 are defined same as in

Iteration 0.

19

4.3 Details of Step 3 of SIEUG Algorithm

For each iteration of the SIEUG algorithm, CPLEX is employed to solve our model which

utilizing the partial solution given by −→yr . It is noted that the CPLEX MIP solver has an

internal function of completing an optimal solution given a partial starting solution. If the

partial starting solution is infeasible, CPLEX will modify it and then use the revised partial

solution to solve the model. We seek a solution such that all the possible solutions which

provide a smaller objective function value are infeasible in the previous iterations. This is

accomplished as follows: First, at each iteration, we update the value of r* by adding 1 to

its current value. By doing this, we are able to define our mathematical model. Second, we

set the value of −→yr such that it satisfies the structure corresponding to the possible optimal

solution proved in Section 3.2. This partial solution gives CPLEX an opportunity to find an

optimal solution for a given total length of path P.

4.4 Conditions for Optimality of SIEUG Algorithm

We formalize our main result in the following theorem.

Theorem 2. If µ ≤ r ≤ r∗u, then the SIEUG algorithm finds an optimal solution to (P r2 ).

Proof. Since the SIEUG algorithm stops at the iteration in which the first feasible solution is

found, given the partial solution in Step 2, Theorem 2 is essentially the same as the following

statement: the first feasible solution found by the SIEUG algorithm is an optimal solution

to (P r2 ). We prove this statement by examining the number of iterations required to find a

feasible solution.

We first prove that the statement is true if the number of iterations required to find

a feasible solution is 1. It is known from Section 4.2 that in Iteration 1, n0=nm(nm is the

dimension of minimum weight perfect matching over odd vertices) and the partial solution we

set is −→yr= ( 1, 1, · · · , 1︸ ︷︷ ︸n1

, 0, 1, · · · , 0, 1︸ ︷︷ ︸n2 (0,1)pair

, 0, 0, · · · , 0︸ ︷︷ ︸n0−n2

, 1), where n1 = m − nodd−22

and n2 = nodd−42

.

If a feasible solution is found in Iteration 1, there are two possible cases.

Case 1: A feasible solution is obtained given the above −→yr . If so, then the solution obtained

is an optimal solution to (P r2 ) by Theorem 1.

Case 2: A feasible solution is obtained by repairing the given starting partial solution at

Iteration 1. This implies that the objective function value corresponding to the feasible

solution found is at least 2m

greater that the objective function value corresponding to −→yr

20

we set in this iteration. Since the best objective value we can obtain in Iteration 2 and later

is also at least 2m

greater than the objective function value corresponding to −→yr (See Property

4 in Section 3 and Section 4.2), the feasible solution obtained in Iteration 1 is optimal to

(P r2 ) with the minimum path length.

Now we prove that if the number of iterations required to find a feasible solution is N

(N> 1), then the solution found is optimal to (P r2 ). If the first feasible solution is found in

Iteration N, it indicates no feasible solution is found in Iteration 1, 2, · · · , N -1. In other

words, the possible optimal objective function value is at least 2m

greater than the objective

function value corresponding to −→yr in Iteration N -1. It is easy to conclude from Section

4.2 that the difference between the objective value corresponding to −→yr in Iteration N and

N -1 is 2m

. Therefore the approach of constructing −→yr in Iteration N -1 guarantees all possible

solutions which have a smaller objective value than this partial solution are infeasible to (P r2 )

in the previous iterations. On the other hand, by the same reasoning as for N=1, we know

that no better solution can be found in iterations after N (N> 1). Therefore the feasibility

of the solution at iteration N is also optimal to (P r2 ).

Theorem 2 provides a condition for optimality of the SIEUG algorithm to (P r2 ). But the

question remains if the value of r∗u we find from Heuristic A is a valid upper bound to the

length of an optimal UP path. Theorem 3 answers this question.

Theorem 3. If the path P obtained by the SIEUG algorithm satisfies Property 4, then

path P is an optimal UP path.

Proof. If the path P obtained by the SIEUG algorithm has a partial solution−→yr = (1, 1, · · · , 1︸ ︷︷ ︸n1

,

0, 1, · · · , 0, 1︸ ︷︷ ︸n2 (0,1)pair

, 0, 0, · · · , 0︸ ︷︷ ︸n0−n2

, 1) , where n1 = m− nodd−22

and n2 = nodd−42

, and n0 = r −m, then

by Property 4, no path with a longer length yields a smaller objective function value. It

indicates that the r∗u value found from Heuristic A is a valid upper bound. On the other

hand, from Theorem 2, we know the path P obtained by the SIEUG algorithm is optimal

to (P r2 ), where µ ≤ r ≤ r∗u. The theorem follows.

As discussed in Section 4.1, the path P we construct by Heuristic A has a corresponding

partial solution −→yr which satisfies or is close to the structure defined in Property 4. However,

we cannot guarantee that path P obtained by the SIEUG algorithm necessarily satisfies

Property 4. We explore this computationally in Section 5.2.

21

5 Computational Results

There are three aspects to our computational study. In Section 5.1, we focus on comparing

Heuristic A to the heuristic presented in the Jotshi and Batta paper. In Section 5.2, we focus

on determining the frequency with which the path P obtained by the SIEUG algorithm

satisfies Property 4. In Section 5.3, we explore the computational limits of the SIEUG

algorithm. Conclusions from our computational study are summarized in Section 5.4.

5.1 Comparison of Heuristic A with Jotshi and Batta’s Heuristic

We compared our Heuristic A with Jotshi and Batta’s heuristic (Heuristic B) on 150 ran-

domly generated connected unit graphs. We define graphs with edges less than 50 to be

small graphs, those with between 50 and 100 edges to be medium graphs, and those with

greater than 100 edges to be large graphs. Furthermore, we restrict the number of edges on

a graph to be no larger than 300 for the computational study due to the limitation of the

commercial software CPLEX we used. All the test runs were done on a computer with a

T8300@2.4GHZ CPU and 2GB of RAM.

The following 4 possible outcomes exist when we compare the two heuristics:

Case 1. Heuristic A provides a reduced or equal expected search time with larger or equal

total path length.

Case 2. Heuristic A provides a reduced or equal expected search time with less total path

length.

Case 3. Heuristic A provides an increased expected search time with larger or equal path

length.

Case 4. Heuristic A provides an increased expected search time with less total path length.

Figure 2 presents the number for each case among the 150 graphs. As we can see from

the histogram, Heuristic A provides a better solution on 117 out of the 150 runs - obtained

by summing up Cases 1 and 2. On the other hand, we observe that Heuristic A provides a

longer optimal path for 143 among the total 150 graphs - obtained by summing up Cases 1

and 3. An explanation for this is as follows: In Heuristic A, we enforce that a Hamiltonian

path covers the minimum weight perfect matching edges at the end of path P ; this is a

stronger requirement than a Hamiltonian path covering all odd vertices applied in Heuristic

B and hence results in a longer path.

22

Figure 2: Heuristic A vs. Heuristic B

We now focus on a comparison of Heuristics A and B as a function of the size of the

graph. Table 1 summarizes the performance comparison on the 150 graphs, for different size

of graphs. In Table 1, E1, L1 and T1 represent the expected search time, total length of

the path found and the run time from Heuristic A, respectively. E2, L2 and T2 are the

corresponding values from Heuristic B. We observe that the difference in objective function

value realized by the two heuristics is very small. Also, the number of edges utilized by the

two heuristics are very similar. On the other hand, the run time difference between Heuristic

A and Heuristic B reduces when the graph size increases. For small graphs, the average run

time of Heuristic A is 0.27 second; for the largest graph we tested (which has 295 edges), the

run time of Heuristic A is 40.51 seconds. Both heuristics A and B turns out to be efficient

even for large-sized graph.

Table 1: Average Comparisons of Solutions and Total Path Length of the Two Heuristics

Graph Size (E2-E1)/E2(%) (L1 -L2)/L2(%) (T1-T2)/T2(%)Small (1-50) 0.7889 0.5938 38.22

Median(50-100) 0.0277 1.0690 24.70Large(100-300) 0.0156 1.0397 6.62

5.2 How Often does the SIEUG Algorithm Deliver an Optimal

Solution?

Here we investigate the frequency with which the SIEUG algorithm delivers an optimal

solution for 20 small and 40 medium graphs. There are two cases here. If the solution by

the SIEUG algorithm satisfies Property 4, then we can conclude its optimality by Theorem

3. Otherwise if the optimality gap of the final solution is 0% in CPLEX in any iteration of

23

the algorithm, the solution is automatically proved to be optimal by exclusively exploring

the branching tree with a branch and cut algorithm implemented in CPLEX. We run the

SIEUG algorithm integrated with CPLEX 11.2 on the same platform as described in Section

5.1. The run time limit in the CPLEX MIP solver is set to be 1800 seconds. Table 2 shows

the results for the SIEUG algorithm on the 60 graphs. Several observations regarding the

performance of the SIEUG algorithm can be made. First, when the number of odd nodes

equals to 0 or 2, which means an Eulerian path exists on the graph, the optimal solution

gap is 0 and the solution from Heuristic A is optimal. This essentially validates our model

by showing that a Chinese Postman path is a Utilitarian path when the graph is Eulerian

with only two odd vertices. Second, for graphs with less than 20 edges (small graphs), the

SIEUG algorithm can find an optimal solution within 30 minutes 81.25% of the time. Third,

when the number of edges on the graph is between 20 and 85, the SIEUG algorithm can

find a feasible solution within 30 minutes. Note that this frequency depends not only on

the algorithm but also the structure of the graph itself. We select graphs such that the odd

nodes are centralized; therefore it is possible to realize a path which has the structure in

Property 4. We also restrict the number of odd nodes on the graph to be no more than 24.

This is due to the computational limits of the SIEUG algorithm, which will be discussed in

the next section.

We note that the solution from the SIEUG algorithm can be proved to be optimal using

Property 4 for 11 out of the 40 graphs. For problems solved in our computational study,

27.5% of the time the SIEUG algorithm provides an optimal solution for medium graphs.

Table 2: Frequency with which the SIEUG Algorithm Delivers an Optimal Solution

Number of Edges Percentage with 0% Percentage that Satisfy Percentage with ProvenOptimality Gap Property 4(but not 0% gap) Optimality

2-20 75 6.25 81.2520-85 0 27.50 27.50

Next we examine the mean gap for the case where the optimality of the solution from

SIUEG cannot be proved, for graphs with number of edges between 20 and 85. Figure 3

shows the relationship between the number of edges and the percentage gap of the feasible

solution obtained from SIEUG. It can be seen that the percentage gap reduces when the

number of edges increases. That is because it becomes harder to obtain a feasible solution

and once it is found it is close to the lower bound provided by a linear relaxation. The mean

gap of the feasible solution is 4.92% while the smallest gap and largest gap are 1.07% and

14.97%, respectively.

24

Figure 3: Number of Edges vs. % Gap

5.3 Computational Limits of the SIEUG Algorithm

Here we ran the SIEUG algorithm to explore its computational limits. The optimality gap

in the CPLEX MIP solver is set to be 0.05 and the time limit to be 1800 seconds.

Figures 4 and 5 summarizes the run time of SIEUG algorithm on the 60 graphs. The

run time is positively affected both by the number of edges on the graph and the number of

odd degree vertices. The first factor increases the size of the model in terms of the number

of variables and constraints, while the second factor increases the difficulty of finding an

optimal solution from the initial given partial solution of −→yr . From our computational study,

when the number of edges on the graph is greater than 85 or the number of odd vertices is

beyond 24, CPLEX is not able to provide a feasible solution within 5% gap after 30 minutes.

Figure 4: Number of Edges vs. Run Time

25

Figure 5: Number of Odd Degree Nodes vs. Run Rime

We now analyze the computational difficulty to solve the model. As observed during

our experiment, the lower bound provided by a linear relaxation at each node is very poor

and hardly effective during the branch and bound process when the graph becomes larger.

This is due to the quadratic structure of some constraints with which we initially model the

problem. In order to solve this problem, an effective bounding method needs to be developed.

The second problem associated with the algorithm is that the traditional branch and cut

algorithm implemented in CPLEX does not perform well on our model. The reason is that

the size of the branch and bound tree becomes unmanageable for large-size problems.

5.4 Summary of Computational Study

We can summarize our computational results in terms of the graph size and structure as

follows:

1. When the number of edges m ≤ 10, CPLEX solves the model to optimality within 30

minutes.

2. When the number of edges 10 ≤ m ≤ 20, the SIEUG algorithm solves the model to

optimality within 30 minutes 81.25% of the time.

3. When the number of edges 20 ≤ m ≤ 85, the SIEUG algorithm provides a feasible

solution within 30 minutes. 27.5% of the time the solution obtained can be proved to

be optimal using Property 4. For the cases where the solution cannot be proved to be

26

optimal, the mean gap of the feasible solution is 4.92%, while the smallest gaps and

largest gap are 1.07% and 14.97%, respectively.

4. When the number of edges m ≥ 85, the SIEUG algorithm cannot provide a feasible

solution within 30 minutes. Either Heuristic A or Heuristic B can be applied. 64% of

the time Heuristic A is superior to Heuristic B with an average 0.1091% improvement

on the solution. For the case where Heuristic B is superior to Heuristic A the mean

difference between the solutions is 0.0905%.

6 Summary, Conclusions and Future Research

In this paper, a mathematical model was developed to determine an optimal path to search

for an immobile entity on a unit graph. Since the maximum length of an optimal path is

required as an input in the model, we first developed a heuristic to find an upper bound

for the total length of an optimal path. This heuristic is compared with Jotshi and Batta’s

heuristic[15] in terms of solution performance and run time. An “exact” algorithm (SIEUG)

is developed to solve the MIP model. This algorithm iteratively incorporates the CPLEX

solver to solve a different problem at each iteration such that the first feasible solution

obtained provides the optimal objective function value. The algorithm is proved to be

effective for small and medium graphs that have a small number of odd degree vertices. The

SIEUG algorithm is not guaranteed to return the optimal solution but in practice it does so

in a large percentage of cases.

Our major contribution is that the mathematical model provides a performance guarantee

on the heuristics we developed. In a disaster relief scenario, the exact solution approach can

be used for long-term planning and the heuristics introduced in this paper with a performance

guarantee are suitable to guide a quick response in a dynamic disaster environment.

A fruitful direction for future research is to apply advanced mathematical programming

techniques to solve the model for large-size problems. Another direction is to modify the

model to be applied to more general graphs.

References

[1] S. Alpern. The rendezvous search problem. SIAM Journal on Control and Optimization,

33(3):673–683, 1995.

27

[2] S. Alpern. Rendezvous search: A personal perspective. Operations Research, 50(5):772–

795, 2002.

[3] S. Alpern. Hide-and-seek games on a tree to which eulerian networks are attached.

Networks, 52(3):162–166, 2008.

[4] S. Alpern, V. Baston, and S. Gal. Network search games with immobile hider, without

a designated searcher starting point. International Journal of Game Theory, 37(2):281–

302, 2008.

[5] S. Alpern, V. Baston, and S. Gal. Searching symmetric networks with utilitarian-

postman paths. Networks, 53(4):392–402, 2009.

[6] S. Alpern and A. Beck. Asymmetric rendezvous on the line is a double linear search

problem. Mathematics of Operations Research, 24(3):604–618, 1999.

[7] S. Alpern and A. Beck. Rendezvous search on the line with limited resources: Maxi-

mizing the probability of meeting. Operations Research, 47(6):849–861, 1999.

[8] S. Alpern and S. Gal. The theory of search games and rendezvous. Kluwer Academic

Publishers, Boston, 2003.

[9] E. J. Anderson and R. R. Weber. The rendezvous problem on discrete locations. Journal

of Applied Probability, 27(4):839–851, 1990.

[10] E.J. Anderson and S. Essegaier. Rendezvous search on the line with indistinguishable

players. SIAM Journal on Control and Optimization, 33(6):1637–1642, 1995.

[11] V.J. Baston. Two rendezvous search problems on the line. Naval Reseach Logistics,

46(3):335–340, 1999.

[12] J. Edmonds and E.L. Johnson. Matching, euler tours and the chinese postman. Math-

ematical Programming, 5:88–124, 1973.

[13] M. Guan. Graphic programming using odd and even points. Chinese Math, 1:273–277,

1962.

[14] J.V. Howard. Rendezvous search on the interval and circle. Operations Research,

47(4):550–558, 1999.

[15] A. Jotshi and R. Batta. Search for an immobile entity on a network. European Journal

of Operational Research, 191(2):347–359, 2008.

28

[16] L. Stone. Theory of optimal search. Operations Research Society of America, Arlington,

Virginia, 2th edition, 1989.

[17] R. Weber. The optimal strategy for symmetric rendezvous search on k3 (working paper),

2007.

Appendix

A.1 A Comparative Example for the MIQCP and MIP Models

Consider the unit graph G(V ,A) shown in Figure A1, where the number of vertices n = 4

and number of edges m = 6. For selected number of traversed edges r (r = 6, 7, 8 and 9), we

can find the optimal path P using the two models, respectively. The results are summarized

in Table A1.

As expected, the objective value obtained from MIQCP and MIP models are the same

for the four given values of r. As the graph is not Eulerian, there does not exist a path

which traverses each edge exactly once. Therefore, no feasible solution can be found given

the length of the path r = 6. Given r = 7, both the optimal paths found by the MIQCP and

MIP model have a repeated edge as the 6th traversed edge on path P. Hence, the expected

search time E (Ts) from the two models are the same. Given r = 8 or 9, both models found

the optimal path which yields the same value of E (Ts) as the result obtained under condition

r = 7. This is because the optimal for a path with the length of 8 or 9 has the first repeated

edge also as the 6th edge on the path and the rest of the repeated edges at the end of the

path, which does not increase the objective function value from r = 7. It is observed from

the example that the minimum expected search time does not change as r increases beyond

a certain level. Also it is desired to have the repeated edges towards the end of the path (see

[19]). These are further discussed in Section 3.

Figure A1: Graph G(V,A), n = 4, m = 6

29

Table A1: Comparisons of Solution and Computing Time for the MIQCP and MIP Models

MIQCP Model MIP Modelr E(Ts) Optimal path P Computing

time(sec)E(Ts) Optimal path P Computing

time(sec)6 - Infeasible 0.30 - Infeasible 0.207 3.167 2-4-1-2-3-1-3-4 1.88 3.167 1-4-3-2-1-3-2-4 1.048 3.167 2-3-4-2-1-3-4-1-4 4.60 3.167 3-1-2-3-4-1-4-2-3 1.679 3.167 1-2-4-1-3-2-4-3-4-2 8.05 3.167 1-2-3-1-4-3-4-2-1-3 1.88

We also note that the computing time of the MIP model is less than that of the MIQCP

model, for each of the four cases. Linearizing the quadratic constraints improves the solv-

ability of the original model. This is why in later sections, we only use the MIP model to

solve our problem, although the properties and solution methodology developed in Sections

3 and 4 applies to both the MIQCP and MIP models. The computational results in Section

5 are reported using the MIP model.

A.2 Solved Examples using Heuristic A

Here we compare our Heuristic A algorithm with Jotshi and Batta’s algorithm on examples

of a general graph and a grid structured graph that are found in [15]. For the general graph

example, Heuristic A finds a path which has the same length as that found by Jotshi and

Batta[15] but has a smaller expected search time. For the grid structured example, Heuristic

A finds a longer path than that found by Jotshi and Batta[15] but has the same expected

search time. Details are contained in sub-sections A.2.1 and A.2.2, respectively.

A.2.1 An example on a general graph

See Figure A2(a) for the unit graph that is solved.

1. Step 1: Since graph G has more than two odd vertices, go to Step 2.

2. Step 2: Derive graph G′ (V ′, E ′) from graph G(V,E ) defined over the set of odd

vertices V ′⊆V, where V ′={1,2,7,13,14,15,16,17,18,19}. The minimum weight perfect

matching set over odd vertices V ′ obtained from LEDA is M={(1,2), (18,19), (13,17),

(14,15), (24,16), (25,7)}. Among the edges defined in M, (24,16) and (25,7) are two

virtual edges which are not in the original graph. Denote l1 = (24, 16) and l2 = (25, 7);

then M ′={(1,2), (18,19), (13,17), (14,15)} and V ′′={1,2,13,14,15,17,18,19}. Let the

temporary starting and ending vertex of path P be o1 = 16 and o2 = 7, respectively.

30

3. Step 3: Find a Hamiltonian path connecting the vertices in V ′′ and covering the edges

in M ′. The path P1 is: 14-15-16-17-13-18-19-10-1-2. Let the starting vertex of P1 be s1

= 14, and ending vertex be s2 = 2. Since P1 contains vertex 16, which is the temporary

ending vertex of path P, go to Step 5. Here we obtain the final starting and ending

vertex of path P : o2 = 7, s2 = 2. Let vertex s1 = 14 be the marked vertex.

(a) General Graph G (b) Hamiltonian Path P1 (c) Eulerian Graph G′′

Figure A2: Application of Heuristic A to a General Graph

1. Step 5: Partition edges on path P1 into set E1={(14,15), (16,17), (13,18), (19,10),

(10,1)} and E2 = {(15, 16) , (17, 13) , (18, 19) , (1, 2)}; the resulting graph G′′(V, E

′′)

with removal of set E2 from graph G has only two odd nodes: 7 and 14. The Eulerian

path P2 constructed on G′′

is: 7-6-1-10-6-11-7-4-3-2-6-3-7-8-4-5-9-13-12-8-9-15-22-21-

17-18-12-11-10-19-12-9-14-5-8-11-19-20-18-13-16-17-20-21-16-22-23-15-14.

2. Step 6: Add path P2 after P3 by removing the marked vertex s1= 14. The resulting fi-

nal path P is 7-6-1-10-6-11-7-4-3-2-6-3-7-8-4-5-9-13-12-8-9-15-22-21-17-18-12-11-10-19-

12-9-14-5-8-11-19-20-18-13-16-17-20-21-16-22-23-15-14-15-16-17-13-18-19-10-1-2. The

repeated edges are underlined. The total length of path P is 57 with a reduced

expected search time 26.2115 compared to 26.3076 for the solution given in [15].

Note that the corresponding value of partial solution −→yr for the optimal path P is

{1,1,· · · ,1,0,1,0,1,0,1,0,0,1}. This partial solution satisfies the optimal structure of −→yrby Property 4 in Section 3.2. Therefore we can conclude that path P is optimal.

A.2.2 An example on a grid structured graph

Here we apply Heuristic A to the grid graph G shown in Figure A3(a). The minimum

weight perfect matching set found in Step 2 is M={(43,24), (42,13), (38,40), (33,36), (22,29),

31

(19,31), (8,16),(4,11), (2,3)}; therefore the resulting matching set without virtual edges is

M ′={(38,40), (33,36), (22,29), (19,31), (8,16),(4,11), (2,3)} and odd vertices set V ′′ is the

original odd vertices set with removal of the vertices 24 and 13. The shortest path connecting

covering edges in M ′ is found in Step 3. This path P1 is show in Fig. A3(b). Denoted vertices

are as following: o1 = 24, o2 = 13, s1 = 16 and s2 = 40. Since P1 does not contain either

o1 or o2, we move to Step 4. In Step 4, the distance between 16 and 24 has the smallest

distance among the four pairs o1 and s1, o2 and s1, o1 and s2, and o2 and s2; therefore we

extend P1 to be starting from s1 = 24 and ending with s2 = 40. Here s1 is the marked

vertex, o2 = 13 is the final starting vertex, and s2 = 40 is the final ending vertex. Edges

{(40,38),(36,33),(29,22),(19,31),(11,4),(3,2),(8,16)} are removed in Step 5 which makes the

remaining graph Eulerian with two odd vertices 13 and 24. An Eulerian path P2 is therefore

found and the final path P is obtained by extending P1 after P2. The expected search time

is the same as in [15] with an increased total path length of 80.

(a) Grid Structured Graph G (b) Hamiltonian Path P1 and Extended P1

Figure A3: Application of Heuristic to a Grid Structured Graph

32