Regret Versions Research Articles

Efficient algorithms for the minmax regret path center problem with length constraint on trees

When there is no constraint on the length, efficient algorithms are known for the minmax regret path center, path median, and path centdian problems on trees. In a recent review on location problems, these problems with length constraint were considered as open. The focus of this paper is the minmax regret path center problem with length constraint on a tree. Efficient algorithms are presented for both the continuous and discrete models, which require, respectively, O(nlg2n) and O(nlgn) time. Our algorithms are based on an approach introduced by Averbakh and Berman for solving the minmax regret p-center problem. To apply their approach, we give a sufficient condition under which the approach works. This result is of independent interest. According to the condition, polynomial algorithms are obtained immediately for the minmax regret versions of many other center location problems, for which no algorithms were known before.

The interval min–max regret knapsack packing-delivery problem

ABSTRACT This paper studies an interval data min–max regret (IDMR) version of the packing-delivery problem, in which a 0-1 knapsack problem is for parcel packing and a capacitated travelling salesman problem is for parcel delivery. The parcel profits for the courier and the tour costs are uncertain and they can take any value from a specific interval with lower and upper bound values. The problem is how to select and deliver a subset of parcels to minimise the maximum regret of net profit which is the difference between the total profits of the selected parcels and the total delivery costs, to deal with the trade-off of the solution robustness and performance. To tackle the problem effectively, we first prove the worst-case scenario of a solution to the problem, based on which, a mixed integer linear programming is formulated. A Benders-like decomposition algorithm is then developed to solve small-scale problems to optimality within the manageable computation time. For medium- and large-scale problems, a simulated-annealing-based heuristic method with a local search procedure is designed. Extensive computational experiments show the efficiency and effectiveness of the proposed methods.

Approximation algorithms for the min-max regret identical parallel machine scheduling problem with outsourcing and uncertain processing time

We consider the robust (min-max regret) version of identical parallel machine scheduling problem, in which jobs may be outsourced to balance total cost against production efficiency. The total cost is measured in terms of the total completion time of jobs processed in-house and the cost of outsourcing the rest. Processing times of in-house jobs are uncertain and they are described as two types of scenarios: discrete and interval. The objective is to obtain a robust (min-max regret) decision that minimises the absolute deviation of total cost from the optimal solution under the worst-case scenario. We first prove the worst-case scenario for any feasible solution. For the interval scenario, we further prove that the maximum regret value can be obtained in polynomial time for any feasible schedule. We also prove that for any discrete scenario, the minimum total cost can be obtained in polynomial time. Since the problem with the interval scenario is strongly NP-hard, we then transform the problem into an equivalent robust single machine scheduling problem. Finally, we develop 2-approximation algorithms for the problem with discrete and interval scenarios, respectively. These results are helpful for bridging the scheduling theory and practice in identical parallel machining environments with outsourcing and uncertain processing times.

A Survey on Facility Location Problems in Dynamic Flow Networks

This paper surveys the facility location problems in dynamic flow networks that have been actively studied in recent years. These problems have been motivated by evacuation planning which has become increasingly important in Japan. The evacuation planning problem is formulated using a dynamic flow network consisting of a graph in which a capacity as well as a transit time is associated with each edge. The goal of the problem is to find a way to send evacuees originally existing at vertices to facilities (evacuation centers) as quickly as possible. The problem can be viewed as a generalization of the classical k-center and k-median problems. In this paper we show recent results about the difficulty and approximability of a single facility location for general networks and polynomial time algorithms for k-facility location problems in path and tree networks. We also mention the minimax regret version of these problems.

Minmax Regret k-Sink Location on a Dynamic Path Network with Uniform Capacities

