An approximation algorithm for a general class of parametric optimization problems

In a (linear) parametric optimization problem, the objective value of each feasible solution is an affine function of a real-valued parameter and one is interested in computing a solution for each possible value of the parameter. For many important parametric optimization problems including the parametric versions of the shortest path problem, the assignment problem, and the minimum cost flow problem, however, the piecewise linear function mapping the parameter to the optimal objective value of the corresponding non-parametric instance (the optimal value function) can have super-polynomially many breakpoints (points of slope change). This implies that any optimal algorithm for such a problem must output a super-polynomial number of solutions. We provide a method for lifting approximation algorithms for non-parametric optimization problems to their parametric counterparts that is applicable to a general class of parametric optimization problems. The approximation guarantee achieved by this method for a parametric problem is arbitrarily close to the approximation guarantee of the algorithm for the corresponding non-parametric problem. It outputs polynomially many solutions and has polynomial running time if the non-parametric algorithm has polynomial running time. In the case that the non-parametric problem can be solved exactly in polynomial time or that an FPTAS is available, the method yields an FPTAS. In particular, under mild assumptions, we obtain the first parametric FPTAS for each of the specific problems mentioned above and a (3/2+ε)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$(3/2 + \varepsilon )$$\end{document}-approximation algorithm for the parametric metric traveling salesman problem. Moreover, we describe a post-processing procedure that, if the non-parametric problem can be solved exactly in polynomial time, further decreases the number of returned solutions such that the method outputs at most twice as many solutions as needed at minimum for achieving the desired approximation guarantee.

Keywords Parametric optimization · Approximation algorithm · Parametric assignment problem · Parametric minimum cost flow problem · Parametric shortest path problem · Parametric metric TSP

Introduction
In a linear parametric optimization problem, the objective function value of a feasible solution does not only depend on the solution itself but also on a parameter λ ∈ R, where this dependence is given by an affine-linear function of λ. The goal is to find an optimal solution for each possible parameter value, where, under some assumptions (e.g., if the set of feasible solutions is finite), an optimal solution can be given by a finite collection of intervals (−∞, λ 1 ], [λ 1 , λ 2 ], . . . , [λ K −1 , λ K ], [λ K , +∞) together with one feasible solution for each interval that is optimal for all values of λ within the corresponding interval.
The function mapping each parameter value λ ∈ R to the optimal objective value of the non-parametric problem induced by λ is called the optimal value function (or the optimal cost curve). The above structure of optimal solutions implies that the optimal value function is piecewise linear and concave in the case of a minimization problem (convex in case of a maximization problem) and its breakpoints (points of slope change) are exactly the points λ 1 , . . . , λ K (assuming that K was chosen as small as possible).
There is a large body of literature that considers linear parametric optimization problems in which the objective values of feasible solutions are affine-linear functions of a real-valued parameter. These problems often arise naturally from important nonparametric problems. Karp and Orlin (1981) observe that the minimum mean cycle problem can be reduced to the parametric shortest path problem (Carstensen 1983b;Mulmuley and Shah 2001). Young et al. (2006) note that parametric shortest path problems appear in the process of solving the minimum balance problem, the minimum concave-cost dynamic network flow problem (Graves and Orlin 1985), and matrix scaling (Orlin and Rothblum 1985;Schneider and Schneider 1991). Other prominent examples include the parametric assignment problem (Gassner and Klinz 2010) and the parametric minimum cost flow problem (Carstensen 1983a). Moreover, parametric versions of general linear programs, mixed integer programs, and nonlinear programs (where the most general cases consider also non-affine dependence on the parameter as well as constraints depending on the parameter) are widely studied-see Mitsos and Barton (2009) for an extensive literature review.
The number of breakpoints is a natural measure for the complexity of a parametric optimization problem since it determines the number of different solutions that are needed in order to solve the parametric problem to optimality. Moreover, any instance of a parametric optimization problem with K breakpoints in the optimal value function can be solved by using a general method of Eisner and Severance (1976), which requires to solve O(K ) non-parametric problems for fixed values of the parameter. Carstensen (1983a) shows that the number of breakpoints in the optimal value function of any parametric binary integer program becomes linear in the number of variables when the slopes and/or intercepts of the affine-linear functions are integers in {−M, . . . , M} for some constant M ∈ N. In most parametric problems, however, the number of possible slopes and intercepts is exponential and/or the variables are not binary. While there exist some parametric optimization problems such as the parametric minimum spanning tree problem (Fernández-Baca et al. 1996) or several special cases of the parametric maximum flow problem (Arai et al. 1993;Gallo et al. 1989;McCormick 1999;Scutellà 2007) for which the number of breakpoints is polynomial in the input size even without any additional assumptions, the optimal value function of most parametric optimization problems can have super-polynomially many breakpoints in the worst case-see, e.g., Carstensen (1983b), Nikolova et al. (2006) for the parametric shortest path problem, Gassner and Klinz (2010) for the parametric assignment problem, and Ruhe (1988) for the parametric minimum cost flow problem. This, in particular, implies that there cannot exist any polynomial-time algorithm for these problems even if P = NP, which provides a strong motivation for the design of approximation algorithms.
To the best of our knowledge, the only existing approximation algorithms for a parametric optimization problem are the approximation schemes for the parametric version of the 0-1 knapsack problem presented in Giudici et al. (2017), Holzhauser and Krumke (2017). Additionally, an approximation scheme for the variant of the 0-1 knapsack problem in which the weights of the items (instead of the profits) depend on the parameter has recently been provided in Halman et al. (2018).
If only positive values are allowed for the parameter λ, linear parametric optimization is closely related to computing supported solutions in biobjective linear optimization problems. Approximating the set of supported solutions in multiobjective optimization has been considered in Daskalakis et al. (2016), Diakonikolas (2011), Diakonikolas and Yannakakis (2008). Under some additional assumptions, approximation in linear parametric optimization problems and approximating supported solutions in biobjective linear optimization problems are equivalent (Diakonikolas 2011;Diakonikolas and Yannakakis 2008). For these overlapping cases, many of the algorithms presented here are similar to the ones studied in Daskalakis et al. (2016), Diakonikolas (2011), Diakonikolas andYannakakis (2008).
Our contribution In Sect. 3, we provide a polynomial-time (parametric) approximation method for a general class of parametric optimization problems whose non-parametric versions have a polynomial-time approximation algorithm available. This means that, for any problem from this class, the method computes a set of solutions that approximate all feasible solutions for all values of λ within the given interval of allowed parameter values. The approximation guarantee of this method depends on the approximation guarantee achievable for the corresponding non-parametric problem. If the non-parametric problem can be approximated within a factor of β ≥ 1, then, for any ε > 0, the parametric problem can be approximated within a factor of (1+ε)·β in time polynomial in the size of the input and in 1 ε . Thus, if an FPTAS or an exact algorithm for the non-parametric problem is available, we obtain a (parametric) FPTAS for the parametric problem.
Moreover, in Sect. 4, we provide an algorithm for parametric problems whose non-parametric version is solvable exactly that, given any β-approximation S of cardinality |S| for the parametric problem, computes a minimum-cardinality subset S of S that still forms a β-approximation. The running time of this algorithm is quadratic in |S| in general. However, we show that, if this algorithm is applied to a β-approximation computed by the approximation method from Sect. 3, then (i) the running time can be reduced to being linear in |S| and (ii) the cardinality of the computed subset S is at most twice as large as the cardinality of any β-approximation for the given problem instance. We will see that this factor of two is best possible in the sense that, for the studied problem class, no algorithm can achieve a better factor in general.
Our approximation method can be viewed as an approximate version of the wellknown Eisner-Severance method for parametric optimization problems (Eisner and Severance 1976). It applies, in particular, to all parametric optimization problems for which the parameter varies on the nonnegative real line, the non-parametric problem can be approximated in polynomial time, and the slopes and intercepts of the value functions of the feasible solutions are nonnegative integer values below a polynomialtime computable upper bound. Under mild assumptions, we obtain the first parametric FPTAS for the parametric versions of the shortest path problem, the assignment problem, and a general class of mixed integer linear programming problems over integral polytopes, which includes the minimum cost flow problem as a special case. As we discuss in the applications of our method presented in Sect. 5, the number of breakpoints can be super-polynomial for each of these parametric problems even under our assumptions, which implies that the problems do not admit any polynomial-time exact algorithms. We moreover obtain a ( 3 2 + ε)-approximation for the parametric version of the APX-hard metric traveling salesman problem.
This work extends our conference paper (Bazgan et al. 2019), in which a less adaptive version of the algorithm is presented only for the special case where the non-parametric problem can be solved exactly. Moreover, the question of computing approximations with small cardinality is not considered in the conference paper.

