# A General Approach to Approximate Multistage Subgraph Problems

In a Subgraph Problem we are given some graph and want to find a feasible subgraph that optimizes some measure. We consider Multistage Subgraph Problems (MSPs), where we are given a sequence of graph instances (stages) and are asked to find a sequence of subgraphs, one for each stage, such that each is optimal for its respective stage and the subgraphs for subsequent stages are as similar as possible. We present a framework that provides a (1/√(2χ))-approximation algorithm for the 2-stage restriction of an MSP if the similarity of subsequent solutions is measured as the intersection cardinality and said MSP is preficient, i.e., we can efficiently find a single-stage solution that prefers some given subset. The approximation factor is dependent on the instance's intertwinement χ, a similarity measure for multistage graphs. We also show that for any MSP, independent of similarity measure and preficiency, given an exact or approximation algorithm for a constant number of stages, we can approximate the MSP for an unrestricted number of stages. Finally, we combine and apply these results and show that the above restrictions describe a very rich class of MSPs and that proving membership for this class is mostly straightforward. As examples, we explicitly state these proofs for natural multistage versions of Perfect Matching, Shortest s-t-Path, Minimum s-t-Cut and further classical problems on bipartite or planar graphs, namely Maximum Cut, Vertex Cover, Independent Set, and Biclique.

## Authors

• 15 publications
• 2 publications
• 8 publications
• ### Approximation algorithms for hitting subgraphs

Let H be a fixed undirected graph on k vertices. The H-hitting set probl...
11/29/2020 ∙ by Noah Brüstle, et al. ∙ 0

• ### Towards a Unified Theory of Sparsification for Matching Problems

