10.5
607
Integer Polynomial Programming
in two stages. In the first stage we see how an integer variable, x i, can be represented
by an equivalent system of zero-one (binary) variables. We consider the conversion
of a zero-one polynomial programming problem into a zero-one LP problem in the
second stage.
10.5.1
Representation of an Integer Variable by an Equivalent System
of Binary Variables
Let x
i
be any integer variable whose upper bound is given by u
x
i
_u
i
so that
i
(10.32)
< ff
We assume that the value of the upper bound u i can be determined from the constraints
of the given problem.
We know that in the decimal number system, an integer p is represented as
p = p 0 + 10
1p
1
2p
+ 10
2
+ · · · , 0 _ p i _ (10 Š 1 = 9)
i = 0, 1, 2 . . .,
for
and written as p = · · · p 2p 1p 0 by neglecting the zeros to the left. For example, we write
the number p = 008076 as 8076 to represent p = 6 + (10 1)7 + (10 2)(0) + (10 3)8 +
(10 4)0 + (10 5)0. In a similar manner, the integer p can also be represented in binary
number system as
p=q
0
1q
+2
1
2q
+2
2
+2
3q
3
+···
where 0 _ q i _ (2 Š 1 = 1) for i = 0, 1, 2, . . . .
(1)
(2)
In general, if y (0)
i
, yi , yi , . . . denote binary numbers (which can take a value of
0 or 1), the variable x i can be expressed as
Ni
xi =
•
k=0
2k
yi
(k)
(10.33)
where N i is the smallest integer such that
ui + 1
2
• 2 Ni
(10.34)
Thus the value of N i can be selected for any integer variable x
i
once its upper bound
u i is known. For example, for the number 97, we can take u
relation
the
98 = 49 _ 2N
ui + 1
=
i
2
2
is satisfied for N i _ 6. Hence by taking N i = 6, we can represent u
97 = q
0
+2
1q
1
+2
2q
2
+2
where q 0 = 1, q 1 = q 2 = q 3 = q 4 = 0, and q
ing the values of q 0, q 1, q 2, . . . is given below.
5
3q
=q
3
+2
6
i
4q
i
= 97 and hence
as
4
+2
5q
5
+2
6q
6
= 1. A systematic method of find-
608
Integer Programming
.
Let M be the given positive integer. To find its
Method of Finding q 0, q 1, q 2, . . .
binary representation q qn nŠ1 . . . q 1q 0, we compute the following recursively:
b0 = M
b1 =q
0
b
1
2
bkŠ1 Š q kŠ1
bk =
= 1 if b
k
is odd and q
k
Š
q1
...
k
Š
2
b
0
b2 =
where q
(10.35)
2
= 0 if b
k
is even. The procedure terminates when
bk = 0.
Equation (10.33) guarantees that x i can take any feasible integer value less than
or equal to u i. The use of Eq. (10.33) in the problem stated in Eq. (10.30) will convert
the integer programming problem into a binary one automatically. The only difference
is that the binary problem will have N 1 + N 2 + · · · + N n zero-one variables instead
of the n original integer variables.
10.5.2
Conversion of a Zero-One Polynomial Programming Problem
into a Zero-One LP Problem
The conversion of a polynomial programming problem into a LP problem is based on
the fact that
xiaki fi xi
(10.36)
if x i is a binary variable (0 or 1) and aki is a positive exponent. If = 0, then
obviously
the variable x i will not be present in the kth term. The use of Eq. (10.36)
aki
permits us to write the kth term of the polynomial, Eq. (10.31), as
n
n
k
ck _ (x
l=1 l)
akl
= ck _
k
l=1
xl = c k(x
nk)
1,
x
2,
...,x
(10.37)
Since each of the variables x 1, x 2, . . . can take a value of either 0 or 1, the
product
(x 1x 2 · · · x nk) also will take a value of 0 or 1. Hence by defining a binary
variable
y k as
_
yk = x 1x 2 · · · xnk
(10.38)
xl
n
l=1
=
k
10.6
609
Branch-and-Bound Method
the kth term of the polynomial simply becomes c y . However, we need to add the
k
following constraints to ensure that y
k
= 1 when all x i = 1 and zero otherwise:
_ n
k
y k _ • xi Š (n k Š 1)
k
(10.39)
i=1
y
It can be seen that if all x
i
= 1,
k_
•
_
1
nk
i=1
kn
nk
•
xi
xi = n k, and Eqs. (10.39) and (10.40) yield
y
k
_1
(10.41)
y
_1
(10.42)
k
which can be satisfied only if y k = 1. If at least one x
and Eqs. (10.39) and (10.40) give
y
(10.40)
i=1
k
i
= 0, we have
•
i=1
kn
xi < n k,
_ Š(n k Š 1)
(10.43)
yk < 1
(10.44)
Since n k is a positive integer, the only way to satisfy Eqs. (10.43) and (10.44) under
all circumstances is to have y k = 0.
This procedure of converting an integer polynomial programming problem into an
equivalent zero-one LP problem can always be applied, at least in theory.
10.6
BRANCH-AND-BOUND METHOD
The branch-and-bound method is very effective in solving mixed-integer linear and
nonlinear programming problems. The method was originally developed by Land and
Doig [10.8] to solve integer linear programming problems and was later modified
by Dakin [10.23]. Subsequently, the method has been extended to solve nonlinear
mixed-integer programming problems. To see the basic solution procedure, consider
the following nonlinear mixed-integer programming problem:
Minimizef (X)
(10.45)
subject to
gj (X) _ 0,
j = 1, 2, . .
.,m
h (kX )
k = 1, 2, . . . , p
= 0,
j = 1, 2, . . . , n 0 (n 0 _ n)
xj = integer,
where X = {x
1,
x
2,
(10.46)
(10.47)
(10.48)
. . . , x n} T. Note that in the design vector X, the first n 0 variables
are identified as the integer variables. If n 0 = n, the problem becomes an all-integer
programming problem. A design vector X is called a continuous feasible solution if
610
Integer Programming
X satisfies constraints (10.46) and (10.47). A design vector X that satisfies all the
constraints, Eqs. (10.46) to (10.48), is called an integer feasible solution.
The simplest method of solving an integer optimization problem involves enumerating all integer points, discarding infeasible ones, evaluating the objective function
at all integer feasible points, and identifying the point that has the best objective
function value. Although such an exhaustive search in the solution space is simple
to implement, it will be computationally expensive even for moderate-size problems.
The branch-and-bound method can be considered as a refined enumeration method in
which most of the nonpromising integer points are discarded without testing them. Also
note that the process of complete enumeration can be used only if the problem is an
all-integer programming problem. For mixed-integer problems in which one or more
variables may assume continuous values, the process of complete enumeration cannot
be used.
In the branch-and-bound method, the integer problem is not directly solved. Rather,
the method first solves a continuous problem obtained by relaxing the integer restrictions on the variables. If the solution of the continuous problem happens to be an
integer solution, it represents the optimum solution of the integer problem. Otherwise,
at least one of the integer variables, say x i, must assume a nonintegral value. If x i is
not an integer, we can always find an integer [x i] such that
[x i] < x i < [x i] +
(10.49)
1
Then two subproblems are formulated, one with the additional upper bound
constraint
x
_ [x i]
(10.50)
_ [x i] + 1
(10.51)
i
and another with the lower bound constraint
x
i
The process of finding these subproblems is called branching.
The branching process eliminates some portion of the continuous space that is not
feasible for the integer problem, while ensuring that none of the integer feasible solutions are eliminated. Each of these two subproblems are solved again as a continuous
problem. It can be seen that the solution of a continuous problem forms a node and
from each node two branches may originate.
The process of branching and solving a sequence of continuous problems discussed
above is continued until an integer feasible solution is found for one of the two continuous problems. When such a feasible integer solution is found, the corresponding
value of the objective function becomes an upper bound on the minimum value of the
objective function. At this stage we can eliminate from further consideration all the
continuous solutions (nodes) whose objective function values are larger than the upper
bound. The nodes that are eliminated are said to have been fathomed because it is
not possible to find a better integer solution from these nodes (solution spaces) than
what we have now. The value of the upper bound on the objective function is updated
whenever a better bound is obtained.