MATH3902 Operations Research II: Integer Programming Topics

Transcription

1 MATH3902 Operations Research II Integer Programming p.0 MATH3902 Operations Research II: Integer Programming Topics 1.1 Introduction Some examples of ILP and MILP Example 1.1: Capital Budgeting Problem Example 1.2: Dichotomy Example 1.3: k-fold Alternatives Example 1.4: If-Then Constraints Example 1.5: Piecewise-Linear Continuous Function Example 1.6: Fixed Charge Problem Some basic properties of ILP and MILP Example 1.7: Methods of Integer Programming Cutting plane methods Method of Integer Forms for ILP Example 1.8: Mixed Cut for MILP Example 1.9: Branch-and-Bound method Example 1.10: Branch-and-Bound Algorithm for ILP [Source of material: Integer Programming by R.S. Garfinkel and G.L. Nemhauser] 0

2 MATH3902 Operations Research II Integer Programming p.1 LN/MATH3902/TGY/CKC/MS/ Chapter 1 Integer Programming (Source: Integer Programming by R.S. Garfinkel and G.L. Nemhauser) 1.1 Introduction Integer programming is a branch of mathematical programming. A general mathematical programming problem can be stated abstractly as MP : max f(x), x S R n where the set S is called the constraint set and f is called the objective function. Every x S is called a feasible solution to (MP). If there is an x S satisfying > f(x ) f(x) for all x S then x is called an optimal solution to (MP). Note that linear programming is simply a special case of (MP) with f(x) being a linear function and S being the set of vectors x satisfying a system of linear equations Ax = b and x 0. An integer programming problem is a mathematical programming problem in which S Z n R n where Z n is the set of all n-dimensional integer vectors (i.e. all the components of x are restricted to integer values). A mixed integer programming problem is a mathematical programming problem in which at least one, but not all, of the components of x S are required to be integers. In this chapter, we consider integer programming and mixed integer programming problems which can be reduced to linear programming problems by dropping the integer restrictions on the variables. Specifically, we shall discuss: (1) Integer linear programming problem (ILP) Max (or Min) z = c x subject to Ax = b, x 0 integer. (2) Mixed integer linear programming problem (MILP) Max (or Min) z = c 1 x + c 2 v subject to A 1 x + A 2 v = b x 0 integer v 0.

3 MATH3902 Operations Research II Integer Programming p.2 The LP obtained by dropping the integrality constraints from the ILP or the MILP will be referred to as the corresponding LP (or its LP relaxation) Some examples of ILP and MILP Let us first give an example of an ILP, to be followed by several examples of MILP: Example 1.1: Capital Budgeting Problem A firm has n projects that it would like to undertake but, because of budget limitations, not all can be selected. In particular, project j has a present value of c j, and requires an investment of a ij dollars in the time period i, i = 1, 2,, m. The capital available in time period i is b i. The problem of maximizing the total present value subject to the budget constraints can be written as n Max z = c j x j subject to j=1 n a ij x j b i, i = 1, 2,, m j=1 x j = 0, 1 j = 1, 2,, n where x j = 1 if project j is selected. There are many problems such as Example 1.1 above where the integrality constraint arises quite naturally. Besides these obvious applications, we shall show that linear constraint with integer or binary variables can be used to model a variety of complex relations that may be difficult to tackle otherwise. Example 1.2: Dichotomy Consider the problem Max z = f(x) subject to g(x) 0 or h(x) 0 or both. This is a mathematical programming problem where the (either-or) constraint is called a dichotomy and is not easily handled by any standard algorithm. However, if it is known that g and h have finite lower bounds g and h, then the dichotomy is equivalent to g(x) δg h(x) (1 δ)h δ = 0, 1. If f, g and h are linear, the resulting problem is an MILP.

