Branch-and-Bound Technique for Solving Integer Programs

Slides:



Advertisements
Similar presentations
Integer Optimization Basic Concepts Integer Linear Program(ILP): A linear program except that some or all of the decision variables must have integer.
Advertisements

Integer Linear Programming
WOOD 492 MODELLING FOR DECISION SUPPORT Lecture 16 Integer Programming.
Branch-and-Bound Technique for Solving Integer Programs
Solving IPs – Cutting Plane Algorithm General Idea: Begin by solving the LP relaxation of the IP problem. If the LP relaxation results in an integer solution,
Pure, Mixed-Integer, Zero-One Models
Branch-and-Bound In this handout,  Summary of branch-and-bound for integer programs Updating the lower and upper bounds for OPT(IP) Summary of fathoming.
DMOR Branch and bound. Integer programming Modelling logical constraints and making them linear: – Conjuction – Disjunction – Implication – Logical constraints.
1 Cutting Plane Technique for Solving Integer Programs.
Water Resources Development and Management Optimization (Integer Programming) CVEN 5393 Mar 11, 2013.
Solving Integer Programs. Natural solution ideas that don’t work well Solution idea #1: Explicit enumeration: Try all possible solutions and pick the.
Dealing with NP-Complete Problems
Mathematical Modeling and Optimization: Summary of “Big Ideas”
Computational Methods for Management and Economics Carla Gomes
Linear Programming Integer Linear Models. When Variables Have To Be Integers Example – one time production decisions –Fractional values make no sense.
Integer Programming Difference from linear programming –Variables x i must take on integral values, not real values Lots of interesting problems can be.
Branch and Bound Algorithm for Solving Integer Linear Programming
D Nagesh Kumar, IIScOptimization Methods: M7L1 1 Integer Programming All Integer Linear Programming.
Review of Reservoir Problem OR753 October 29, 2014 Remote Sensing and GISc, IST.
LP formulation of Economic Dispatch
Graphical Solutions Plot all constraints including nonnegativity ones
(Not in text).  An LP with additional constraints requiring that all the variables be integers is called an all-integer linear program (IP).  The LP.
Integer programming Branch & bound algorithm ( B&B )
Chapter 11: Hillier and Lieberman Dr. Hurley’s AGB 328 Course
Mathematical Modeling and Optimization: Summary of “Big Ideas”
Operations Research Assistant Professor Dr. Sana’a Wafa Al-Sayegh 2 nd Semester ITGD4207 University of Palestine.
Types of IP Models All-integer linear programs Mixed integer linear programs (MILP) Binary integer linear programs, mixed or all integer: some or all of.
Integer Programming Key characteristic of an Integer Program (IP) or Mixed Integer Linear Program (MILP): One or more of the decision variable must be.
Approximation Algorithms Department of Mathematics and Computer Science Drexel University.
WOOD 492 MODELLING FOR DECISION SUPPORT
Applications of Dynamic Programming and Heuristics to the Traveling Salesman Problem ERIC SALMON & JOSEPH SEWELL.
15.053Tuesday, April 9 Branch and Bound Handouts: Lecture Notes.
Integer Programming Li Xiaolei. Introduction to Integer Programming An IP in which all variables are required to be integers is called a pure integer.
Divide and Conquer Optimization problem: z = max{cx : x  S}
Integer LP In-class Prob
M Tech Project – First Stage Improving Branch-And-Price Algorithms For Solving 1D Cutting Stock Problem Soumitra Pal [ ]
Branch and Bound Algorithms Present by Tina Yang Qianmei Feng.
1.2 Guidelines for strong formulations  Running time for LP usually depends on m and n ( number of iterations O(m), O(log n)). Not critically depend on.
5-1 Copyright © 2013 Pearson Education Integer Programming: The Branch and Bound Method Module C.
Integer Programming, Branch & Bound Method
Chapter 6 Optimization Models with Integer Variables.
Approximation Algorithms based on linear programming.
1 Chapter 6 Reformulation-Linearization Technique and Applications.
0 Integer Programming Introduction to Integer Programming (IP) Difficulties of LP relaxation IP Formulations Branch and Bound Algorithms Reference: Chapter.
Solving IPs – Implicit Enumeration Similar to Binary IP Branch and Bound General Idea: Fixed variables – those for which a value has been fixed. Free Variable.
An Introduction to Linear Programming
Water Resources Development and Management Optimization (Integer and Mixed Integer Programming) CVEN 5393 Mar 28, 2011.
Nonlinear Programming Prepared by Lee Revere and John Large
Integer Programming An integer linear program (ILP) is defined exactly as a linear program except that values of variables in a feasible solution have.
Introduction to Operations Research
5.2 Mixed Integer Linear Programming
Integer Linear Programming
Chapter 3 The Simplex Method and Sensitivity Analysis
Integer Linear Programming
Linear Programming and Approximation
ENGM 435/535 Integer Programming.
Cynthia Phillips (Sandia National Laboratories)
Linear Programming Integer Linear Models.
Integer Linear Programming
5.2 Mixed Integer Linear Programming
6.5 Stochastic Prog. and Benders’ decomposition
We have the following incomplete B&B tree:
Branch-and-Bound Algorithm for Integer Program
1.2 Guidelines for strong formulations
Integer LP: Algorithms
1.2 Guidelines for strong formulations
Integer Programming (IP)
5.2 Mixed Integer Linear Programming
Presentation transcript:

Branch-and-Bound Technique for Solving Integer Programs In this handout Basic concepts Introducing the technique based on an example

