Tải bản đầy đủ - 0 (trang)
Chapter 22. Parametric Integer Programming: the Righthand-Side Case

# Chapter 22. Parametric Integer Programming: the Righthand-Side Case

Tải bản đầy đủ - 0trang

R.E. Marsten, T.L. Morin

376

present paper, which has grown out of the authors’ work on synthesizing dynamic

programming with branch-and-bound [3, 4, 51, is devoted to the right-hand-side

case.

In parametric linear programming, the first step is to solve (Po), i.e. (P,) for 8 = 0.

Then the direction vector d = (d,, . . ., d,) is specified and the analysis is performed

by driving 8 from 0 to 1. Critical values of 8 and new optimal solutions are

identified one at a time as 8 increases. In the procedure for parametric integer

programming to be presented here, the direction d must be specified in advance.

The (PIP) is solved in one branch-and-bound search. The usual bounding test is

modified so that a partial solution is eliminated only if none of its descendants is

optimal for any (P,), 0 S 8 6 1. This means that some partial solutions must be

retained that could otherwise be eliminated if only (Po) were of interest. The

severity of the resulting computational burden depends on the magnitude of d.

The organization of the paper is as follows. A prototype branch-and-bound

algorithm for (Po) is presented in Section 2 .

The lower bound and upper bound functions are developed in Sections 3 and 4,

respectively. The modified branch-and-bound algorithm for (PIP) is given in

Section 5 and applied to a sample problem in Section 6. Computational experience

with the algorithm is reported in Section 7.

2. A prototype branch-and-bound algorithm

We shall draw upon the framework and terminology of Geoffrion and Marsten

[ 2 ] to describe a simple linear programming based branch-and-bound algorithm for

(Po). Problem (Po) is separated, by fixing variables at zero and one, into smaller

candidate problems (CP4). Each candidate problem has an associated set of fixed

variables F 4 C J = (1, . . ., n} and partial solution x q . That is, (CPq) is defined by the

conditions x, = x 4 for j E F 4 . The current set of candidate problems is called the

candidate list. If any feasible solutions of (Po) are known, the best of these is called

the incumbent and its value denoted by LB. If we let J 4 = J - F4 be the set of

“free” variables and

where Ai is the j t h column of A, then a typical candidate problem may be written

as (CP4)

subject to

up,

b, - p?, 1

i

J E J ~

x, E (0, l}, j E J 4 .

m,

Parametric integer programming

377

An upper bound on the value of (CPq) is obtained by solving its LP relaxation

(CP;). It is also helpful to compute a lower bound on the value of (CP.). This can

be done by using a heuristic to find a feasible solution of (CP.). This feasible

solution, if it is better than the incumbent, becomes the new incumbent. A

prototype branch-and-bound algorithm may now be described as follows.

Step 1. Place (Po) in the candidate list and set LB = - 00.

Step 2. If the candidate list is empty, stop. If there is an incumbent, it is optimal

for (Po). Otherwise (Po) is infeasible.

Step 3. Select a candidate problem and remove it from the candidate list. Call it

(CP.).

Step 4. Solve the linear program (CP;). Let UBq denote its optimal value.

Step 5. If UBq s LB, go to Step 2.

Step 6. If the optimal solution of (CP:) is all integer, make this solution the new

incumbent, set LB = UBq, and go to Step 2 .

Step 7. Use a heuristic to find a feasible solution of (CP.). Let H 4 denote its

value. If H q > LB, then make this solution the new incumbent and set LB = H q .

Step 8. Separate (CP4) into two candidate problems (CPq') and (CP.") by

choosing p E J 4 and setting F4'= Fq"= Fq U { p } , x;' = 0, x;" = 1. Place (CP.') and

(CP.") in the candidate list and return to Step 2.

A great many variations on this pattern are described in [ 2 ] , but this prototype

will suffice for our purposes. Step 5 is the bounding test. If this test is satisfied, then

no descendant of x q is better than the incumbent. Notice that the bounding test

includes the case where (CPZ), and hence (CP.), is infeasible since then UBq =

- 00. If (CPq) does not have to be separated at Step 8, then we say that it has been

fathomed. This occurs if (CPq) passes the bounding test or if (CP;) has an all

integer solution. Step 7, the heuristic, is optional. Its purpose is to strengthen the

bounding test by improving the incumbent and increasing LB.

The modifications that must be made to this prototype algorithm to solve (PIP)

are confined to Steps 5, 6 and 7. The notion of the incumbent must be generalized

from a single value LB to a function LB(8) defined on 0 =s8 =s 1. The upper bound

must also be expressed as a function of 8: UB4(8). The bounding test then becomes

a comparison of two functions on the interval 0 8 c 1 rather than just a point

comparison for 8 = 0.

3. The optimal return and lower bound functions

In this section we shall investigate the behavior of the optimal value of an integer

program as a function of its right-hand-side. Let the optimal return function

f ( b ' ) = max rx

subject to Ax s b'

x E (071)

R.E. Marsten, T.L. Morin

378

be defined for b‘ E R”’.It is apparent that f(b’) is nondecreasing in each component

of b’. Let {x k E K} be the set of all feasible solutions of (PIP), i.e. of all (P,) for

0 S 8 S 1. For each k E K , define the step function

1

I

otherwise

---do

for all b’ E R”’.The optimal return function f(b’) is the pointwise maximum of this

finite collection of nondecreasing step functions

1

f ( b ’ ) = max {fk (b’) k E K }

and is therefore itself a nondecreasing step function.

are known, where 17 K. A lower

Now suppose that the solutions { x * k E

approximation of f(b’) may be constructed from these known solutions, namely

I

f(b’)=max{f*(b’)( k

z}

€17).

Clearly f ( b ’ )is also a nondecreasing step function and is a lower bound function for

f(b’), i.e. f ( b ’ )S f(b’) for all b’ E R”.The approximation can be improved as new

feasible solutions are discovered.

We are interested in a particular “slice” of f(b’) and f(b’): the line segment

{b + 8d 10 S 8 S 1) where b is the right-hand-side of (Po) and d is the given

direction vector. Define g ( 8 ) = f(b + 8 d ) and LB(8) = f ( b + Bd) for 0 s 8 s 1.

Then g(8) and LB(8) are both step functions and LB(8) s g ( 8 ) for all 0 s 8 s 1. If

d 3 0, then g ( 8 ) and LB(8) are both nondecreasing. (See Fin. 1). There is at least

m e optimal solution of (PIP) associated with each step of g ( 8 ) . Solving (PIP) is

equivalent to constructing g ( 8 ) by finding at least one x solution for each of its

steps.

0

8

Fig. 1. Typical g(0) and LB(0) functions.

I

Parametric integer programming

379

The procedure for constructing LB(8) from the known feasible solutions is as

define

follows. For each k E

{ 1 2 A , x ; c 6 + Bd]

8 : = min 8

j=l

8: = max

{ 8 I 2 Ajx7 s 6 + (Id}

j=1

where 8 :

=

8:

=

+

00

if the indicated set is empty. Then

rjx:

if 8 : s

e c e:,

LBk( 8 ) =

(3.3)

I

--tc1

otherwise,

LB(8)=max{LBk(8))k

€z}.

(3.4)

The solutions which determine LB(8) will be called the incumbents. Each one is

incumbent for a particular interval of 8.

4. The upper bound functions

Consider a given partial solution x q . In order to demonstrate that no descendant

of x q could be optimal for any (Ps),we need an upper bound on the return achieved

by any descendant and this upper bound must depend on 8. Such an upper bound

can be obtained by introducing ( 8 d ) into the relaxed candidate problem (CP;).

Define

UBq(8) =

2 r,x4 + max 2 rjxj

j€Fq

subject to

j€Jq

a,x, s 6, + Od, - /3:,

1S i c m,

I E J ~

so that UBq(0) = UBq. It is well known that UBq(8) is concave and piecewise linear

on 0 s 0 c 1. The function UBq(8) could be obtained explicitly by ordinary

parametric linear programming. The computational burden involved in doing this

for every candidate problem could be quite substantial, however. Fortunately any

dual feasible solution of (CP;) can be used to construct a linear upper bound

function for UBq(8). An optimal dual solution of (CP; ), barring degeneracy, yields

the first linear segment of UBq(8). By linear programming duality we know that:

380

R.E. Marsten, T.L. Morin

r,xF

UB"(8)=

+ min

z=l

jEFq

m

subject to

,=I

m

u,a,, + u, 2 r,,

u,(b, + Od,- P 4 ) +

"

2 u,,

,=I

j E Jq,

u, 2 0 , l s i s r n ,

u, 2 0 , l s j s n.

For notational convenience we have included all of the u, variables, even though

u, = 0 for j' E F" in any optimal solution. Let D q denote the dual feasible region

Since the primal variables are all bounded and at least one (P,) is feasible, we may

conclude that 0" is non-empty. Let { ( u ' , u ' ) t E T q }and { ( y ' , z " ) s E S " } denote

the sets of extreme points and extreme rays, respectively, of 0 " .Taking e =

(1,. . ., 1) we have

1

UB"(8)s

r,x;

1

+ u ' ( b + 8d - P q ) + u'e

,€F4

for all t E T", with equality if ( u ' , u ' ) is optimal for the objective function

u ( b + 8d - P q ) + ue. As a function of 8 then, the return achieved by any descendant of x " is bounded above by:

UB4 ( 0 ; t ) = ( u * d ) 0+

r,xy

[f€F''

+ u ' ( b - P q ) + ule

I

for any t E T". This is a linear function of 8 and, since u ' 3 0, it is nondecreasing if

d 20.

In the modified branch-and-bound algorithm for (PIP), linear programming is

applied to (CPZ) as usual. The functions UB4(8;t ) are obtained at n o extra cost.

The function obtained from an optimal dual solution will be denoted UB4(8;*).

Barring degeneracy, UB"(8;*) coincides with the first linear segment of UB4(8)

(see Fig. 2). As in conventional branch-and-bound, if the dual simplex method is

used, then suboptimal dual solutions can be used to perform additional weaker

tests.

If (CPR) is infeasible, then the simplex method will terminate with an extreme

point ( u ' , u r )3 0 and an extreme ray ( y ' , 2') 3 0 , such that

y ' ( b - p ") + z 'e < 0.

If y ' d s 0 , then we may conclude that UB4(8)= - = for all 0 8 s 1. If y " d > 0 ,

then U B 4 ( 8 ) = - - f o r O s 8 < 8 * a n d U B " ( 8 ) s UB4(0 ; t)for 0 * s 0 G 1, where

e* =

-

Y ( b - P ' ) - zse

Y "d

Param eiric integer programming

0

381

6

Fig. 2. Typical UB4(0) and UB4( 0 ; *) functions.

5. A branch-and-bound algorithm for (PIP)

Now that the upper and lower bound functions have been derived, the

generalized bounding test may be stated. The partial solution x q does not have a

descendant that is better than an incumbent if

UBq(8) s LB(8),

for all 0 S 8 S 1,

or if

UB4(8; t ) S LB(8),

for all 0 s 8 s 1,

for some t E T 4 .This test is the basis for a modified branch-and-bound algorithm

that can solve (PIP).

Step 1. Place (Po) in the candidate list and set LB(8) = - 30 for 0 8 S 1.

Step 2. If the candidate list is empty, stop. LB(8) = g(8) for 0 s 8 S 1 .

Step 3. Select a candidate problem and remove it from the candidate list. Call it

(CP.).

Step 4. Solve (CP;). If it is infeasible, obtain the appropriate dual extreme

point ( u *, v *) and extreme ray ( y *, z *). Otherwise obtain an optimal dual solution

( u * , v*).

Step 5. I. (CP:) infeasible.

(a) y * d 0. Go to Step 2.

(b) y * d > O . Set 8 * = [ - y * ( b - p ) - z * e ] / y * d . If U B q ( 8 ; * ) s L B ( 8 ) for all

8 * s e s 1, go to Step 2.

11. (CR4,) feasible. If UB4(8;*) ==LB(8) for all 0 s 8 s 1 , go to Step 2.

Step 6. If the optimal primal solution of (CPX) is all integer, use it to update

LB(8).

Step 7. Use a heuristic to find feasible solutions of (CPq) with right-hand-side

( b + 8 d ) for several values of 8. Use these feasible solutions to update LB(8).

R.E. Marsten, T.L. Morin

382

Step 8. Separate (CPq) into two new candidate problems (CP4') and (CP4") by

choosing p E J 4 and setting Fq' = Fq"= F U { p } x \$ = 0, x;" = 1. Place (CP.') and

(CP.") in the candidate list and return to Step 2.

The validity of the generalized bounding test insures that an optimal solution for

every (Po), 0 s 8 S 1, will be found by the search. At worst, an optimal solution

may not be discovered until the bottom of the branch-and-bound tree is reached

(Fq = J). This guarantees that LB(8) will coincide with g(8) by the time the

algorithm is finished. It remains only to show how the optimal solutions are

identified.

Let { x k k E E } be the set of incumbents when the algorithm terminates. Let

8 E [0,1]and suppose that (Po) is feasible, g ( 8 ) > - w. From the construction of

LB(8), (3.1)-(3.4),we know that there is some k E K such that

1

g ( 8 ) = LB(8)

= LBk(8)

=

2 r,x: >

-w.

1'1

Furthermore, L B k ( 8 ) > - w means that 8 ; s 8 c O,", or equivalently that

2 Ajxr

b + 8d.

j=1

Since x k is feasible for (Po) and its return is equal to g ( B ) , it follows that x k is

optimal for (Po). To summarize, if k E K and 8 E [0,1], then x Ir is optimal for (Po)

if and only if

"

Ajx: 5 b + 8d

(i)

j-1

At Step 6, in contrast to the prototype algorithm, x 4 is not fathomed when the

optimal primal solution of (CPZ) is all integer. This is because x 4 may have other

descendants which are optimal for 8 > 0. The use of heuristics at Step 7, while in

principle optional, is an important part of the algorithm since integer solutions of

(CPZ) can only yield LB(8) = LB(0) for 0 s 8 c 1. The heuristics are needed to

produce stronger values of LB(8) for 8 >O.

As with the prototype algorithm, the above procedure will admit considerable

variation and refinement. If the dual simplex method is used. then suboptimal dual

solutions can be used to perform additional bounding tests. Cutting planes can be

generated for any candidate problem to give stronger upper bound functions.

Parametric linear programming can be used to generate more than the first segment

of UBq(8). If a candidate problem with an all-integer LP solution has to be

separated at Step 8, then the same LP solution is optimal for one of the two new

Parametric integer programming

383

candidates and does not have to be recomputed. Extensive experimentation will be

required to determine the most effective computational tactics.

6. Example

In this section the algorithm will be applied to a simple example. In order to

illustrate all of the different cases that can arise, the parameterization will be done

over a relatively large interval. The test problem is

max lox1+ 15x2+ l o x 3 + 5x4

subject to 2x1+ 3x2+ 5x3+ 1x4s 4 + 8 4

~ x , + ~ x , + I x , + I x , ~ ~ +8 4

xi E {0,1} 1 s j s 4

Thus b = (4,4), d = (4,4) and increasing 8 from zero to one amounts to doubling

the right-hand-side. A picture of the optimal return function f(b') is given in Fig. 3.

8

7

6

5

b;

4

25

3

2

01

1

I

I

2

I

I

I

1

I

3

4

5

6

7

8

bl'

Fig. 3. The optimal return function f(b').

The dashed line indicates the line segment of interest: { b + 8d 10 s 8 s 1). It is

clear from this picture that three optimal solutions must be found, with values of 20,

25, and 30. These solutions are (0,1,0, l), (1,1,0,0), and (1,1,0,1) respectively. The

g ( 8 ) function, shown in Fig. 4, is

20

25

30

for 0 s 8 < 112,

for 1 1 2 s 8 <3/4,

for 3 / 4 6 8 s 1.

R.E. Marsten, T.L. Morin

3 84

t--+20

I

I

I

I

0

114

I/ 2

3 /4

I

Fig. 4. The parametric function g(0).

The optimal LP solution of (Po) is x = (1/2,1,0,0), u = (5,0), u = (0) with value

UBo = 20. The rounded down solution has value 15 and is feasible for 0 2 0; the

rounded up solution has value 25 and is feasible for 0 2 1/2. This provides an initial

lower bound function:

15 for 0 s 8 < 1/2,

LB(8) =

25 for 1/2< 8 S 1.

The complete branch-and-bound tree is displayed in Fig. 5. The nodes will be

discussed in the order in which they were created.

Fig. 5. Branch-and-bound tree for the example

385

Parametric integer programming

Node 1. LP solution: x = (0,1,0, l), u = (5,0), u = (0), UB' = 20. UB'(8; *) =

208 + 20. The LP solution is all integer and is feasible for 8 3 0. Therefore the

lower bound function may be improved:

LB(8)

=

r

20 for 0 s 8 < 1/2,

25 for 1 / 2 s 8 s 1.

The bounding test for node 1 is shown in Fig. 6. Node 1 is not fathomed.

I14

112

314

I

Fig. 6. Bounding test for node 1

Node 2. LP solution: x = (1,0,0,0), u = (0, lo), u = (0), UB2 = 10. UB'(8; *) =

408 + 10. The bounding test, shown in Fig. 7, is not successful. Notice that if we

were only interested in solving (Po) we would be finished. Node 1 has an all integer

solution with value 20 and node 2 has upper bound UB2 = 10 < 20 = LB(0).

I /4

1/2

314

I

Fig. 7. Bounding test for node 2.

Node 3. LP solution: x = (0,0,3/5, l), u = (2,0), u = (0,0,0,3), UB3 = 11.

UB3(8;*) = 88 + 11. The bounding test, shown in Fig. 8, is successful and node 3 is

fathomed.

Node 4. Same as node 1, since optimal LP solution at node 1 has x2 = 1 .

Node 5. Same as node 2, since optimal LP solution at node 2 has xz = 0.

R.E. Marsten. T.L. Morin

386

25t

I

5 t

01

I

I

I /4

112

I

3/4

I

Fig. 8. Bounding test for node 3.

Node 6. LP is infeasible. The dual extreme point is u = (0, lo), u = (0) and the

extreme ray is y = (0, l), z = (0). The critical value of 8 is ( - y (b - p") - z e ) / y d =

1/2. Thus UB"(8) = - m for 0 s 8 < 1/2 and UB"(8; *) = 408 + 5 for 1/2 s 8 G 1.

The bounding test is shown in Fig. 9.

I

I

I

I /4

112

3/4

I

Fig.9. Bounding test for node 6.

Node 7. Same as nodes 1 and 4, since optimal LP solution for node 4 has x3 = 0.

Node 8. LP is infeasible. The dual extreme point is u = (5,0), u = (0) and the

extreme ray is y = (1,0), z = (0). The critical value of 8 is ( - y ( b - p 8 )- z e ) / y d =

1, so UB8(8)= - O D on 0 s 8 s 1 and node 8 is fathomed.

Node 9. Same as nodes 2 and 5, since optimal LP solution for node 5 has x7 = 0.

Node 10. LP is infeasible. The dual extreme point is u = (5,0), u = (0) and the

extreme ray is y = (l,O), z = (0). The critical value of 8 is ( - y ( b - PIo)- z e ) / y d =

3/4. Thus UB'O(8) = - m for 0 s 8 < 3/4 and UB"(8; *) = 208 + 5 for 3/4 S 8 G 1.

Node 10 is therefore fathomed. See Fig. 10.

Node 11. LP is infeasible. The dual extreme point is u = (0,5),u = (0) and the

extreme ray is y = (0, l), z = (0). The critical value of 8 is ( - y ( b - P I ' ) - z e ) / y d = ### Tài liệu bạn tìm kiếm đã sẵn sàng tải về

Chapter 22. Parametric Integer Programming: the Righthand-Side Case

Tải bản đầy đủ ngay(0 tr)

×