In Dynamic flow networks an edge’s capacity is the amount of flow (items) that can enter it in unit time. All flow must be moved to sinks and congestion occurs if flow has to wait at a vertex for other flow to leave. In the uniform capacity variant all edges have the same capacity. The minmax k-sink location problem is to place k sinks minimizing the maximum time before all items initially on vertices can be evacuated to a sink. The minmax regret version introduces uncertainty into the input; the amount at each source is now only specified to within a range. The problem is to find a universal solution (placement of k sinks) whose regret (difference from optimal for a given input) is minimized over all inputs consistent with the given range restrictions. The previous best algorithms for the minmax regret version of the k-sink location problem on a path with uniform capacities ran in O(n) time for $$k=1$$ , $$O(n \log ^ 4 n)$$ time for $$k=2$$ and $${\varOmega }(n^{k+1})$$ for $$ k >2$$ . A major bottleneck to improving those solutions was that minmax regret seemed an inherently global property. This paper derives new combinatorial insights that allow decomposition into local problems. This permits designing two new algorithms. The first runs in $$O(n^3 \log n)$$ time independent of k and the second in $$O( n k^2 \log ^{k+1} n)$$ time. These improve all previous algorithms for $$k >1$$ and, for $$k > 2$$ , are the first polynomial time algorithms known.

Searching for multiple objects in multiple locations

Many practical search problems concern the search for multiple hidden objects or agents, such as earthquake survivors. In such problems, knowing only the list of possible locations, the Searcher needs to find all the hidden objects by visiting these locations one by one. To study this problem, we formulate new game-theoretic models of discrete search between a Hider and a Searcher. The Hider hides k balls in n boxes, and the Searcher opens the boxes one by one with the aim of finding all the balls. Every time the Searcher opens a box she must pay its search cost, and she either finds one of the balls it contains or learns that it is empty. If the Hider is an adversary, an appropriate payoff function may be the expected total search cost paid to find all the balls, while if the Hider is Nature, a more appropriate payoff function may be the difference between the total amount paid and the amount the Searcher would have to pay if she knew the locations of the balls a priori (the regret). We give a full solution to the regret version of this game, and a partial solution to the search cost version. We also consider variations on these games for which the Hider can hide at most one ball in each box. The search cost version of this game has already been solved in previous work, and we give a partial solution in the regret version.

A minmax regret version of the time-dependent shortest path problem

We consider a shortest path problem where the arc costs depend on their relative position on the given path and there exist uncertain cost parameters. We study a minmax regret version of the problem under different types of uncertainty of the involved parameters. First, we provide a Mixed Integer Linear Programming (MILP) formulation by using strong duality in the uncertainty interval case. Second, we develop three algorithms based on Benders decomposition for general polyhedral sets of uncertainty. In order to make the algorithms faster we use constant factor approximations to initialize them. Finally, we report some computational experiments for different uncertainty sets in order to compare the behavior of the proposed algorithms.

Min–max regret version of a scheduling problem with outsourcing decisions under processing time uncertainty

We consider the min-max regret version of a single-machine scheduling problem to determine which jobs are processed by outsourcing under processing time uncertainty. The performance measure is expressed as the total cost for processing some jobs in-house and outsourcing the rest. Processing time uncertainty is described through two types of scenarios: either an interval scenario or a discrete scenario. The objective is to minimize the maximum deviation from optimality over all scenarios. We show that when the cost for in-house jobs is expressed as the makespan, the problem with an interval scenario is polynomially solvable, while the one with a discrete scenario is NP-hard. Thus, for the discrete scenario case, we develop a 2-approximation algorithm and investigate when the problem is polynomially solvable. Since the problem minimizing the total completion time as a performance measure for in-house jobs is known to be NP-hard for both scenarios, we consider the problem with a special structure for the processing time uncertainty and develop a polynomial-time algorithm for both scenarios.

Min-Max Regret Version of the Linear Time–Cost Tradeoff Problem with Multiple Milestones and Completely Ordered Jobs

We consider a linear time–cost tradeoff problem with multiple milestones and uncertain processing times such that all jobs are completely ordered. The performance measure is expressed as the sum of total weighted number of tardy jobs and total crashing cost. The processing times uncertainty is described through two types of scenarios: discrete and interval scenarios. The objective is to minimize maximum deviation from optimality over all scenarios. For the discrete scenario case, we prove its NP-hardness, develop a pseudo-polynomial time approach, and present a polynomially solvable case. Finally, we show that the interval scenario case is also NP-hard.