4 MATH3902 Operations Research II Integer Programming p.3 Example 1.3: k-fold Alternatives A generalization of Example 1.2 is to replace the dichotomy constraint by the following condition: At least k of the m constraints g i (x) 0 i = 1,, m must hold, where 1 k < m. The condition can be replaced by the constraint set: g i (x) δ i g i, i = 1,, m m δ i m k i=1 δ i = 0, 1 i = 1,, m where each g i is a known finite lower bound on g i (x). Example 1.4: If-Then Constraint To transform the conditional constraint g(x) > 0 h(x) 0 into an equivalent set of constraints without the conditional relation, we can use the following formulation: g(x) M(1 δ) h(x) Mδ δ = 0, 1 where M is arbitrarily large. Example 1.5. Piecewise-Linear Continuous Function Let f(t) be a piecewise-linear continuous function given by a set of line segments determined by the points (s 1, f 1 ),, (s p, f p ). Figure 1.1 below illustrats the case of f(t) being a piecewise-linear approximation for a non-linear curve, with p = 5. f j (x j ) (s 1j, f 1j ) (s 2j, f 2j ) (s 4j, f 4j ) (s 3j, f 3j ) (s 5j, f 5j ) u j x j Figure 1.1

5 MATH3902 Operations Research II Integer Programming p.4 The function f(t), 0 t u, can be represented as follows: p f(t) = Min λ k f k k=1 subject to t = p λ k s k k=1 p λ k = 1 k=1 λ k 0 k = 1,, p. Furthermore, no more than two of the λ k can be positive and these must be of the form λ k, λ k+1. This condition can be achieved by the addition of adjacency constraints: λ 1 δ 1 λ k δ k 1 + δ k, k = 2,, p 1 λ p δ p 1 p 1 δ k = 1 k=1 δ k = 0, 1 k = 1,, p 1. Remark: The above representation of f(t) is called a mixed-integer minimization model (MIMM) for the function f(t), and is used to convert f(t), a nonlinear function, into a more manageable linear model. Consider the following problem: n Min f j (x j ) j=1 subject to Ax = b, x 0, where each f j (x j ) is a piecewise linear continuous function. Then using the above MIMM representation for each f j (x j ), this nonlinear problem can be converted into a MILP. Example 1.6: Fixed Charge Problem In a typical production planning problem involving N products, the production cost for product j may consist of a fixed cost d j independent of the amount produced and a variable cost c j per unit. Thus if x j is the production level of product j, its production cost function may be written as { dj + c j x j, x j > 0 f j (x j ) = 0 x j = 0. This is nonlinear in x j because of the discontinuity of f j (x j ) at the origin. Consequently, the following minimum cost problem is also nonlinear: N Min z = f j (x j ) j=1 subject to Ax = b, x 0.

6 MATH3902 Operations Research II Integer Programming p.5 If it is known that 0 x j u j and d j > 0 then the nonlinear function f j (x j ) can be transformed into a linear minimization model as follows: f j (x j ) = Min c j x j + d j y j subject to x j u j y j 0 y j = 0, 1 It means that for a given value of x j, the value f j (x j ) is equal to the optimal value of the ILP and therefore can be represented by the ILP. Rewriting all the f j (x j ) in terms of their MIMM in the minimum cost problem, we get N Min z = (c j x j + d j y j ) j=1 subject to 0 x j u j y j, j = 1,, N y j = 0, 1 j = 1,, N Ax = b Some basic properties of ILP and MILP Before explaining how methods of IP work in general, we make the following elementary but important observation: If we solve the LP relaxation of a pure IP and obtain a solution in which all variables are integers, then the optimal solution to the LP relaxation is also an optimal solution to the IP. To see why this observation is true, consider the following IP: Max z = 3x 1 + 2x 2 subject to 2x 1 + x 2 6 x 1, x 2 0 integer The optimal solution to the LP relaxation of this pure IP is x 1 = 0, x 2 = 6, z = 12. Because this solution gives integer values to all variables, the preceding observation implies that it is also the optimal solution to the IP. Observe that the feasible region for the IP is a subset of the points in the LP relaxation s feasible region. Thus, the optimal z-value for the IP cannot be larger than the optimal z-value (= 12) for the LP relaxation. Thus the point x 1 = 0, x 2 = 6, with z = 12, must be optimal for the IP. From the computational standpoint, ILP problems are much more difficult than LP problems. One convenient way to solve an ILP is to solve the corresponding LP and then round the solution to the closest feasible integers. However, this approach is obviously

7 MATH3902 Operations Research II Integer Programming p.6 inadequate in many cases. For instance, in the Capital Budgeting problem, the binary variable x j is used to denote whether a project is accepted or rejected. In this case, it is nonsensical to deal with fractional values of x j, and the use of rounding is logically unacceptable. Also consider the following example. Example 1.7: Max z = 2x 1 + x 2 subject to x 1 + x 2 5 x 1 + x 2 0 6x 1 + 2x 2 21 x 1, x 2 0 integer Figure 1.2 From the above figure, it is clear that there are eight feasible solutions to the ILP and that the optimal solution is x 1 = 3, x 2 = 1. However, the optimal solution to the corresponding LP is x 1 = 11/4, x 2 = 9/4. In this case, rounding the optimal LP solution does not give us the optimal integer solution Methods of Integer Programming Even though a bounded ILP has only a finite number of feasible solution, the integer nature of the variables makes it difficult to devise an effective algorithm that searches directly among the feasible integer points of the solution space. In view of this difficulty, researchers have developed a solution procedure that is based on exploiting the tremendous success in solving LP problems. The strategy for this procedure can be summarized in three steps:

8 MATH3902 Operations Research II Integer Programming p.7 (1) Relax the integer constraints of the ILP so that the ILP is converted into a regular LP. (2) Solve the resulting relaxed LP model and identify its (continuous) optimum point. (3) Starting from the continuous optimum point, add special constraints that will iteratively force the optimum extreme point of the resulting LP model toward the desired integer restrictions. There are two widely used methods for generating the special constraints that will force the optimum point of the relaxed LP problem toward the desired integer solution: 1. Cutting plane. 2. Branch-and-bound. In both methods, the added constraint will eliminate portions of the relaxed solution space, but never any of the feasible integer points. Neither of the two methods can be claimed to be uniformly more effective in solving ILP s. Nevertheless, branch-and-bound methods are far more successful computationally than are the cutting-plane methods. For this reason most commercial codes are based on the use of the branch-and-bound procedure Cutting plane methods The basic idea of the cutting plane method is to cut off parts of the feasible region of the corresponding LP, so that the optimal integer solution becomes an extreme point and therefore can be found by the simplex algorithm. For instance, if we add two additional constraints (cutting planes) to Figure 1.2 of Example 1.7 as in the following figure. Figure 1.3 Then the optimal integer solution (3, 1) can be found by solving the corresponding LP. One of the methods to generate these cuts is as follows.

9 MATH3902 Operations Research II Integer Programming p.8 Method of Integer Forms for ILP We assume all problems are comprised of rational data (notice that all numbers stored in digital computers are rational) and since rational data can be transformed into integral data by multiplying by a suitable constant, we shall only consider problems comprised of integral data. Let an ILP be given. Assume that a non-integer optimal solution x of the corresponding LP has been found, and that the optimal tableau is written as x j b z z x r y rj x r where {x r : r B} are the basic variables and {x j : j N} are the non-basic variables. Suppose that x has a non-integer component x r. Then for any feasible integer solution x, we have x r + y rj x j = x r. (1) j N Since x 0, x r + j N[y rj ]x j x r (2) where [u] = largest integer u. Since x has integer components, the L.H.S. of (2) must be an integer. Thus Subtracting (3) from (1), we get (y rj [y rj ])x j x r [x r]. j N x r + j N[y rj ]x j [x r]. (3) Letting y rj = [y rj ] + f rj and x r = [x r] + f r, we obtain (a Gomory cut) f rj x j f r (4) or j N Further S must also be integral since ( x r = f r + j N S = f r + j N f rj x j, S 0. (5) ) ( f rj x j + [x r] ) [y rj ]x j j N and both x r and the expression inside the second parenthesis on the R.H.S. are integral. An important property of (5) is that f r > 0. Thus (5) can be used as a constraint (cutting plane) to exclude the optimal soluton x of the corresponding LP having f r > 0. Furthermore (5) does not exclude any feasible integer solution.

10 MATH3902 Operations Research II Integer Programming p.9 Example 1.8: Consider Example 1.7. Rewrite the problem in standard form: Max z = 2x + x 2 subject to x 1 + x 2 + x 3 = 5 x 1 + x 2 + x 4 = 0 6x 1 + 2x 2 + x 5 = 21 x 1,, x 5 0 integer and solve the corresponding LP. This yields the following optimal tableau x 3 x 5 b z 1/2 1/4 31/4 x 1 1/2 1/4 11/4 x 2 3/2 1/4 9/4 x 4 2 1/2 1/2 Using (4) to generate a cut yields Table 1 x 3 /2 + x 5 /4 3/4 x 3 /2 + 3x 5 /4 1/4 x 5 /2 1/2 (x 1 -row) (x 2 -row) (x 4 -row) Each row could serve as the source of a cut, or simply as a source row. Suppose we add the x 4 -row cut, or x 5 /2 + S 1 = 1/2, S 1 0 to Table 1. This yields Table 2 with S 1 = 1/2 as a new basic variable in the dual feasible solution. x 3 x 5 b z 1/2 1/4 31/4 x 1 1/2 1/4 11/4 x 2 3/2 1/4 9/4 Source x 4 2 1/2 1/2 Cut S 1 0 1/2 1/2 Table 2 Whenever additional constraint is added, dual feasibility but not primal feasibility is retained. Thus it is convenient to reoptimize using the dual simplex algorithm. Following the dual simplex algorithm, S 1 leaves and x 5 enters the basis. After pivoting we obtain

11 MATH3902 Operations Research II Integer Programming p.10 Table 3 (excluding the S 2 row) x 3 S 1 b z 1/2 1/2 15/2 Source x 1 1/2 1/2 5/2 x 2 3/2 1/2 5/2 x x Cut S 2 1/2 1/2 1/2 Table 3 Here we can choose either x 1 or x 2 row as a source row. Arbitrarily selecting the x 1 row, we obtain x 3 /2 + S 1 /2 1/2. Thus we add the constraint x 3 /2 S 1 /2 + S 2 = 1/2 to Table 3 and reoptimize. The departing variable is S 2. Either x 3 or S 1 can enter, and we choose x 3. After pivoting, we obtain Table 4. S 2 S 1 b z x x x x x Table 4 The solution is primal and dual feasible, and integral; therefore it is optimal to the ILP. Remarks: (1) If the source rows are chosen according to a scheme developed by Gomory, then it can be proved that the algorithm must terminate after a number of iterations. (2) The methods of integer forms has two disadvantages (i) When this algorithm is implemented on digital computer, round-off errors may cause serious problem, especially in distinguishing integers from non-integers. (ii) The solution of the problem remains infeasible until the optimal integer solution is reached. This means that there will be no good integer solution on hand, if the calculations are stopped prematurely owing to budget or time limitations.

12 MATH3902 Operations Research II Integer Programming p.11 (3) To overcome the difficulties stated above, various cutting plane methods, such as dual all-integer algorithm, primal all-integer algorithm etc. have been developed. But each algorithm has its own disadvantages. (4) For all cutting plane methods, there is no upper bound on the number of cuts required. In practice, very often the number of cuts required is so large that the problem becomes insolvable computationally. Mixed Cut for MILP Let x r be an integer variable of the MILP. Again, as in the pure integer case, consider the x r -equation in the optimal continuous solution. This is given by x r + y rj x j = x r (Source row) j N and x r [x r] = f r j N y rj x j. Because some of the nonbasic variables may not be restricted to integer values in this case, it is incorrect to use the cut developed in the preceding section. But a new cut can be devised based on the same general idea. For x r to be integer, either x r [x r] or x r [x r] + 1 must be satisfied. From the source row, these conditions are equivalent to: y rj x j f r (6) j N y rj x j f r 1. (7) j N Let J + = set of subscripts j in N for which y rj 0 J = set of subscripts j in N for which y rj < 0. Then from (6) and (7) one gets y rj x j f r (8) j J + ( fr ) y rj x j f r. (9) f r 1 j J Since (6) or (7), and hence (8) or (9), must hold, and the left hand sides of both (8) and (9) are non-negative, it follows that (8) and (9) can be combined into one constraint of the form S y rj x j + j J + ( fr ) f r 1 y rj x j = f r j J (Mixed cut)

13 MATH3902 Operations Research II Integer Programming p.12 where S 0 is a nonnegative slack variable. The last equation is the required mixed cut and it represents a necessary condition for x r to be integer. When this cut is added to the optimal tableau, the tableau becomes primal infeasible but retains dual feasibility. The dual simplex method is used to clear the infeasibility. Example 1.9: Consider Example 1.8. Suppose that only x 1 is restricted to integer values. From the x 1 -row in Table 1, the mixed cut is { 1 S 1 4 x 5 + or S x x 3 = 3 4. ( 3 )( } )x 3 = 3 2 4, Adding this to the tableau in Table 1 gives x 3 x 5 b z 1/2 1/4 31/4 x 1 1/2 1/4 11/4 x 2 3/2 1/4 9/4 x 4 2 1/2 1/2 S 1 3/2 1/4 3/4 Table 5 After pivoting, we obtain S 1 x 5 b z 1/3 1/6 15/2 x 1 1/3 1/3 3 x 2 1 1/2 3/2 x 4 4/3 5/6 3/2 x 3 2/3 1/6 1/2 Table 6 The solution is primal and dual feasible, and x 1 is integral; therefore it is optimal to the MILP. 1.6 Branch-and-Bound Method Consider the ILP: max z = c x subject to x S 0 where S 0 = {x Ax = b, x 0 integer}. The general idea of the branch-and-bound method is first to solve the problem as a continuous model, i.e. solve its corresponding LP: max z = c x subject to x T 0 = {x Ax = b, x 0}.

14 MATH3902 Operations Research II Integer Programming p.13 Suppose x r is an integer-constrained variable whose optimum continuous value x r is fractional. The range [x r] < x r < [x r] + 1 cannot include any feasible integer solution. Consequently, a feasible integer value of x r must satisfy one of the two conditions, namely x r [x r] or x r [x r] + 1 These two conditions when applied to the continuous model result in two mutually exclusive problems with constraint sets: (i) T 1 = {x Ax = b, x r [x r], x 0} (ii) T 2 = {x Ax = b, x r [x r] + 1, x 0}. And when the integrality constraints are also included, the sets S 1 = {x Ax = b, x r [x r], x 0 integer} S 2 = {x Ax = b, x r [x r] + 1, x 0 integer} actually form a separation of S 0, i.e. S 1 S 2 = S 0, S 1 S 2 = φ. The optimal solution x of the given problem must lie either in S 1 or S 2 and must also be the optimal solution of one of the subproblems: (i) max z = c x subject to x S 1 (ii) max z = c x subject to x S 2. These subproblems can again be solved by repeating the above process of relaxing the integrality constraint and branching when the optimal solution has a component with fractional value. This branching process will generate a rooted tree, with each node k of the tree corresponding to a subproblem: max z = c x subject to x S k. If the optimal solution of its corresponding LP is feasible with respect to the integrality constraints (i.e. has integer components), it will be recorded and its objective value will constitute a lower bound for the optimum. In this case it will be unnecessary to further branch this subproblem and the node is said to have fathomed. Nodes not yet fathomed are called live. At any node the optimum value (or the greatest integer less than or equal to the optimum value if the objective function has integer coefficients) z k of its corresponding LP is an upper bound for the optimum value of all its children. If the upper bound is less than the best lower bound available, then it is also unnecessary to branch this subproblem. The process of branch and bound continues until each subproblem terminates either with an integer solution or its upper bound is less than the current lower bound. In this case the best feasible solution at hand, if any, is the optimum. Example 1.10: and max z = 7x 1 3x 2 4x 3 subject to x 1 + 2x 2 + 3x 3 x 4 = 8 3x 1 + x 2 + x 3 x 5 = 5 x 1, x 2,, x 5 0 integer

15 MATH3902 Operations Research II Integer Programming p.14 We begin by solving the corresponding LP. The optimal solution is x 1 = 2 5, x 2 = 19 5, x 3 = x 4 = x 5 = 0 with z 0 = [ 71 5 ] = 15. We must now partition S 0 based on x 1 or x 2 and we arbitrarily choose x 2. resulting tree is shown in Figure 1.4. z = 15 0 z = x 2 3 x 2 4 z = z = 15 The Figure 1.4 The optimal solution of the LP at node 1 is x 1 = 1 2, x 2 = 3, x 3 = 1 2, x 4 = x 5 = 0 with z 1 = [ 29 2 ] = 15. There is no change in the bounds. We choose to branch node 1 using x 1 as in Figure 1.5. z = 15 0 z = x 2 3 x z = 15 x 1 0 x 1 1 z = z = 15 Figure 1.5 Taking the left branch and solving the LP, we obtain an all-integer optimal solution: x 1 = 0, x 2 = 3, x 3 = 2, x 4 = 4, x 5 = 0 with z 3 = 17. Thus the new lower bound z 0 = max{, z 3 } = 17. Also node 3 is fathomed and we backtrack to node 4. It is found that z 4 = 18 < z 0 and node 4 is fathomed. We now backtrack to node 2. The optimal solution of its LP is x 1 = 1 3, x 2 = 4, x 3 = 0, x 4 = 1/3, x 5 = 0 with z 2 = [ 43 3 ] = 15. We choose to branch on x 1 and obtain Figure 1.6. z = 15 0 z = 17 x 2 3 x x 1 0 x 1 1 x 1 0 x 1 1 z = z = 18 5 z = 15 6 z = 15 Figure 1.6

16 MATH3902 Operations Research II Integer Programming p.15 At node 5, the optimal solution of its LP is all-integer and z 5 = 15. Thus z 0 = max{z 0, z 5 } = 15 and nodes 5 and 6 are fathomed. An optimal solution is given by the solution at node 5: x 1 = 0, x 2 = 5, x 3 = 0, x 4 = 2, x 5 = 0 and z = 15. Branch-and-Bound Algorithm for ILP (assuming that an upper bound u j each variable x j and the problem is a maximization problem.) is known for Step 1: (Initialization) Step 2. Begin with one live node 0, where z 0 =, z 0 =. Go to Step 2: (Branching) If no live nodes exist, go to Step 7; otherwise select a live node k (usually according to the backtracking algorithm). If the corresponding LP has been solved, go to Step 3; otherwise go to Step 4. Step 3: (Separation) Choose a variable with fractional value, i.e. x r = [x r] + f r, 0 < f r < 1. Then a separation of the constraint set S k at node k is constructed as follow: S k {x x r [x r]} and S k {x x r [x r] + 1}. Go to Step 2. Step 4: (Solving the LP) Solve the corresponding LP. If the LP has no feasible solution, node k is fathomed and we go to Step 2. If the LP has an optimal solution x, let z k = [z ] and go to Step 5. (z is the value of the objective function at x.) Step 5: (Fathoming by integrality) If x is not all-integer, go to Step 6. If x is integer, let z 0 = max{z 0, z }. Go to Step 6. Step 6: (Fathoming by bounds) 2. Any node k such that z k z 0 is fathomed. Go to Step Step 7: (Termination) Terminate. If z 0 = there is no feasible solution. If z 0 >, that feasible solution which yielded z 0 is optimal. Remark: (1) If each variable x j is bounded above, then it can be easily proved that the above algorithm must terminate after a finite number of steps. (2) The efficiency of the above algorithm depends directly on (i) the way that the different subproblems are generated, i.e. which variable with fractional value is used to generate a separation of the constraint set. (ii) the way that the nodes of the tree are scanned. In the above example, we have used the backtracking algorithm. But, scanning the nodes by some other rules may be faster sometimes.

17 MATH3902 Operations Research II Integer Programming p.16 Unfortunately, there is no definite best way for handling this problem, only empirical rules exist which do enhance the process. These rules are usually implemented in most of the commercial branch-and-bound codes. (3) The corresponding LP can be solved by either the primal or dual simplex procedure. For Example 1.10, the dual approach is readily applicable when the LP is rewritten as: max z = 7x 1 3x 2 4x 3 subject to x 1 2x 2 3x 3 8 3x 1 x 2 x 3 5 x 1, x 2, x 3 0 integer (4) After obtaining an optimal solution of the corresponding LP at a node, the addition of a constraint x r [x r] or x r [x r] + 1 will destroy the primal feasibility of the solution. But since dual feasibility is retained we can reoptimize using the dual simplex algorithm. For example, at node 0 of Example 1.10, an optimal LP tableau is obtained as in the following table: x 3 x 4 x 5 b z 3/5 2/5 11/5 71/5 x 1 1/5 1/5 2/5 2/5 x 2 8/5 3/5 1/5 19/5 Table 7 When the constraint x 2 3 is added, we can rewrite it as S = 3 x 2 = 3 ( x 3 ( 3 5 )x x 5), or S 8 5 x x x 5 = 4 5, and add it to the tableau: x 3 x 4 x 5 b z 3/5 2/5 11/5 71/5 x 1 1/5 1/5 2/5 2/5 x 2 8/5 3/5 1/5 19/5 S 8/5 3/5 1/5 4/5 Table 8 Using the dual simplex iteration once we get S x 4 x 5 b z 3/8 5/8 17/8 29/2 x 1 1/8 1/8 3/8 1/2 x x 3 5/8 3/8 1/8 1/2 Table 9

18 MATH3902 Operations Research II Integer Programming p.17 which is both optimal and primal feasible. Hence we obtain the (non-integer) optimal solution x 1 = 1 2, x 2 = 3, x 3 = 1 2, x 4 = x 5 = 0 at node 1. (5) As stated before, branch-and-bound methods are empirically observed to be far more successful computationally than are the cutting-plane methods. Unfortunately, an unsuspecting comparison could easily lead to a naive opposite conclusion incorrectly. For example, consider adding a Gomory cut generated from the x 2 -row 3x 3 /5 2x 4 /5 x 5 /5 + x 6 = 4/5 to Table 7 and reoptimize. The departing variable is x 6. Either x 3 or x 4 can enter, and suppose we choose x 4. After one pivot, we obtain Table 10. It yields the same optimal integer solution given at node 5 of the branch-and-bound tree in Example x 3 x 6 x 5 b z x 1 1/2 1/2 1/2 0 x 2 5/2 3/2 1/2 5 x 4 3/2 5/2 1/2 2 Table 10 However, had we chosen x 3 as the entering variable instead, we would get an optimal (continuous) solution with all basic variables taking on fractional values as in the following table: x 6 x 4 x 5 b z x 1 1/3 1/3 1/3 2/3 x 2 8/3 5/3 1/3 5/3 x 3 5/3 2/3 1/3 4/3 Table 11 (6) The branch and bound algorithm can also be applied to MILP. For MILP, only those variables with integrality constraint are examined and if any of these variables takes fractional value, further separation will be performed. For example, if in Example 1.10, only x 2 is required to be integer, then the branch-and-bound tree will consist of three nodes 0, 1 and 2, as given by Figure 1.4. (The bounds are z 0 = 71/5, z 1 = 29/2 and z 2 = 43/3 instead.) Both nodes 1 and 2 are fathomed by integrality, with the optimal MILP solution given by the solution at node 2.