Basic Concepts The basic concept underlying the branch-and-bound technique is to divide and conquer. Since the original “large” problem is hard to solve directly, it is divided into smaller and smaller subproblems until these subproblems can be conquered. The dividing (branching) is done by partitioning the entire set of feasible solutions into smaller and smaller subsets. The conquering (fathoming) is done partially by (i) giving a bound for the best solution in the subset; (ii) discarding the subset if the bound indicates that it can’t contain an optimal solution. These three basic steps – branching, bounding, and fathoming – are illustrated on the following example.

Example of Branch-and-Bound 6 Max Z = 5x1 + 8x2 s.t. x1 + x2  6 5x1 + 9x2  45 x1 , x2 ≥ 0 integer x1 + x2 = 6 5 4 (2.25, 3.75) 3 Z=41.25 2 5x1 + 9x2 = 45 1 Z=20 1 2 3 4 5 7 8 6

Utilizing the information about the optimal solution of the LP-relaxation Fact: If LP-relaxation has integral optimal solution x*, then x* is optimal for IP too. In our case, (x1, x2) = (2.25, 3.75) is the optimal solution of the LP-relaxation. But, unfortunately, it is not integral. The optimal value is 41.25 . Fact: OPT(LP-relaxation) ≥ OPT(IP) (for maximization problems) That is, the optimal value of the LP-relaxation is an upper bound for the optimal value of the integer program. In our case, 41.25 is an upper bound for OPT(IP).

Branching step In an attempt to find out more about the location of the IP’s optimal solution, partition the feasible region of the LP-relaxation. Choose a variable that is fractional in the optimal solution to the LP-relaxation – say, x2 . Observe that every feasible IP point must have either x2  3 or x2 ≥ 4 . With this in mind, branch on the variable x2 to create the following two subproblems: Subproblem 1 Subproblem 2 Max Z = 5x1 + 8x2 Max Z = 5x1 + 8x2 s.t. x1 + x2  6 s.t. x1 + x2  6 5x1 + 9x2  45 5x1 + 9x2  45 x2  3 x2 ≥ 4 x1 , x2 ≥ 0 x1 , x2 ≥ 0 Solve both subproblems (note that the original optimal solution (2.25, 3.75) can’t recur)

Branching step (graphically) Z=41 Subproblem 1: Opt. solution (3,3) with value 39 Subproblem 2: Opt. solution (1.8,4) with value 41 5 Subproblem 2 4 (1.8, 4) 3 (3, 3) 2 Subproblem 1 1 Z=39 Z=20 1 2 3 4 5 7 8 6

Solution tree S1: x2  3 (3, 3) Z=39 For each subproblem, we record the restriction that creates the subproblem the optimal LP solution the LP optimum value The optimal solution for Subproblem 1 is integral: (3, 3). If further branching on a subproblem will yield no useful information, then we can fathom (dismiss) the subproblem. In our case, we can fathom Subproblem 1 because its solution is integral. The best integer solution found so far is stored as incumbent. The value of the incumbent is denoted by Z*. In our case, the first incumbent is (3, 3), and Z*=39. Z* is a lower bound for OPT(IP): OPT(IP) ≥ Z* . In our case, OPT(IP) ≥ 39. The upper bound is 41: OPT(IP)  41. int. All (2.25, 3.75) Z=41.25 S2: x2 ≥ 4 (1.8, 4) Z=41

Next branching step (graphically) - Fathom Subproblem 1. - Branch Subproblem 2 on x1 : Subproblem 3: New restriction is x1  1. Opt. solution (1, 4.44) with value 40.55 Subproblem 4: New restriction is x1 ≥ 2. The subproblem is infeasible 5 (1, 4.44) Subpr. 4 Subpr. 3 4 3 Z=40.55 Z=20 2 1 1 2 3 4 5 7 8 6

Solution tree (cont.) int. S1: x2  3 (3, 3) Z=39 int. If a subproblem is infeasible, then it is fathomed. In our case, Subproblem 4 is infeasible; fathom it. The upper bound for OPT(IP) is updated: 39  OPT(IP)  40.55 . Next branch Subproblem 3 on x2 . (Note that the branching variable might recur). All (2.25, 3.75) Z=41.25 S3: x1  1 (1, 4.44) Z=40.55 S2: x2 ≥ 4 (1.8, 4) Z=41 S4: x1 ≥ 2 infeasible

Next branching step (graphically) Branch Subproblem 3 on x2 : Subproblem 5: New restriction is x2  4. Feasible region: the segment joining (0,4) and (1,4) Opt. solution (1, 4) with value 37 Subproblem 6: New restriction is x2 ≥ 5. Feasible region is just one point: (0, 5) Opt. solution (0, 5) with value 40 (0, 5) 5 4 (1, 4) 3 Z=20 2 1 1 2 3 4 5 7 8 6

Solution tree (final) int. int. S1: x2  3 (3, 3) Z=39 int. S5: x2  4 (1, 4) Z=37 If the optimal value of a subproblem is  Z*, then it is fathomed. In our case, Subproblem 5 is fathomed because 37  39 = Z*. If a subproblem has integral optimal solution x*, and its value > Z*, then x* replaces the current incumbent. In our case, Subproblem 5 has integral optimal solution, and its value 40>39=Z*. Thus, (0,5) is the new incumbent, and new Z*=40. If there are no unfathomed subproblems left, then the current incumbent is an optimal solution for (IP). In our case, (0, 5) is an optimal solution with optimal value 40. int. All (2.25, 3.75) Z=41.25 S3: x1  1 (1, 4.44) Z=40.55 S2: x2 ≥ 4 (1.8, 4) Z=41 S6: x2 ≥ 5 (0, 5) Z=40 int. S4: x1 ≥ 2 infeasible