Preliminaries
In the following, we consider a general parametric minimization or maximization problem Π of the following form: The goal is to provide an optimal solution to this optimization problem for every λ ∈ I , where I = [λ min , ∞) for some λ min ∈ R, which is given as part of the input of the problem. More precisely, a solution x * λ ∈ X is sought, for every λ ∈ I , such that where f : I → R is the optimal cost curve mapping each parameter value to its corresponding optimal objective function value. It is assumed that the optimal cost curve is well-defined, i.e., min / max x∈X f x (λ) exists for every λ ∈ I . It is easy to see that the optimal cost curve f is continuous and concave (for minimization problems) or convex (for maximization problems).
For any λ ∈ I , we call the non-parametric problem obtained from Π by fixing the parameter value to λ the non-parametric version of Π .
Even though all our results apply to minimization as well as maximization problems, we focus on minimization problems in the rest of the paper in order to simplify the exposition. All our arguments can be straightforwardly adapted to maximization problems.
We assume that the functions a, b : X → R defining the intercepts and slopes of the value functions, respectively, are polynomial-time computable, and that we can compute positive rational bounds LB and UB such that b(x), f x (λ min ) ∈ {0} ∪ [LB, UB] for all x ∈ X in polynomial time. In particular, this implies that LB and UB are of polynomial encoding length. 1 These assumptions ensure that the objective function values f x (λ) are nonnegative for all x ∈ X and λ ∈ I , which is a usual requirement when considering approximation. The bounds LB and UB are guaranteed to exist, e.g., for combinatorial optimization problems for which the decision version of the non-parametric problem is in NP, and also for problems where a(x) and b(x) only attain nonnegative integer values of polynomial encoding length (we can choose LB = 1 in this case).
We say that a solution x ∈ S ⊆ X is supported in S if x is optimal within S for some parameter value, i.e., if f x (λ) = min x ∈S f x (λ) for at least one λ ∈ I . If a solution x ∈ X is supported in X , we simply call x supported.
For two solutions x, x ∈ X for which b(x) = b(x ), we define μ(x, x ) ∈ R to be the value where the two lines f x (·) and f x (·) intersect, i.e., the parameter value for Our goal is approximating linear parametric optimization problems, that is, for every λ ∈ I , finding a solution x λ ∈ X that is approximately optimal for λ. We want the total number of solutions used for approximating the parametric problem to be finite. When given a finite set S ⊆ X of solutions, we would obviously assign them to the parameter values in a way such that each parameter value λ ∈ I is assigned a solution x λ ∈ S such that This can be done easily using Lemma 1. A simple (yet not necessarily the most efficient) way to do this is to compute the value μ(x, x ) for every pair of solutions , partition I into subintervals defined by these values, and then determine a solution x λ satisfying (2) for an arbitrary parameter value λ in each of these subintervals. Lemma 1 then ensures that x λ also satisfies (2) for all other parameter values inside the corresponding interval. It is, therefore, reasonable to define approximations for parametric optimization problems as follows: Definition 1 For α ≥ 1, an α-approximation for an instance of a parametric optimization problem Π is a finite set S ⊆ X such that, for any λ ∈ I , there exists a solution x ∈ S that is α-approximate for (the non-parametric problem instance obtained by fixing the parameter value to) λ, i.e., for which An algorithm A that computes an α-approximation in polynomial time for every instance of Π is called an α-approximation algorithm for Π .
A polynomial-time approximation scheme (PTAS) for Π is a family (A ε ) ε>0 of algorithms such that, for every ε > 0, algorithm A ε is a (1 + ε)-approximation algorithm for Π . A PTAS (A ε ) ε>0 for Π is called a fully polynomial-time approximation scheme (FPTAS) if the running time of A ε is additionally polynomial in 1/ε.