Improved algorithms for computing minmax regret sinks on dynamic path and tree networks

Suppose that in an emergency, such as an earthquake or fire, a number of people need to be evacuated to a safe “sink” from every vertex of a network. The k-sink problem seeks to minimize the evacuation time of all the evacuees to k sinks. In the minmax regret version of this problem, the exact number of evacuees at each vertex is unknown, but only an interval for a possible number is given. Under the assumption that all edges have the same capacity, we want to minimize the evacuation time in the worst case, where the actual numbers of evacuees are the most unfavorable to the chosen sink locations. We first present an O(n) time algorithm for finding the minmax regret 1-sink on a dynamic path network, improving the previously known O(nlog⁡n) algorithms. We then present an O(nlog4⁡n) time algorithm for finding the minmax regret 2-sink on a dynamic path network, improving the previously best O(n2log2⁡n) time algorithm. We also present an O(nlog⁡n) time algorithm for finding the minmax regret 1-sink in a dynamic tree network, improving the previously best algorithm that runs in O(n2log2⁡n) time.

Complexity of the robust weighted independent set problems on interval graphs

This paper deals with the max–min and min–max regret versions of the maximum weighted independent set problem on interval graphs with uncertain vertex weights. Both problems have been recently investigated by Talla Nobibon and Leus (Optim Lett 8:227–235, 2014), who showed that they are NP-hard for two scenarios and strongly NP-hard if the number of scenarios is a part of the input. In this paper, new complexity and approximation results for the problems under consideration are provided, which extend the ones previously obtained. Namely, for the discrete scenario uncertainty representation it is proven that if the number of scenarios \(K\) is a part of the input, then the max–min version of the problem is not at all approximable. On the other hand, its min–max regret version is approximable within \(K\) and not approximable within \(O(\log ^{1-\epsilon }K)\) for any \(\epsilon >0\) unless the problems in NP have quasi polynomial algorithms. Furthermore, for the interval uncertainty representation it is shown that the min–max regret version is NP-hard and approximable within 2.

Worst‐case regret algorithms for selected optimization problems with interval uncertainty

PurposeThe purpose of this paper is to consider selected optimization problems with parameter uncertainty. A case is studied when uncertain parameters in functions undergoing the optimization belong to intervals of known bounds as well as the absolute regret based approach for coping with such an uncertainty is applied. The paper presents three different cases depending on properties of optimization problems and proposes which method can be used to solve corresponding problems.Design/methodology/approachThe worst‐case absolute regret method is employed to manage interval uncertainty in functions to be optimized. To solve resulting uncertain optimization problems, optimal, approximate as well as heuristic solution algorithms have been elaborated for particular problems presented and described in the paper. The latter one is based on Scatter Search metaheuristics.FindingsSolution algorithms for worst‐case absolute regret versions of the following optimization problems have been determined: resource allocation in a complex of independent operations and two task scheduling problems Q‖∑Ci and P‖Cmax.Research limitations/implicationsIt is very difficult to generalize the results obtained and to use them for solving other optimization problems which correspond to real‐world applications. Such new cases require separate investigations.Practical implicationsThe considered allocations as well as task scheduling problems have plenty of applications, for example in computer and manufacturing systems. Their versions with not precisely known parameters can be met commonly.Originality/valueThe investigations presented correspond to previous works on so‐called minimax regret problems and extend them for new optimization problems.

A tabu search algorithm for the minmax regret minimum spanning tree problem with interval data

This paper deals with the strongly NP-hard minmax regret version of the minimum spanning tree problem with interval costs. The best known exact algorithms solve the problem in reasonable time for r...

Approximating a two-machine flow shop scheduling under discrete scenario uncertainty

This paper deals with the two machine permutation flow shop problem with uncertain data, whose deterministic counterpart is known to be polynomially solvable. In this paper, it is assumed that job processing times are uncertain and they are specified as a discrete scenario set. For this uncertainty representation, the min–max and min–max regret criteria are adopted. The min–max regret version of the problem is known to be weakly NP-hard even for two processing time scenarios. In this paper, it is shown that the min–max and min–max regret versions of the problem are strongly NP-hard even for two scenarios. Furthermore, the min–max version admits a polynomial time approximation scheme if the number of scenarios is constant and it is approximable with performance ratio of 2 and not (4/3 − ϵ)-approximable for any ϵ > 0 unless P = NP if the number of scenarios is a part of the input. On the other hand, the min–max regret version is not at all approximable even for two scenarios.

