5.7 How Integer Programming Codes Work

The most widely-used and effective algorithm for solving integer programming problems is Branch-and-Bound (see
Figure 5). First the problem is solved as an LP, i.e. ignoring the
requirement that the integer decision variables must take integer
values. The solution is examined. If all the integer decision variables
happen to have taken integer values, we are finished.

Figure 5: Branch-and-Bound Tree

If some of the integer decision variables are at non-integer values, we select one of these variables. Suppose n3 = 4.63. We define two sub-problems. In the first sub-problem we add the constraint n3≥ 5.0. In the other we add the constraint n3≤ 4.0. As the variable n3
must take an integer value, these two sub-problems between them contain
all possible integer feasible solutions which the original problem
contained.

We
select one of the sub-problems to solve as an LP. As we have already
solved the parent problem, we can solve the sub-problem very
efficiently by starting from the solution to the parent problem and
using the dual simplex algorithm. There are two possible outcomes.
Either the sub-problem has a feasible solution, in which case the
variable n3 will be at its bound (which is integer); or the
sub-problem will be infeasible. In the former case, we have made some
progress towards our aim of finding an integer feasible solution; in
the latter, we can exclude the sub-problem from further consideration.

We
then examine the solutions to the sub-problems for integer decision
variables which are at non-integer values and repeat our procedure,
developing a tree of sub-problems.

The
trouble with this approach is that at each stage there is an increase
in the number of sub-problems which we have to consider. Further,
integer decision variables which happen to be at integer values in one
sub-problem may move away from those values as we add further
constraints, or the sub-problem may become infeasible.

Even
if we find a solution in which all the integer decision variables take
integer values we are not finished. All that we know is that the
problem has an integer feasible solution. As we added constraints to
the sub-problems in developing our tree, so the objective function
worsened. We know the objective value of the original LP solution and
the objective value of the integer feasible solution which we have
found. But we do not know whether there are other integer feasible
solutions which are better than the one we have found. We must explore
the rest of the tree to find out.

This
is where we use the "and-Bound" part of the algorithm. Once we have an
integer feasible solution we know a worst-case value for the objective
of integer feasible solutions. This becomes the cut-off. When
we solve sub-problems we can discard them if their objective becomes
worse than the cut-off. We thus have two weapons for pruning the
proliferation of branches of the tree: infeasibility and the cut-off.
If we find a better integer feasible solution, its objective value
becomes the new cut-off. The Branch-and-Bound algorithm continues until
either the entire tree has been traversed or we run out of time.

There are several problems with the Branch-and-Bound algorithm:

there is an exponential proliferation of branches in the tree;

there
is no good way to estimate what will happen to the objective function
as one forces variables to integer values, or indeed, whether the
problem will remain feasible.

It
is because of these problems that Integer Programming is not
straightforward. You can help the IP code by giving it extra
information about your problem, such as using the high-level integer
structures of Special Ordered Sets, and by guiding the search.