A general approximation method
We now present our method for approximating a general parametric optimization problem Π as in (1). We assume that there is an algorithm available that can approximate the non-parametric version of Π for any λ ∈ I . More precisely, we assume that, for some β ≥ 1, we have an algorithm alg β that, given any fixed λ ∈ I , computes a β-approximate solution for λ. 2 Our method uses alg β as a blackbox in order to compute an approximation for the parametric problem. The approximation quality achievable by the method is arbitrarily close to β, i.e., for any ε > 0, we can compute a ((1 + ε) · β)-approximation for the parametric problem. If the non-parametric problem can be solved exactly in polynomial time (i.e., if β = 1) or admits a (non-parametric) FPTAS, our method yields a (parametric) FPTAS.
The running time of alg β will be denoted by T alg β , where we assume that this running time is at least as large as the time needed to compute the objective value f x (λ) = a(x) + λ · b(x) of any feasible solution x ∈ X in the non-parametric problem. 3 We first describe the general functioning of the algorithm before formally stating it and proving several auxiliary results needed for proving its correctness and analyzing its running time.
The algorithm maintains a queue Q, whose elements ([λ , λ r ], x , x r ) consist of a subinterval [λ , λ r ] of the interval [λ * , λ * ] and β-approximate solutions x , x r for the respective interval boundaries λ , λ r . The queue is initialized as After the initialization, in each iteration, the algorithm extracts an element ([λ , λ r ], x , x r ) from the queue and first checks if one of the two conditions holds, in which case one of the two solutions x , x r is β-approximate for the whole interval [λ , λ r ]. Otherwise, the algorithm considers the line connecting (λ , f x (λ )) and (λ r , f x r (λ r )). If this line is not more than a factor of (1+ε) (measured in the second coordinate) away from either the line f x or the line f x r , we know that x or x r is ((1+ε)·β)-approximate within the whole interval [λ , λ r ] (see Proposition 2). This condition can be checked easily at λ = μ(x , x r ), where f x and f x r intersect, since this must be the value within [λ , λ r ] where this distance is maximum.
Otherwise, [λ , λ r ] is bisected into the subintervals [λ , λ m ] and [λ m , λ r ], where λ m := μ(x , x r ). This means that a β-approximate solution x m for λ m is computed and the two triples ([λ , λ m ], x , x m ) and ([λ m , λ r ], x m , x r ) are added to the queue in order to be explored. Proposition 3 states that [λ , λ r ] will not be bisected if λ m is too close to either λ or λ r , which ensures a polynomial number of iterations performed by the algorithm in total.
Before proving the auxiliary results mentioned in the algorithm description above, we state two helpful lemmas about general properties of approximations. The first lemma shows that a solution that is α-approximate for two different parameter values must also be α-approximate for all parameter values in between.
Algorithm 1: An approximation algorithm for parametric optimization problems input : An instance of a parametric optimization problem Π as in (1), ε > 0, a β-approximation algorithm alg β for the non-parametric version of Π output: A ((1 + ε) · β)-approximation for the given instance of Π Then λ = γ λ + (1 − γ )λ for some γ ∈ [0, 1] and we can compute: Here, the first inequality follows by the assumption, and the second inequality follows from concavity of the optimal cost curve.
The next lemma covers an important property of μ(·, ·).
Lemma 3 Let α ≥ 1, let ∅ = [λ,λ] ⊆ I be a compact interval and let the solutions x andx be α-approximate for λ andλ, respectively. Assume that b(x) = b(x). Then the following statements are equivalent: The next result justifies our choice of the initial parameter interval [λ * , λ * ] in Algorithm 1.
Reordering terms and using the assumption that 0 Since λ ∈ [λ min , λ * ], the claim follows by Lemma 2. Now, we prove the statement for λ * . Let λ > λ * and let x ∈ X be optimal for λ.
Reordering terms and using that 0 Consequently, using that x * is β-approximate for λ * , we can conclude that