On the approximability of robust spanning tree problems

In this paper the minimum spanning tree problem with uncertain edge costs is discussed. In order to model the uncertainty a discrete scenario set is specified and a robust framework is adopted to choose a solution. The min–max, min–max regret and 2-stage min–max versions of the problem are discussed. The complexity and approximability of all these problems are explored. It is proved that the min–max and min–max regret versions with nonnegative edge costs are hard to approximate within O ( log 1 − ϵ n ) for any ϵ > 0 unless the problems in NP have quasi-polynomial time algorithms. Similarly, the 2-stage min–max problem cannot be approximated within O ( log n ) unless the problems in NP have quasi-polynomial time algorithms. In this paper randomized LP-based approximation algorithms with performance bound of O ( log 2 n ) for min–max and 2-stage min–max problems are also proposed.

General approximation schemes for min–max (regret) versions of some (pseudo-)polynomial problems

While the complexity of min–max and min–max regret versions of most classical combinatorial optimization problems has been thoroughly investigated, there are very few studies about their approximation. For a bounded number of scenarios, we establish general approximation schemes which can be used for min–max and min–max regret versions of some polynomial or pseudo-polynomial problems. Applying these schemes to shortest path, minimum spanning tree, minimum weighted perfect matching on planar graphs, and knapsack problems, we obtain fully polynomial-time approximation schemes with better running times than the ones previously presented in the literature.

Min–max and min–max regret versions of combinatorial optimization problems: A survey

Abstract Min–max and min–max regret criteria are commonly used to define robust solutions. After motivating the use of these criteria, we present general results. Then, we survey complexity results for the min–max and min–max regret versions of some combinatorial optimization problems: shortest path, spanning tree, assignment, min cut, min s–t cut, knapsack. Since most of these problems are NP-hard, we also investigate the approximability of these problems. Furthermore, we present algorithms to solve these problems to optimality.

Complexity of the min–max (regret) versions of min cut problems

This paper investigates the complexity of the min–max and min–max regret versions of the min s – t cut and min cut problems. Even if the underlying problems are closely related and both polynomial, the complexities of their min–max and min–max regret versions, for a constant number of scenarios, are quite contrasted since they are respectively strongly NP-hard and polynomial. However, for a non-constant number of scenarios, these versions become strongly NP-hard for both problems. In the interval scenario case, min–max versions are trivially polynomial. Moreover, for min–max regret versions, we obtain the same contrasted results as for a constant number of scenarios: min–max regret min s – t cut is strongly NP-hard whereas min–max regret min cut is polynomial.

A 2-approximation algorithm for interval data minmax regret sequencing problems with the total flow time criterion

In this paper we discuss a minmax regret version of the single-machine scheduling problem with the total flow time criterion. Uncertain processing times are modeled by closed intervals. We show that if the deterministic problem is polynomially solvable, then its minmax regret version is approximable within 2.

Approximation of min–max and min–max regret versions of some combinatorial optimization problems

This paper investigates, for the first time in the literature, the approximation of min–max (regret) versions of classical problems like shortest path, minimum spanning tree, and knapsack. For a constant number of scenarios, we establish fully polynomial-time approximation schemes for the min–max versions of these problems, using relationships between multi-objective and min–max optimization. Using dynamic programming and classical trimming techniques, we construct a fully polynomial-time approximation scheme for min–max regret shortest path. We also establish a fully polynomial-time approximation scheme for min–max regret spanning tree and prove that min–max regret knapsack is not at all approximable. For a non-constant number of scenarios, in which case min–max and min–max regret versions of polynomial-time solvable problems usually become strongly NP-hard, non-approximability results are provided for min–max (regret) versions of shortest path and spanning tree.