Lecture Notes Discrete Optimization - Applied Mathematics

Note that in this example the number of feasible solution in F is uncountable. So why
does this problem qualify as a discrete optimization problem? The answer is that F
defines a feasible set that corresponds to the convex hull of a finite number of vertices.
It is not hard to see that if we optimize a linear function over a convex hull then there
always exists an optimal solution that is a vertex. We can thus equivalently formulate the
problem as finding a vertex x of the convex hull defined byF that minimizes c(x).
1.2 Algorithms and Efficiency
Intuitively, an algorithm for an optimization problem Π is a sequence of instructions
specifying a computational procedure that solves every given instance I of Π. Formally,
the computational model underlying all our considerations is the one of a Turing machine
(which we will not define formally here).
A main focus of this course is on efficient algorithms. Here, efficiency refers to the overall
running time of the algorithm. We actually do not care about the actual running time
(in terms of minutes, seconds, etc.), but rather about the number of basic operations.
Certainly, there are different ways to represent the overall running time of an algorithm.
The one that we will use here (and which is widely used in the algorithms community)
is the so-called worst-case running time. Informally, the worst-case running time of an
algorithm measures the running time of an algorithm on the worst possible input instance
(of a given size).
There are at least two advantages in assessing the algorithm’s performance by means
of its worst-case running time. First, it is usually rather easy to estimate. Second, it
provides a very strong performance guarantee: The algorithm is guaranteed to compute a
solution to every instance (of a given size), using no more than the stated number of basic
operations. On the downside, the worst-case running time of an algorithm might be an
overly pessimistic estimation of its actual running time. In the latter case, assessing the
performance of an algorithm by its average case running time or its smoothed running
time might be suitable alternatives.
Usually, the running time of an algorithm is expressed as a function of the size of the input
instance I. Note that a-priori it is not clear what is meant by the size of I because there
are different ways to represent (or encode) an instance.
Example 1.1. Many optimization problems have a graph as input. Suppose we are given
an undirected graph G=(V,E) with n nodes and m edges. One way of representing G is
by its n×n adjacency matrix A=(a i j ) with a i j = 1 if(i, j)∈ E and a i j = 0 otherwise. The
size needed to represent G by its adjacency matrix is thus n 2 . Another way to represent G
is by its adjacency lists: For every node i∈ V, we maintain the set L i ⊆ V of nodes that
are adjacent to i in a list. Note that each edge occurs on two adjacency lists. The size to
represent G by adjacency lists is n+2m.
The above example illustrates that the size of an instance depends on the underlying data
structure that is used to represent the instance. Depending on the kind of operations that
an algorithm uses, one might be more efficient than the other. For example, checking
2