IEOR 269, Spring 2010 Integer Programming and Combinatorial ...

IEOR269 notes, Prof. Hochbaum, 2010 11
On the other hand, the number of operations we need is roughly O(n 3 ): For each pair of the
O(n 2 ) rows, we need n additions (or subtractions) and n multiplications. Therefore, the number
of operations is a polynomial function on the input size.
However, there is an important issue we need to clarify here. When we are doing complexity
analysis, we must be careful if multiplications and divisions are used. While additions, subtractions,
and comparisons will not bring this problem, multiplications and divisions may increase the size of
numbers. For example, after multiplying two numbers a and b, we need ⌈log 2 ab⌉ ⌈log 2 a⌉+⌈log 2 b⌉
bits to represent a single number ab. If we further multiply ab by another number, we may need
even more bits to represent it. This exponentially increasing length of numbers may bring two
problems:
• The length of the number may go beyond the storage limit of a computer.
• It actually takes more time to do operations for “long” numbers.
In short, when ever we have multiplications and divisions in our algorithms, we must make sure that
the length of numbers does not grow exponentially, so that our algorithm is still polynomial-time,
as we desire.
For Gaussian elimination, the book by Schrjiver has Edmond’s proof (Theorem 3.3) that, at
each iteration of Gaussian elimination, the numbers grow only polynomially (by a factor of ≤ 4 with
each operation). With this in mind, we can conclude that Gaussian elimination is a polynomial-time
algorithm.
7.4 Linear Programming
Given an m × n matrix A, an m × 1 vector b, and an n × 1 vector c, the linear program to solve is
max
s.t.
c T x
Ax = b
x ≥ 0.
With the parameters A, b, and c, the input size is bounded below by
mn +
m∑
i=1 j=1
n∑
⌈log 2 a ij ⌉ +
m∑
⌈log 2 b i ⌉ +
i=1
n∑
⌈log 2 c j ⌉.
Now let’s consider the complexity of some algorithms for linear programming. As we already
know, the simplex method may need to go through almost all basic feasible solutions in some
instances. This fact makes the simplex method an exponential-time algorithm. On the other hand,
the ellipsoid method has been proved to be a polynomial-time algorithm for linear programming.
Let n be the number of variables and
( )
L = log 2 max{det B | B is a submatrix of A} ,
it has been shown that the complexity of the ellipsoid method is O(n 6 L 2 ).
It is worth mentioning that in practice we still prefer the simplex method to the ellipsoid
method, even if theoretically the former is inefficient and the latter is efficient. In practice, the
simplex method is usually faster than the ellipsoid method. Also note that the complexity of the
ellipsoid method depends on the values of A. In other words, in we keep the numbers of variables
and constraints the same but change the coefficients, we may result in a different running time.
This does not happen in running the simplex method.
j=1