Remark 1
In the case where f x (λ min ) and b(x) only attain values from a discrete set, i.e., for all for all x ∈ X ), we can choose λ * and λ * independently of ε in Proposition 1. Analogous arguments as in the proof above show that the lemma then holds true for the following values: This choice leads to a slightly better running time for Algorithm 1 as we will see in Remark 2.
The following proposition ensures that the set of solutions returned by Algorithm 1 is in fact an approximation of the desired quality. For two solutions x,x that are βapproximate for the two boundaries λ,λ, the proposition compares the value of the unique affine-linear function that intersects f x at λ and fx atλ (this function does not necessarily correspond to a feasible solution x ∈ X ) to the value of those two functions at their intersection point μ(x,x) (see Fig. 1).
The proposition states that, if those two values differ by no more than a factor of α, the solutions x andx (together) are (α · β)-approximate for the whole interval [λ,λ]. The reason for this is that, since the optimal cost curve is concave and x,x are βapproximate for λ andλ, respectively, the connecting function is a lower bound for Proposition 2 Let α, β ≥ 1, let ∅ = [λ,λ] ⊆ I be a compact interval and let the solutions x andx be β-approximate for λ andλ, respectively. Assume that b( .
Now, use concavity of the optimal cost curve f : Next, we show that the condition of Proposition 2 is always fulfilled if μ(x,x)−λ min differs from either λ−λ min orλ−λ min by not more than a factor of α. This allows us to compute a polynomial bound on the number of iterations performed by Algorithm 1.
Proof We write μ := μ(x,x) for short and definẽ . We now prove the claim for (i). We can writeλ ). This is a simple computation: where the first inequality follows from (i) and the second inequality holds since f x (λ min ) ≥ 0. We now prove the statement for the case that (ii) holds. Similar to above, we can writeλ where the first equality holds since Now, we are ready to calculate where the second inequality follows from (ii) and the last inequality follows from the previous computation.
We are now ready to state the main theorem of this section.
where T LB/UB denotes the time needed for computing the bounds LB and UB, and T alg β denotes the running time of alg β .
Proof We first note that, at any given time during the execution of Algorithm 1, any In order to prove the approximation guarantee, let λ ∈ I be chosen arbitrarily. We show the following statement: At the beginning of each iteration of the while loop starting in line 6, either λ ∈ [λ , λ r ] for some element ([λ , λ r for some element x of S. Since Q = ∅ at termination, the approximation guarantee then follows. At the beginning of the first iteration of the while loop, we have Q = {([λ * , λ * ], x * , x * )} and S = {x * , x * }. So, if λ ∈ I \ [λ * , λ * ], the statement follows immediately from Proposition 1. Let the statement now hold at the beginning of some iteration of the while-loop. We show that the statement holds at the end of this iteration. Let ([λ , λ r ], x , x r ) be the element that is extracted from Q in this iteration and assume that λ ∈ [λ , λ r ] since, otherwise, there is nothing to show. We distinguish four cases: , then x r is added to S, which is then β-approximate for λ ∈ [λ , λ r ] by Lemma 2. Otherwise, we know that , then x and x r are added to S and the statement holds due to Proposition 2. In the remaining case, ([λ , λ m ], x , x m ) and ([λ m , λ r ], x m , x r ) are added to Q, and we (trivially) have We prove now the bound on the running time. Starting with the initial interval [λ * , λ * ], Algorithm 1 iteratively extracts an element ([λ , λ r ], x , x r ) from the queue Q and checks whether the interval [λ , λ r ] has to be further bisected into two subintervals [λ , λ m ] and [λ m , λ r ] that need to be further explored. During this process, alg β is called once exactly each time an interval is bisected, computing an optimal solution x m for the newly created interval boundary λ m . This procedure ensures that at any given time during the execution of Algorithm 1, there does not exist a value λ ∈ I for which alg β has been called so far and that lies in the interior of an interval that belongs to one of the current elements of Q.
First, consider the case that I = [λ min , ∞) for some λ min ∈ R. For all i ∈ Z, define the values We show that, for each i ∈ Z for which λ * < λ i+1 and λ i < λ * , there exists at most one value λ in the interval [λ i , λ i+1 ] for which alg β is called during the execution of Algorithm 1. Note that these intervals (together) cover the initial interval [λ * , λ * ], outside of which alg β is never called in Algorithm 1. Consider one of these intervals and, for the sake of a contradiction, assume that λ, λ ∈ [λ i , λ i+1 ] are two values for which alg β is called during the execution of Algorithm 1. We assume without loss of generality that alg β is not called for any value in between λ and λ during the execution of Algorithm 1 and that alg β is called for λ before alg β is called for λ .
Consider the iteration of the while loop during which alg β is called for λ , i.e., where λ = λ m = μ(x l , x r ). The value λ cannot lie in the interior of [λ , λ r ] due to our previous observation. Also, λ cannot lie outside of [λ , λ r ] as this would contradict our assumption that alg β is not called for any value in between λ and λ during the execution of Algorithm 1 since alg β must have been called for λ and λ r earlier.
Thus, we must have λ = λ or λ r = λ. But now, since λ − λ min and λ − λ min differ by a factor of at most 1 + ε, Proposition 3 implies that either f and, thus, alg β is not called for λ . It remains to count the number of values λ i for i ∈ Z that satisfy (5) and (6), which are satisfied exactly for all i ∈ Z with So, this number is in O( 1 ε · log 1 ε + 1 ε · log UB LB + 1 ε · log β). Adding the time T LB/UB needed for computing the bounds LB, UB at the beginning of the algorithm, this proves the bound on the running time.
Moreover, we obtain the following corollary: Corollary 1 If either an exact algorithm alg = alg 1 or a (non-parametric) FPTAS is available for the non-parametric version, then Algorithm 1 yields an FPTAS. If a (non-parametric) PTAS is available for the non-parametric version, then Algorithm 1 yields a PTAS.

Remark 2
In the case of discrete problems as in Remark 1, the choice of the initial interval [λ * , λ * ] proposed in Remark 1 leads to a running time of

Small cardinality
In this section, we address the issue of computing approximations for parametric optimization problems that are as small as possible in terms of cardinality. To this end, we provide an algorithm that, given an α-approximation R and an exact algorithm alg = alg 1 for the non-parametric problem, returns an α-approximation S that has minimum cardinality among the ones contained in R. If it is known that R consists of solutions that are supported in R, we show how this information can be used in order to reduce the running time of this algorithm significantly. Moreover, if S * ⊆ X is an α-approximation of minimum cardinality for a given instance of a parametric optimization problem, we show that this algorithm can be used along with Algorithm 1 of the previous section in order to compute an αapproximation S of cardinality |S| ≤ 2 · |S * |.
Throughout this section, we assume that alg can not only find an optimal solution for any λ ∈ I but can also compute a lexicographically optimal solution for the (non-parametric) optimization problem where we assume that this optimum exists. For α ≥ 1, we say that a solution x ∈ X is α-approximate for (7) if, for an optimal solution x * of (7), we have b(x) ≤ α · b(x * ) and a(x) ≤ α · a(x * ). Solving (7) corresponds to minimizing a+λ·b for "λ → ∞" in the following sense: A solution x ∈ X is optimal for (7) if and only if, for any x ∈ X , there exists some λ * ∈ I such that f x (λ) ≤ f x (λ) for all λ ≥ λ * . This also applies to approximation: A solution x ∈ X is α-approximate for (7) if and only if, for any x ∈ X , there exists some λ * ∈ I such that f For convenience, we define the following notation: We write f x (∞) := (b(x), a(x)) for all x ∈ X and f (∞) := f x * (∞) for an optimal solution x * ∈ X to (7). When writing f x (∞) ≤ f x (∞) for two solutions x, x ∈ X , we refer to the lexicographical order relation. We also write "alg(∞)" when indicating that alg is called for solving (7).
The additional assumption that alg is able to solve (7) is a reasonable one since, for most applications of linear parametric optimization, the functions a and b admit values in a discrete set such that the values of any two different solutions x, x ∈ X are either equal or differ by at least LB. In this case, (7) is equivalent to the non-parametric problem for λ > UB LB . Thus, solving (7) is typically not more difficult than minimizing the objective function a + λ · b for any other λ ∈ I .
We stress the fact that this assumption is necessary as the following theorem states.

Theorem 2 For a given α > 1, no deterministic algorithm can compute a minimum cardinality subset R * of an α-approximation R that maintains α as the approximation guarantee for the general linear parametric problem (1) when given as the input only:
-the α-approximation R -the interval I = [λ min , ∞) -a routine alg that computes an optimal solution for any λ ∈ I but not for (7) Proof For the sake of a contradiction, assume that there exists such a deterministic algorithm A that, for any instance of a linear parametric optimization problem, terminates after finitely many calls to alg. Consider the following instance: When A is used to compute a minimum cardinality α-approximation that is a subset of the α-approximation R = {x 1 , x 2 } it returns {x 1 } after finitely many calls to alg.
Since, for any λ ∈ I , x 3 is the only optimal solution, all of these calls to alg return x 3 . We denote byλ the maximum value for which alg is called by A in this scenario. We assume, without loss of generality, thatλ > 0. Otherwise setλ = 1. Now consider the instance with I = [0, ∞) and (see also Fig. 2) and again, use A to compute a minimum cardinality subset of R = {x 1 , x 2 }. Note that R is, in fact, an α-approximation in this instance since, for all λ ∈ I , Also, note that the input for A is exactly the same in this scenario as in the previous one. Moreover, for all 0 < λ ≤λ, we have and we also have f x 3 (0) = 1 < 1 + α = f x 4 (0), so alg returns x 3 , i.e., the same solution as in the other instance, for all λ ≤λ. Thus, since A is a deterministic algorithm, it behaves in exactly the same way in both of these scenarios. It returns {x 1 } after doing the same calls to alg as before.
Algorithm 2 describes the following greedy procedure that, given a β-approximation R ⊆ X , extracts a minimum cardinality β-approximation S ⊆ R from R: We start by choosing the solution among R that covers the largest set of parameter values containing λ min in terms of β-approximation, i.e., that is β-approximate for the maximum value λ ∈ I while still being β-approximate for λ min . After that, we always choose the solution that, together with all the previously chosen solutions, covers the largest connected portion of I (starting at λ min ) in terms of β-approximation.
The algorithm takes advantage of the following property of μ: If two solutions x, x ∈ X are β-approximate at μ(x, x ), then the one of them having the smaller slope covers a larger portion of [μ(x, x ), ∞). If x, x are not β-approximate at μ(x, x ), then the one of them having the larger slope covers a larger portion of [λ min , μ(x, x )) (if one of them covers any value in this interval at all). This property suffices to be able to compare two solutions x, x ∈ R with respect to the above criterion in all necessary cases using a single alg-call.
The following theorem formally states the correctness and running time of Algorithm 2.
Algorithm 2: Algorithm minimizing the cardinality of an α-approximation input : An α-approximation R = {x 1 , . . . , x k }, an exact algorithm alg for the non-parametric version of Π output: A smallest-cardinality subset of R that is an α-approximation /* solution set */ 5 i = 1; /* index of currently found best next solution */ 6 j ← 2; /* index of current solution */ 7 π ← 0; /* index of previously chosen solution */ 8 while f x j (λ min ) ≤ α · f x min (λ min ) and j ≤ k do Theorem 3 Algorithm 2 computes a minimum cardinality subset of R that is an αapproximation using O(k 2 ) calls to alg.

Proof
In this proof, we use the following notation: For ι = 1, . . . , k, we defineλ x ι to be the maximum parameter value for which the solution x ι ∈ R (after the sorting and the deleting step) is α-approximate, i.e., We use the convention thatλ x ι = −∞ if the set in this definition is empty or if ι = 0, and thatλ x ι = ∞ if the set in this definition is unbounded. Ifλ x ι ∈ I for some x ι ∈ X , then f x ι (λ) = α · f (λ) since f and f x ι are continuous. Moreover, for any two solutions Thus, by Lemma 1, In this case, we haveλ x j <λ x i since, by Lemma 1, We now prove that Algorithm 2 terminates after performing O(k 2 ) calls to alg. Apart from the initialization, alg is only called when evaluating the optimal cost curve f at μ(x i , x j ) or μ(x π , x j ) in lines 9 and 16. In the while loop starting in line 8, at most k iterations are performed.
The stopping condition of the while loop starting in line 13 is also fulfilled after at most k iterations: We know that R is an α-approximation, so, for any x j )). Note that in the beginning of each iteration of the while loop, π is set to be equal to i, so the condition in line 16 simplifies x j )). Thus, the value of i is strictly increased in each iteration. When i = k (at the latest), the algorithm terminates since R is an α-approximation, so we must have f In each iteration of the second while loop, 2 · (k − π) ∈ O(k) many calls to alg are performed.
We now show that the set S returned by Algorithm 2 is indeed an α-approximation. To this end, we show by induction that at any time during the execution of the algorithm, (i) S is an α-approximation for all λ ∈ [λ min ,λ x π ] and (ii) the set S ∪ {x i } is an α-approximation for all [λ min ,λ x i ] Statements (i) and (ii) obviously hold after the initialization, when S = ∅, i = 1 and π = 0. Afterwards, whenever x i is added to S, π is set to be equal to i, so it suffices to show (ii), since this immediately implies (i) at any given time during the execution of the algorithm. We assume now that statements (i) and (ii) hold immediately before the value of i is changed during the execution of the algorithm and show that (ii) holds after this step.
When i is assigned a new value in line 10, we know that (for this new value) by line 8, which, in particular, impliesλ x i ≥ λ min . Since also by (8), statement (ii) follows from Lemma 2. When i is assigned a new value in line 17 and if statement (i) holds at this moment, it suffices to show that x i is α-approximate for all λ ∈ [λ x π ,λ x i ]. We know that When the algorithm terminates, we know that f x i (∞) ≤ α · f x ∞ (∞), so we havē λ x i = ∞. Since x i must have been added to S immediately before, this concludes the proof that the returned set S is an α-approximation.
Finally, we show that S has minimum cardinality among all α-approximations S ⊆ R. Note that we only have to consider the remaining set after the sorting and deleting in the beginning of the algorithm, i.e., it suffices to show that S has minimum cardinality among all α-approximations S ⊆ {x 1 , . . . , x k }, since if, for two solutions x, x ∈ R, we have f x (λ min ) ≤ f x (λ min ) and f x (∞) ≤ f x (∞), x can be replaced by x in any α-approximation. Thus, in the following, we assume that R = {x 1 , . . . , x k }. We know that S = {x j 1 , . . . , x j } for some j 1 < · · · < j and l = |S|, and we denote the cardinality of a smallest α-approximation S * ⊆ R by m := |S * |.
It is easy to see that, for the ordering of x 1 , . . . , x k , it holds that b(x 1 ) > · · · > b(x k ). Moreover, we note that the fact that the value of i is never decreased during the execution of the algorithm implies that x j 1 , . . . , x j are added to S in exactly this order.
In order to show the statement for ι = 1, let S * 0 = {x j * 1 , . . . , x j * m } ⊆ R with j * 1 < · · · < j * m be an α-approximation. We show that x j 1 is α-approximate for any λ ∈ [λ min , μ(x j * 1 , x j * 2 )] and we can therefore replace x j * 1 by x j 1 in S * 0 : Note that whenever the condition in line 9 is checked during the execution of the algorithm, we know that i < j, i.e., b(x i ) > b(x j ). Moreover, both x i and x j are α-approximate for λ min , which implies that the condition that f x j (μ(x i , x j )) ≤ α · f (μ(x i , x j )), which is checked in line 9, is equivalent to the condition thatλ x j ≥λ x i . Thus, after the while loop starting in line 8, x i satisfiesλ x i ≥λ x j for all x j ∈ R with f x j (λ min ) ≤ α· f (λ min ), so, in particular, we haveλ where the equality holds since x i = x j 1 is the first solution added to S and the last inequality holds since x j * 1 is α-approximate for μ(x j * 1 , x j * 2 ) in S * 0 . Next, we do the induction step ι → ι + 1 for ι = 1, . . . , − 1. To this end, let the set S * ι = {x j * 1 , . . . , x j * m } ⊆ R with j * 1 < · · · < j * m be an α-approximation of cardinality m that contains {x j 1 , . . . , x j ι }. Note that we must have x j * 1 = x j 1 , . . . , x j * ι = x j ι since S is an α-approximation and S * ι has minimum cardinality. Consider the iteration of the while loop starting in line 13 in which x j ι+1 is added to S. In this iteration, we have π = j ι = j * ι . Note that the condition checked in line 16 is equivalent to so, at the end of the inner loop starting in line 15, x i satisfiesλ x i ≥λ x j for all j ≥ π with f x j (μ(x π , x j )) ≤ α · f (μ(x π , x j )). Moreover, x i is added to S at the end of this iteration, so we have i = j ι+1 . Thus, we can concludeλ x j ι+1 =λ x i ≥λ x j * ι+1 . Again, we argue that we can replace x j * ι+1 by x j ι+1 in S * ι : If ι = 1, since S is an α-approximation, Similarly, if ι ∈ {2, . . . , − 1}, x j ι is α-approximate for any Moreover, x j ι+1 is α-approximate for any ].
This concludes the proof that |S| = m.
Remark 3 For β > α ≥ 1, any α-approximation is also a β-approximation. Thus, letting Algorithm 2 interpret a given α-approximation S α as a β-approximation yields a β-approximation S β ⊆ S α that has minimum cardinality among all subsets of S α that are a β-approximation.
In Algorithm 2, if we know that all solutions x 1 , . . . , x k ∈ R are supported, we can reduce the running time by modifying the second while loop using the following property: Lemma 4 Let α ≥ 1, let R ⊆ X be an α-approximation, and let x, x , x ∈ X be solutions that are supported in R such that . Therefore, by Lemma 2, it suffices to show that λ x ≤ μ(x, x ) ≤ μ(x, x ). The first inequality follows immediately from Lemma 1. In order to prove the second inequality, assume, for the sake of a contradiction, that μ(x, x ) > μ(x, x ). Then, by Lemma 1, and, therefore, for all λ ≤ μ(x, x ), and, for λ ≥ μ(x, x ), which contradicts the fact that x is supported in R.
Due to this property, we know that, during the execution of Algorithm 2, whenever f x j (μ(x π , x j )) > α · f (μ(x π , x j )) for some j in line 16, this also holds for j + 1, . . . , k. Therefore, we do not have to check the first condition of line 16 for all j > π in each iteration of the while loop starting in line 13. The second condition can be removed completely in the case that all solutions in R are supported in R, since in this case, for j = 1, . . . , k − 1, we have that x j is α-approximate for (μ(x j , x j + 1)).
In Algorithm 2, if all solutions x ∈ R are supported in R, we can, thus, replace lines 15 through 17 by the following without changing the output of the algorithm: Moreover, for the same reason that the second condition of line 16 in the original version of Algorithm 2 is always fulfilled, the condition in line 9 is also always fulfilled and can therefore be removed. We obtain the following result: Theorem 4 If R is an α-approximation consisting of solutions that are supported in R, the modified version of Algorithm 2 computes a minimum cardinality subset of R that is an α-approximation using O(k) calls to alg.
Proof As argued above, the output of Algorithm 2 is not changed by the modifications if R consists of solutions that are supported in R.
Moreover, since, in the modified algorithm, f is evaluated only for values μ(x π , x j ), where, after each evaluation, either π or j is strictly increased, the number of evaluations is in O(k).
Given an instance of a parametric optimization problem and α, one might be interested in computing α-approximations containing the minimum number of solutions needed for an α-approximation. When having access to an algorithm alg solving the non-parametric problem exactly, we are able to compute approximations consisting of solutions that are supported not only in the approximation itself but in X . The following results state that any α-approximation consisting of supported solutions contains an αapproximation whose cardinality is at most twice as large as the minimum cardinality of any α-approximation for the given instance.
Proof Since S consists of supported solutions, we know that, for each x i ∈ S, there exists a value λ i ∈ I such that f x i (λ i ) = f (λ i ). For these values, Lemma 1 implies that First, consider the case that b(x * ) > b(x 1 ). By Lemma 1, we know that f x * (λ) < f x 1 (λ) for all λ < μ(x * , x 1 ), so we must have λ 1 ≥ μ(x * , x 1 ).
We know that x 1 is α-approximate for all λ ∈ I with λ ≤ μ(x 1 , x 2 ), so, in particular, by Lemma 1, so, since x * is α-approximate for λ, also x 1 is αapproximate for λ. Similarly, we can show that, in the case that b(x * ) < b(x k ), x k is α-approximate for all λ ∈ [λ,λ].
Otherwise, we can choose i maximal such that b( Then Note that Lemma 5 also holds for intervals [λ, ∞) ⊆ I . Thus, we have the following corollary: Corollary 2 Let S ⊆ X be an α-approximation consisting of supported solutions and let S * ⊆ X be an α-approximation having minimum cardinality among all αapproximations for the given instance. Then there exists an α-approximation S ⊆ S with |S | ≤ 2 · |S * |.
Proof By Lemma 5, for each solution x * ∈ S * , there exist two or fewer solutions in S such that, for all λ ∈ I for which x * is α-approximate, at least one of the two is α-approximate. Thus, for an α-approximation, at most 2 · |S * | solutions from S are necessary.

Remark 4
In Algorithm 1, when using a stack instead of a queue in order to handle the remaining intervals, the solutions x of the returned set are computed in decreasing order of b(x). This means that, when applying Algorithm 1 and Algorithm 2 consecutively, the sorting step of Algorithm 2 can be skipped if this ordering is preserved.
The following example shows that there exist instances of linear parametric optimization problems where the unique minimum cardinality α-approximation does not contain any supported solutions. This means that no algorithm that can only access the instance via an alg routine is able to compute a minimum cardinality α-approximation and the factor of two achieved by Corollary 3 is, in this sense, best possible. Moreover, the example can be used to demonstrate that, in the modified version of Algorithm 2, the condition that the input set R consists of solutions that are supported in R is, in fact, necessary.

Applications
In this section, we show that our general results apply to the parametric versions of many well-known, classical optimization problems including the parametric shortest path problem, the parametric assignment problem, a general class of parametric mixed integer linear programs that includes the parametric minimum cost flow problem, and the parametric metric traveling salesman problem. As will be discussed below, for each of these parametric problems, either the number of breakpoints in the optimal value function can be super-polynomial, which implies that solving the parametric problem exactly requires the generation of a super-polynomial number of solutions, or the corresponding non-parametric version is already NP-hard.

Parametric shortest path problem
In the single-pair version of the parametric shortest path problem, we are given a directed graph G = (V , R), where |V | = n and |R| = m, together with a source node s ∈ V and a destination node t ∈ V , where s = t. Each arc r ∈ R has a parametric length of the form a r + λ · b r , where a r , b r ∈ N 0 are non-negative integers. The goal is to compute an s-t-path P λ of minimum total length r ∈P λ (a r + λ · b r ) for each λ ≥ 0.
Since the arc lengths a r + λ · b r are non-negative for each λ ≥ 0, one can restrict to simple s-t-paths as feasible solutions, and an upper bound UB as required in Algorithm 1 is given by summing up the n − 1 largest values a r and summing up the n − 1 largest values b r and taking the maximum of these two sums, which can easily be computed in polynomial time. The non-parametric problem can be solved in polynomial time O(m+n log n) for any fixed λ ≥ 0 by Dijkstra's algorithm, where n = |V | and m = |R| (see, e.g., Schrijver 2003). Hence, Corollary 1 and Remark 2 yield an FPTAS with running time O 1 ε · (m + n log n) · log nC , where C denotes the maximum among all values a r , b r . Moreover, by Corollary 3, we obtain an approximation of cardinality at most twice the minimum possible.
On the other hand, the number of breakpoints in the optimal value function is at least n Ω(log n) in the worst case even under our assumptions of non-negative, integer values a r , b r and for λ ∈ R ≥0 (Carstensen 1983b;Nikolova et al. 2006).

Parametric assignment problem
In the parametric assignment problem, we are given a bipartite, undirected graph G = (U , V , E) with |U | = |V | = n and |E| = m. Each edge e ∈ E has a parametric weight of the form a e + λ · b e , where a e , b e ∈ N 0 are non-negative integers. The goal is to compute an assignment A λ of minimum total weight e∈A λ (a e + λ · b e ) for each λ ≥ 0.
Similar to the parametric shortest path problem, an upper bound UB as required in Algorithm 1 is given by summing up the n largest values a r and summing up the n largest values b r and taking the maximum of these two sums. The non-parametric problem can be solved in polynomial time O(n 3 ) for any fixed value λ ≥ 0 (see, e.g., Schrijver 2003). Hence, Corollary 1 and Remark 2 yield an FPTAS with running time O 1 ε · n 3 · log nC , where C denotes the maximum among all values a e , b e . Moreover, Corollary 3 yields an additional bound on the cardinality of the computed approximation.
On the other hand, applying the well-known transformation from the shortest s-tpath problem to the assignment problem (see, e.g., Lawler 2001) to the instances of the shortest s-t-path problem with super-polynomially many breakpoints presented in Carstensen (1983b), Nikolova et al. (2006) shows that the number of breakpoints in the parametric assignment problem can be super-polynomial as well (see also Gassner and Klinz 2010).

Parametric MIPs over integral polytopes
A very general class of problems our results can be applied to are parametric mixed integer linear programs (parametric MIPs) with non-negative, integer objective function coefficients whose feasible set is of the form P ∩ (Z p × R n− p ), where P ⊆ R n ≥0 is an integral polytope. More formally, consider a parametric MIP of the form where A, B are rational matrices with n rows, d, e are rational vectors of the appropriate length, and a, b ∈ N n 0 are non-negative, rational vectors. We assume that the polyhedron P := {x ∈ R n : Ax = d, Bx ≤ e, x ≥ 0} ⊆ R n is an integral polytope, i.e., it is bounded and each of its (finitely many) extreme points is an integral point.
Since, for each λ ≥ 0, there exists an extreme point of P that is optimal for the non-parametric problem Π λ , one can restrict to the extreme points when solving the problem. Sincex ∈ N n 0 for each extreme pointx of P and since a, b ∈ N n 0 , the values a(x) = a x and b(x) = b x are non-negative integers. In order to solve the non-parametric problem for any fixed value λ ≥ 0, we can simply solve the linear programming relaxation min / max{(a + λb) x : x ∈ P} in polynomial time. This yields an optimal extreme point of P, which is integral by our assumptions. Similarly, an upper bound UB as required in Algorithm 1 can be computed in polynomial time by solving the two linear programs max{a x : x ∈ P} and max{b x : x ∈ P}, and taking the maximum of the two resulting (integral) optimal objective values.
While Corollary 1 yields an FPTAS for any parametric MIP as above, it is well known that the number of breakpoints in the optimal value function can be exponential in the number n of variables (Carstensen 1983a;Murty 1980). An important parametric optimization problem that can be viewed as a special case of a parametric MIP as above is the parametric minimum cost flow problem, in which we are given a directed graph G = (V , R) together with a source node s ∈ V and a destination node t ∈ V , where s = t, and an integral desired flow value F ∈ N 0 . Each arc r ∈ R has an integral capacity u r ∈ N 0 and a parametric cost of the form a r +λ·b r , where a r , b r ∈ N 0 are non-negative integers. The goal is to compute a feasible s-tflow x with flow value F of minimum total cost r ∈R (a r + λ · b r ) · x r for each λ ≥ 0. Here, a large variety of (strongly) polynomial algorithms exist for the non-parametric problem, see, e.g., Ahuja et al. (1993). An upper bound UB can either be obtained by solving two linear programs as above, or by taking the maximum of r ∈R a r · u r and r ∈R b r · u r . Using the latter and applying the enhanced capacity scaling algorithm to solve the non-parametric problem, which runs in O((m · log n)(m + n · log n)) time on a graph with n nodes and m arcs (Ahuja et al. 1993), Corollary 1 and Remark 2 yield an FPTAS with running time O 1 ε · (m · log n)(m + n · log n) · log mCU , where C denotes the maximum among all values a r , b r , and U := max r ∈R u r . Corollary 3, again, lets us bound the cardinality of the approximation.
On the other hand, the optimal value function can have Ω(2 n ) breakpoints even under our assumptions of non-negative, integer values a r , b r and for λ ∈ R ≥0 (Ruhe 1988).

Parametric metric traveling salesman problem
In the parametric version of the (symmetric) metric traveling salesman problem (TSP), we are given a complete undirected graph G = (V , E), where |V | = n. Each edge e ∈ E = V × V has a parametric length of the form a e + λ · b e , where a e , b e ∈ N 0 are non-negative integers that satisfy the triangle inequality: For any three vertices u, v, w ∈ V , we have a(u, w) ≤ a (u, v)+ a(v, w) and b(u, w) ≤ b(u, v)+ b(v, w). The goal is to compute a Hamiltonian cycle H λ of minimum total length e∈H λ (a e + λ · b e ) for each λ ≥ 0. Similar to, e.g., the shortest path problem, an upper bound UB can be obtained by taking the maximum of the sum of the n largest values a e and the sum of the n largest values b e . The non-parametric metric TSP can be 3 2 -approximated in O(n 3 ) time using Christofides' algorithm (Christofides 1976). Hence, Remark 2 yields a ( 3 2 + ε)approximation algorithm whose running time is in O 1 ε · n 3 · (log nC) , where C denotes the maximum among all values a e , b e .
On the other hand, it is well-known that even the non-parametric metric TSP is APX-complete (see, e.g., Papadimitriou and Yannakakis 1993).
Funding Open Access funding enabled and organized by Projekt DEAL.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.