In this paper, we present a construction of a `matching sparsifier', tha...
11/05/2018 ∙ by Sepehr Assadi, et al. ∙ 0

• ### Covering with Clubs: Complexity and Approximability

Finding cohesive subgraphs in a network is a well-known problem in graph...
06/04/2018 ∙ by Riccardo Dondi, et al. ∙ 0

• ### The Matching Augmentation Problem: A 7/4-Approximation Algorithm

We present a 7/4 approximation algorithm for the matching augmentation p...
10/17/2018 ∙ by Joe Cheriyan, et al. ∙ 0

• ### Recognizing Generating Subgraphs in Graphs without Cycles of Lengths 6 and 7

Let B be an induced complete bipartite subgraph of G on vertex sets of b...
08/30/2018 ∙ by David Tankus, et al. ∙ 0

• ### LP-based algorithms for multistage minimization problems

We consider a multistage framework introduced recently where, given a ti...
09/23/2019 ∙ by Evripidis Bampis, et al. ∙ 0

• ### The Minimum Edge Compact Spanner Network Design Problem

In this paper we introduce and study the Minimum Edge Compact Spanner (M...
12/11/2017 ∙ by Tathagata Mukherjee, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Subgraph Problems are concerned with selecting some feasible set of graph elements (vertices and/or edges) that is optimal with respect to some measure. However, if the graph at hand changes over time (i.e., if we consider a multistage graph), a single solution does not suffice and a sequence of solutions is necessary. A natural concern is to avoid big changes when transitioning from one solution to the next, since each change might induce costs for changing the state of the corresponding entities. Depending on the problem, the transition quality may be measured differently.

Introduced by Gupta et al. [GTW14] and Eisenstat et al. [EMS14], multistage graph problems have shown to be a rich subject of research. A multistage graph is simply a sequence of graphs (the stages) and we ask for an individual solution per stage. In many cases, generalizing a polynomial-time solvable problem to a multistage setting renders it NP-hard (e.g., Multistage Shortest --Path [FNSZ20] or Multistage Perfect Matching [GTW14]). There is some work on identifying parameters that allow for fixed-parameter tractability of NP-hard multistage problems [FNRZ19, FNSZ20, F21, BFK20, HHKNRS19]. Another popular approach to tackle such problems are approximation algorithms [BEK19, BELP18, BEST19, BET19, EMS14].

In most of these works, the objective is to optimize a combined quantity that measures both the objective value  of the individual per-stage solutions and the quality  of the transitions between subsequent solutions. For example, consider the following multistage MaxWeight Perfect Matching problem on a sequence of  graphs , each with edge weights : find a perfect matching  for each  such that  is maximized; here, is the sum of the individual matchings’ weights and  is the sum of transition qualities measured as the cardinality of common edges between subsequent solutions.

In an approximation setting, this combined objective allows to trade suboptimal transitions for suboptimal single-stage solutions. This results in some strong approximation algorithms, e.g., a -approximation for a multistage Vertex Cover problem [BEK19] or a -approximation for a -stage MinWeight Perfect Matching problem on metric graphs [BELP18]. In [BEST19], several upper and lower bounds for competitive ratios of online algorithms are shown for general Multistage Subset Maximization problems; the corresponding algorithms are not considering running times and depend on polynomial oracles for the underlying single-stage problems.

Contrasting this combined objective, the focus in [CTW20] is to break up the interdependency between  and  for several types of Multistage Perfect Matching problems. Here, is required to yield optimal values, i.e., an approximation algorithm must yield optimal solutions for each individual stage. Thus, the approximation factor measures the difficulty in approximating the transition cost. Regarding exact algorithms, this would only be a special case of the combined objective, where transition costs are scaled appropriately. However, approximation guarantees are in general not transferable to this special case as the approximation may require non-optimal solutions in individual stages (see [CTW20] for a detailed example). In [CTW20], several approximation algorithms for multistage perfect matching problems are provided, where the approximation factor is dependent on the maximum size of the intersection between two adjacent stages (we will later define this parameter as intertwinement).

#### Contribution.

In this paper, we provide a framework to obtain approximation algorithms for a wide range of multistage subgraph problems, where, following the concept of [CTW20], we guarantee optimal solutions in each stage (Section 2). As a key ingredient we define preficient (short for preference efficient) problems (Definition 3.2); they allow to efficiently compute an optimal solution to an individual stage that prefers some given graph elements. As it turns out, many polynomial-time solvable graph problem are trivially preficient. Secondly, we introduce the multistage graph parameter intertwinement that provides a measure for the maximum difference between subsequent stages of the multistage input graph. Our framework algorithm can be applied to any preficient multistage subgraph problem where we measure the transition quality as the number of common graph elements between subsequent stages; it yields an approximation ratio only dependent on the input’s intertwinement.

A building block of this algorithm, which does not depend on the transition quality measure and may therefore be of independent interest, is Theorem 3.1: any -approximation (possibly ) to a -stage subgraph problem with fixed can be lifted to an approximation (with only constantly weaker guarantee, depending on ) for the corresponding unrestricted multistage subgraph problem. The main algorithm of the framework is then discussed in Section 3.2.

Finally, in Section 4, we demonstrate that the class of applicable multistage problems is very rich: It is typically straight-forward to construct a preficiency algorithm from classic algorithms. We can thus deduce several new approximation results simply by applying our preficiency framework approximation, without the need of additional deep proofs. As examples, we showcase this for multistage variants of Perfect Matching, Shortest --Path and Minimum --Cut. Furthermore, several NP-hard (single-stage) problems become polynomial-time solvable on restricted graph classes (e.g., planar, bipartite, etc.); on these, we can apply our framework as well, as we showcase for Maximum Cut, Vertex Cover, Independent Set, and Biclique.

## 2 Framework

Let be a graph with vertex set and (directed or undirected) edge set . Vertices and edges of  are referred to as elements . If the context is clear, we may simply use , or . We denote an edge between vertices with ; if is directed, it is directed from  to . An enriched graph is a graph together with additional information at its elements, e.g., weights or labels.

[Subgraph Problem] A Subgraph Problem (SP)

is a combinatorial optimization problem

, where

• denotes a class of enriched graphs that is the (in general infinite) set of possible instances;

• is a function such that, for an instance , the set contains the feasible solutions, which are subsets of ;

• is a function such that, for an instance  and a feasible solution , the measure of  is given by ;

• the goal is either or .

Given some instance , the objective is to find a feasible solution that is optimal in the sense that . The set of optimal solutions is denoted by .

The class of SPs is very rich; in particular, all of the following problems can be expressed as SPs: Shortest --Path, Minimum --Cut, Minimum Weight Perfect Matching, Maximum Independent Set, Minimum Vertex Cover, Maximum Cut, Maximum Planar Subgraphs, Steiner Trees, etc.

For , we define and . A multistage graph (or -stage graph), is a sequence of graphs for some . The graph is the th stage of ; denotes the element set of . Let and ; and . Let denote the union graph of . The element set of is , the set of intersection elements of is . The intertwinement is a measure for the similarity of consecutive stages of . For an index set , denotes the multistage subgraph induced by , i.e., the multistage graph consisting only of the stages with an index in  in their natural order.

[Multistage Subgraph Problem] A Multistage Subgraph Problem (MSP) is a combinatorial optimization problem , where

• is a Subgraph Problem;

• an instance is a multistage graph for some ;

• is a function such that, given an instance and two element sets , measures the transition quality of these sets;

• the goal is either or , independent of .

Given some instance , let denote the set of feasible multistage solutions, containing -tuples of optimal solutions for the individual stages. The objective is to find a feasible multistage solution that is -optimal (often simply optimal) in the sense that where  denotes the global quality of .

If there is an upper bound  on the number of stages , the MSP  may be denoted by . If and are fixed for several MSPs, we refer to them as -MSPs. We stress that a feasible multistage solution must necessarily consist of optimal solutions w.r.t.  in each stage. Most common choices for transition qualities are symmetric difference cost ( with ; see, e.g., [FNSZ20, FNRZ19, F21, BFK20, BET19, BEK19, GTW14]) and intersection profit ( with ; see, e.g., [FNSZ20, BEST19, BELP18, CTW20]).

## 3 Algorithmic techniques for approximation

### 3.1 Reducing the number of stages

It is natural to expect that MSPs are easier to solve if the number of stages is bounded by some constant . We justify this notion by showing that an optimal algorithm  for the -stage restriction of a MSP can be used to generate a feasible solution that is optimal within factor for the unbounded problem. If is an approximation, the same technique can be used to obtain an approximation for the unbounded problem as well.

Algorithm 1. Consider an MSP  that has an -approximation  for ; possibly , i.e., yields optimal solutions. For , let ; is only non-empty for . For each , compute the multistage solution . For each , let  and construct a multistage solution . Depending on the goal  of , the algorithm’s output  is either if  or if .

Let be an MSP and  an -approximation for for some fixed  (possibly ). Then Algorithm 3.1 yields an -approximation for .

###### Proof.

Suppose has a maximization goal (the proof works analogously for minimization). For , let ; is only non-empty for . For a multistage solution and , let denote the quality of on . Since the algorithm’s output is constructed as , it has at least average profit over the candidate solutions, so

 Q(S)≥1/t∑k∈⟦t−1⟧Q(S(k))=1/t∑k∈⟦t−1⟧∑i∈JkQi(S(k))=1/t∑i∈JQi(S(k)).

For , let be the optimal quality in . Since is an -approximation for , we have for all and and thus . Let be an optimal multistage solution. For each , the term is contained in exactly times, namely for each . We thus have and conclude that . ∎

### 3.2 Approximating two stages

Building on results of [CTW20], we present an algorithm that computes an approximately optimal solution for the -stage restriction of any -MSP that possesses a certain property.

An MSP is called preficient (short for preference efficient) if there is an algorithm  that solves the following problem in polynomial time: Given an instance and a set of elements, compute an optimal solution such that . Such an algorithm  is called a preficiency algorithm for .

Since in general a quality function

does not underlie strong restrictions (it might be a constant function, even though this would not convey much information), a preficiency algorithm may be trivial for some MSPs. However, for these MSPs the notion of preficiency is probably not very meaningful and the problems might better be approached from another angle.

The following Algorithm (see Algorithm 1 for pseudocode) approximates with intersection quality, provided that has a preficiency algorithm . Given a 2-stage graph , we run two loops that both generate a -stage solution in each iteration; throughout, we store the currently best overall solution. In the first loop, we consider each single intersection element and use  to find a solution that optimizes ; we then execute  a second time to find a solution that optimizes . In the second loop, with iterations indexed by , we consider a set of elements, initialized with ; keeps track of intersection elements that have not been chosen in previous solutions for the first stage and is updated accordingly at the beginning of each iteration. In iteration , we use to find a solution that optimizes ; then we use  to find a solution that optimizes . If , i.e., if every intersection element has already been in a with , the loop stops and the algorithm outputs the -stage solution that has maximum quality over all candidate solutions that have been generated throughout the algorithm’s execution.

The approximation ratio depends on the intertwinement of ; for this is .

Let be a preficient -MSP. Then, Algorithm 1 is a polynomial time -approximation algorithm for .

###### Proof.

Let be a preficiency algorithm for and let be a 2-stage graph with non-empty . We denote the optimal solution value with opt and the output solution value with apx. Let denote the set of intersection elements that can possibly contribute to . W.l.o.g. we can assume , i.e., is non-empty. Since the first loop eventually considers , the algorithm achieves .

In each iteration  of the second loop, at least one element of  that has not been in any previous first stage solution is contained in a solution for  (otherwise the loop terminates) and hence the second loop terminates in polynomial time. Let  denote the number of iterations of the second loop. For any , let denote the 2-stage solution computed in the th iteration of the second loop. Let  denote an optimal 2-stage solution and its intersection; note that may be non-empty. Let  denote the set of intersection elements that are in but not in  for any previous iteration ; let . Note that in iteration , the algorithm first searches for a solution that maximizes . We define and equivalently to , but w.r.t.  instead of  (cf. Figure 1). Thus, contains those elements of that are selected (into ) for the first time over all iterations. Observe that .

Let . For every the algorithm chooses such that is maximized. Since we may choose , it follows that . Thus, if , we have a -approximation. In case , any solution with profit at least  yields a -approximation (which we trivially achieve as discussed above). We show that we are always in one of these two cases.

Let . Assume that (thus ) and simultaneously for all . Since we distribute  over the disjoint sets , each containing less than edges, we know that (thus ). Recall that in iteration , . Thus, we have that is empty and the number of elements of that contribute to is . Hence, the latter term is a lower bound on  and we deduce:

 ri≥∣∣S∗∩∖⋃j∈[i−1]R∗j∣∣=opt−∑j∈[i−1]r∗j≥opt−∑j∈[i−1]opt/x=% opt⋅(1−(i−1)/x).

The above assumptions give a contradiction:

Note that tightness for Algorithm 1 is not provable in general, since this would require the construction of instances for arbitrary preficient -MSPs; they can be differently hard to approximate.

## 4 Applications

We show preficiency for a variety of -MSPs. Proving preficiency often follows the same pattern for these problems: we modify (or assign) weights for those graph elements that are to be preferred in a way that does not interfere with the feasibility of a solution for the respective single stage Subgraph Problems; we then apply a polynomial algorithm to solve the single stage problem w.r.t. the modified weights. The above Sections 3.1 and 3.2 then allow us to deduce the existence of approximation algorithms.

To justify the need for approximation algorithms, we show (or refer to existing results) that each of the presented multistage problems is NP-hard even when restricted to two stages. Since the proofs are lenghty and not the main focus of this paper, they can be found in the Appendix.

Let be a graph with edge weights . Let denote the weight of an edge set  and let be the minimal difference between edge weights. Given an edge set and some , we define the modified weight function that is identical to  on  and for . The modified weight function is well-behaved if the following properties hold for any two edge sets :

1. if , then ;

2. if and , then ;

3. for all .

This modification can be made analogously for a vertex weight function and .

### 4.1 Multistage Minimum (Weight) Perfect Matching

In a graph with edge weights , an edge set is a perfect matching if each is incident with exactly one edge in . A perfect matching has minimum weight if for each perfect matching we have .

[MMinPM ] Given a multistage graph  with edge weights for each , find a -optimal multistage solution such that for each , is a minimum weight perfect matching w.r.t.  in .

As shown in [CTW20], is NP-hard on multistage graphs even with bipartite union graph.

MMinPM is preficient.

###### Proof.

Let be a graph with edge weights and the set of edges to be preferred. Set . We use an arbitrary polynomial time algorithm for computing a minimum weight perfect matching (e.g. Edmonds [LP86]) in with the modified weight function and denote its output by . Since is well-behaved, is a minimum weight perfect matching in  such that  is maximum. ∎

There is a polynomial time -approximation algorithm for . There is a polynomial time -approximation algorithm for MMinPM.

### 4.2 Multistage Shortest s-t-Path

In a graph with edge weights and two terminal vertices , an edge set is an --path in if it is of the form where , and . An --path is a shortest --path if for each --path we have .

[MSPath ] Given a multistage graph  with edge weights and terminal vertices for each , find a -optimal multistage solution such that for each , is a shortest path from to in .

is shown to be NP-hard in [FNSZ20].

MSPath is preficient.

###### Proof.

Let be a graph with edge weights , the terminal vertices, and the set of edges to be preferred. Set . We use an arbitrary polynomial time algorithm for computing a shortest --path (e.g. Dijkstra [D59]) in  with the modified weight function  and denote its output with . Since is well-behaved, is a shortest --path in  such that  is maximum. ∎

There is a polynomial time -approximation algorithm for . There is a polynomial time -approximation algorithm for MSPath.

### 4.3 Multistage Minimum s-t-Cut

In a graph with edge weights , two vertices , an edge set is an --cut if there is no --path in . An --cut is minimum if for each --cut we have .

[MMinCut ] Given a multistage graph with edge weights and terminal vertices for each , find a -optimal multistage solution  such that for each , is a minimum --cut for in .

[Proof in Appendix A] is NP-hard, even if , , and the edges have uniform weights.

MMinCut is preficient.

###### Proof.

Let be a graph with edge weights , the terminal vertices, and the set of edges to be preferred. Set . We use an arbitrary polynomial time algorithm for computing a minimum --cut (e.g. Ford and Fulkerson [FF56]) in with the modified weight function and denote its output with . Since is well-behaved, is a minimum --cut in  such that  is maximum. ∎

There is a polynomial time -approximation algorithm for . There is a polynomial time -approximation algorithm for MMinCut.

#### Vertex variant.

The problem of finding a minimum --cut for each stage can also be optimized to maintain the same set of vertices that are connected to . For a concise problem definition, we need new terminology: in a graph with edge weights and vertices , a vertex set with , is an --separating partition;  is optimal, if the induced --cut  has minimum weight.

Given a multistage graph with edge weights for each and terminal vertices for each , we may ask for a -optimal multistage solution  such that for each , is an optimal --separating partition for  in . The objective is to maximize the global quality w.r.t. intersection profit.

However, choosing each as the largest (w.r.t. ) optimal --separating partition for  in is a polynomial-time algorithm yielding the optimal solution, since the union of two minimum --separating partitions is again an optimal --separating partition.

A natural variation is to consider the quality function instead of . In this case, the problem can be easily reduced to a single-stage minimum --cut problem as shown in [BEK19]: Add disjoint copies of each stage to an empty graph, and two new vertices  and . Add an edge with infinite weight from  to each  and one from each  to . For each occurrence of a vertex in two adjacent stages, add an edge with small positive weight  between the two vertex copies. A minimum --cut in this graph directly induces a minimum --cut in each stage such that the number of vertices that are in  is minimized and thus is maximized.

### 4.4 Multistage Weakly Bipartite Maximum Cut

In a graph with edge weights , a vertex set induces a maximum cut if for each vertex set we have . The (unfortunately named) class of weakly bipartite graphs is defined in [GP81] and contains in particular also planar and bipartite graphs. While the precise definition is not particularly interesting to us here, we make use of the fact that a maximum cut can be computed in polynomial time on weakly bipartite graphs [GP81].

[MWBMaxCut ] Given a multistage graph  with edge weights for each where each stage is weakly bipartite, find a -optimal multistage solution such that for each , is a maximum cut in .

[Proof in Appendix B] is NP-hard already on multistage graphs where each stage is planar.

MWBMaxCut is preficient.

###### Proof.

Let be a weakly bipartite graph with edge weights and the set of edges to be preferred. Set . We use an arbitrary polynomial time algorithm for computing a maximum cut (e.g. Grötschel and Pulleyblank [GP81]) in  with the modified weight function and denote its output with . Since is well-behaved, is a maximum cut in  such that  is maximum. ∎

There is a polynomial time -approximation algorithm for . There is a polynomial time -approximation algorithm for MWBMaxCut.

### 4.5 Multistage Minimum (Weight) Bipartite Vertex Cover

In a bipartite graph with vertex weights , a vertex set is a vertex cover if each is incident with at least one vertex in . A vertex cover has minimum weight if for each vertex cover we have . MMinBVC aims to maximize the number of common vertices:

[MMinBVC ] Given a multistage graph  with vertex weights for each where each stage is bipartite, find a -optimal multistage solution  such that for each , is a minimum weight vertex cover in .

[Proof in Appendix C] is NP-hard already with uniform weights on multistage graphs where each stage only consists of disjoint cycles.

MMinBVC is preficient.

###### Proof.

Let be a bipartite graph with vertex weights  and the set of vertices to be preferred. Let . Construct the modified graph from by adding two new vertices and edge sets and . We equip with edge weights :

• An edge with has weight ,

• an edge with has weight ,

• an edge with has weight ,

• an edge with has weight ,

• an (original) edge has infinite weight.

Note that is well-behaved w.r.t. . A minimum weight --cut  in  (computable in polynomial time [FF56]) induces a minimum weight vertex cover  in  by picking all vertices that are incident with an edge in : (i) Suppose is not a vertex cover, i.e., there is an edge not incident with an edge in and w.l.o.g.  and . Then is an --path in  and  is no --cut. (ii) Suppose there is a vertex cover such that . Then the edge set is an --cut in  with , contradicting the minimality of  w.r.t. .

Further, maximizes : Suppose there is a minimum weight vertex cover in such that . Let again denote the --cut associated with . By construction and since , we have , again contradicting minimality of w.r.t. . ∎

There is a polynomial time -approximation algorithm for . There is a polynomial time -approximation algorithm for MMinBVC.

### 4.6 Multistage Maximum (Weight) Bipartite Independent Set

In a graph with vertex weights , a vertex set is an independent set if for with we have . An independent set has maximum weight if for each independent set we have .

[MMaxBIS ] Given a multistage graph  with vertex weights for each where each stage is bipartite, find a -optimal multistage solution such that for each , is a maximum weight independent set in .

It is well-known that in a bipartite graph the complement of a minimum weight vertex cover is a maximum weight independent set. Thus, MMaxBIS is NP-hard as well. Given a bipartite graph and a set of vertices , running the preficiency algorithm for MMinBVC with input and , we have a preficiency algorithm for MMaxBIS.

There is a polynomial time -approximation algorithm for .

There is a polynomial time -approximation algorithm for MMaxBIS.

### 4.7 Multistage Maximum (Weight) Bipartite Biclique

In a bipartite graph with vertex weights , a vertex set is a biclique if for with and