The Minimum Shared Edges Problem on Grid-like Graphs
Till Fluschnik, Meike Hatzel, Steffen H\"artlein, Hendrik Molter, and, Henning Seidler

TL;DR
This paper investigates the computational complexity of the Minimum Shared Edges problem on grid-like graphs, providing efficient solutions for certain grid sizes and establishing hardness results and kernelization limits in a parameterized complexity framework.
Contribution
It offers linear-time algorithms for MSE on bounded grids with specific size relations and proves NP-hardness on subgraphs, also analyzing kernelization bounds in parameterized complexity.
Findings
Linear-time solvability on certain bounded grids
NP-hardness on subgraphs of bounded grids
No polynomial kernel for combined parameters under standard assumptions
Abstract
We study the NP-hard Minimum Shared Edges (MSE) problem on graphs: decide whether it is possible to route paths from a start vertex to a target vertex in a given graph while using at most edges more than once. We show that MSE can be decided on bounded (i.e. finite) grids in linear time when both dimensions are either small or large compared to the number of paths. On the contrary, we show that MSE remains NP-hard on subgraphs of bounded grids. Finally, we study MSE from a parametrised complexity point of view. It is known that MSE is fixed-parameter tractable with respect to the number of paths. We show that, under standard complexity-theoretical assumptions, the problem parametrised by the combined parameter , , maximum degree, diameter, and treewidth does not admit a polynomial-size problem kernel, even when restricted to planar graphs.
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsAdvanced Graph Theory Research · Complexity and Algorithms in Graphs · Interconnection Networks and Systems
\mathligsoff
The Minimum Shared Edges Problem on Grid-like Graphs
Till Fluschnik Supported by the DFG, project DAMM (NI 369/13-2). Institut für Softwaretechnik und Theoretische Informatik, TU Berlin, Germany, {till.fluschnik,meike.hatzel,hendrik.molter}@tu-berlin.de
{haertlein,henning.seidler}@campus.tu-berlin.de
Meike Hatzel
Institut für Softwaretechnik und Theoretische Informatik, TU Berlin, Germany, {till.fluschnik,meike.hatzel,hendrik.molter}@tu-berlin.de
{haertlein,henning.seidler}@campus.tu-berlin.de
Steffen Härtlein
Institut für Softwaretechnik und Theoretische Informatik, TU Berlin, Germany, {till.fluschnik,meike.hatzel,hendrik.molter}@tu-berlin.de
{haertlein,henning.seidler}@campus.tu-berlin.de
Hendrik Molter Partially supported by the DFG, project DAPA (NI 369/12). Institut für Softwaretechnik und Theoretische Informatik, TU Berlin, Germany, {till.fluschnik,meike.hatzel,hendrik.molter}@tu-berlin.de
{haertlein,henning.seidler}@campus.tu-berlin.de
Henning Seidler
Institut für Softwaretechnik und Theoretische Informatik, TU Berlin, Germany, {till.fluschnik,meike.hatzel,hendrik.molter}@tu-berlin.de
{haertlein,henning.seidler}@campus.tu-berlin.de
Abstract
We study the -hard Minimum Shared Edges (MSE) problem on graphs: decide whether it is possible to route paths from a start vertex to a target vertex in a given graph while using at most edges more than once. We show that MSE can be decided on bounded (i.e. finite) grids in linear time when both dimensions are either small or large compared to the number of paths. On the contrary, we show that MSE remains -hard on subgraphs of bounded grids.
Finally, we study MSE from a parametrised complexity point of view. It is known that MSE is fixed-parameter tractable with respect to the number of paths. We show that, under standard complexity-theoretical assumptions, the problem parametrised by the combined parameter , , maximum degree, diameter, and treewidth does not admit a polynomial-size problem kernel, even when restricted to planar graphs.
1 Introduction
Routing in street-like networks is a frequent task. Graphs modelling street networks are often (almost) planar, that is, they can be drawn in the plane with (almost) no edge crossings. As a special case, a graph modelling the street network in Manhattan is similar to a grid graph. We study the following problem, originally introduced by Omran et al. [15], from a computational (parametrised) complexity perspective on planar and grid-like graphs:
Minimum Shared Edges (MSE)
Input:
An undirected graph , two distinct vertices , and two integers .
Question:
Are there paths from to in such that at most edges appear in more than one of the paths?
Note that Omran et al. [15] originally defined the problem on directed graphs (we refer to this as Directed Minimum Shared Edges or DMSE). While Omran et al. motivate MSE by applications in security management, the problem can further appear in the following scenario. A network company wants to upgrade their network since it still uses old copper cables. To improve the throughput, some of these cables shall be replaced by modern optical fibre cables. The network routes information from a source location to a target location and the company wants to achieve a certain minimal throughput. Since digging up the conduits for the cables is much more expensive than the actual cables, we can neglect the cost of the cables and upgrade them to arbitrary bandwidth, because once open, we can lay as many cables as necessary into a conduit. The company wants to find the minimum number of conduits that have to be dug up in order to achieve the desired bandwidth.
Related Work.
Omran et al. [15] showed that DMSE is -complete on directed acyclic graphs. The problems MSE and DMSE were both shown to be -complete even if the input graph is planar [8]. Moreover, MSE is solvable in linear time on unbounded (i.e. infinite) grid graphs [6]. DMSE is -approximable [3], but there is no polynomial-time approximation of factor for any unless [15].
Analysing its parametrised complexity, Fluschnik et al. [7] showed that MSE is fixed-parameter tractable when parametrised by the number of paths but does not admit a polynomial-size problem kernel unless , MSE is -hard when parametrised by , where denotes the treewidth of the input graph, and -hard when parametrised by the number of shared edges. Furthermore, MSE is solvable in polynomial time on graphs of bounded treewidth [2, 18].
Our Contribution.
We give both positive and negative results for MSE on grid-like graphs. On the positive side, we show that if the dimensions of the grid are smaller than the number of paths, then MSE is trivially decidable, and if the dimensions of the grid are at least the number of paths, then we provide an arithmetic criterion to decide MSE in linear-time (Section 3.1). On the negative side, we prove that the situation changes when subgraphs of bounded grids (which we refer to as holey grids) are considered, that is, we prove that MSE on subgraphs of bounded grids is -hard (Section 3.2). Similarly, we prove that DMSE is -hard for acyclic subgraphs of directed bounded grids (Section 3.3). Our -hardness results improve upon the known hardness results [8] as the graphs we consider are more restricted. Moreover, we show that MSE parametrised by , where and denote the maximum degree and diameter, respectively, does not admit a polynomial-size problem kernel, unless , even on planar graphs (Section 4), improving an existing kernelization lower bound [7].
2 Preliminaries
We use basic notation from graph theory and parametrised complexity. We denote by the natural numbers containing zero.
Graph Theory.
Unless stated otherwise, we assume that all graphs are finite, undirected, simple and without self-loops. We refer with and to the vertex set and edge set, respectively, of a graph . An edge set is called a path if we have for some pairwise distinct vertices . In this case we say is a --path of length . The distance between two vertices is defined as the length of a shortest --path (we set if there is no - path in ).
Grids.
For , let be the (bounded) -grid, that is, the undirected graph with the set of vertices and the set of edges .
The coordinates of a vertex are denoted by . We call the vertices of degree less than four the rim of the grid. We refer to the vertex set as the upper rim and analogously we use lower, left and right rim. For a given vertex we define and , , and . We also use and .
Parametrised Complexity.
A pair with and is called a parametrised problem. A parametrised problem admits a problem kernel (or is kernelisable) if there is a polynomial-time algorithm transforming any instance of into an instance such that
(i) , and
(ii) the size of (the kernel) is bounded by a computable function .
If is a polynomial, then the problem is said to admit a polynomial (problem) kernel. A parametrised problem is fixed-parameter tractable (or in FPT) if each instance can be decided in time, where is a computable function. A (decidable) parametrised problem is in FPT if and only if it is kernelisable. A parametrised problem that is -hard is presumably not in FPT.
Further Notation.
Let be an instance of MSE. We say is a solution for if
(i) is a multiset of --paths , and
(ii) .
We say that is a trivial solution if for all . An edge is called shared if it occurs in at least two paths of .
3 On Bounded and Holey Grids
The class of grid graphs appeared frequently in the literature: There is work on grid graphs and related graphs with respect to finding paths [11, 12], routing [4], or structural properties [1, 10]. In this section we study the complexity of MSE on bounded grids and their subgraphs. We show that MSE is solvable in linear time on bounded grids when both dimensions are either small or large compared to the number of paths (Section 3.1) and becomes -hard for subgraphs of bounded grids (Sections 3.2 and 3.3). We remark that MSE is solvable in linear-time on the class of unbounded grids [6].
3.1 Bounded Grids
We fix some instance for the remainder of the section. Since the problem is invariant under symmetry and swapping and , we may assume lies left and below of and . To show optimality of the constructions we regard edge cuts of size less than . Assume has a solution . We know [6] that after contraction of the shared edges, the graph must allow an --flow of value at least . Therefore, every cut smaller than has to be eliminated by a contraction, that is, it must contain a shared edge.
We distinguish the following different cases depending on the dimensions of the grid in relation to the number of paths: -small grid (), -large grid (), and -narrow grids (neither -small nor -large). We leave open whether MSE is solvable in polynomial-time on -narrow grids. However, ongoing work indicates that the question can be answered positively.
On -small grids.
If , then every set of horizontal edges with endpoints having the same coordinates in the grid forms an --cut of size smaller than (analogously for every set of horizontal edges). Hence, intuitively, any set of --paths share an edge for each horizontal or vertical level they cross. Indeed, we prove that every instance on -small grids is a yes instance if and only if it admits the trivial solution.
Lemma 1**.**
If and , then we have a solution if and only if .
Proof.
Each row and each column between and is a cut of size smaller than . Formally, these are rows for and columns for . All these cuts are disjoint, since neither two rows nor two columns nor a row and a column ever intersect with respect to edges. Their number is . So if we have a solution, then has to be at least . Conversely, if , we have a trivial solution by definition. ∎
On -large grids.
Compared to the situation on -small grids, -large grids allow for non-trivial solutions. Nevertheless, we prove that the existence of such non-trivial solutions is expressed by arithmetic conditions which can be checked in linear time. These arithmetic conditions basically relate , , and the positions of and relative to the rim of the grid. If lies sufficiently far away from the corner formed by the left and lower rim, then only every second path in our construction introduces a new shared edge at this part. However, if lies close to the corner (or if is large enough), there is a critical number of paths after which every additional path introduces at least one new shared edge. The same happens at the side of . Thus we obtain the following cases.
Lemma 2**.**
Let and . Then there is a non-trivial solution if and only if either
- •
* and , or*
- •
and , or
- •
* and .*
To simplify the notation for our construction, we introduce the following arrow notation. For we define . Analogously we define and . We also use the concatenation of these expressions such that e.g. .
Proof.
From we construct path fragments (cf. Fig. 1) going upwards:
[TABLE]
Next, we construct path fragments going to the right:
[TABLE]
To obtain the solution we add the path fragments in the following order. This process is illustrated in Fig. 1(a).
- A)
We start with , , , and which have no shared edge. This yields paths, since some of these are identical if lies on the rim. Then for we add and , where new adds a shared edge (the other common edges were already shared before). Afterwards we continue adding and for , where adds a shared edge. Thus every other path fragment adds a shared edge. We stop as soon as we have constructed paths. 2. B)
Continue adding for and for until we reach paths. Here each single fragment adds another shared edge.
For we add the following modifications. If , that is, is the last right-going fragment, extend this fragment downwards such that the endpoints of the form a consecutive line. If the leave a gap, that is, is not part of the construction for some , we take the rightmost up-going fragment and route it leftwards along the first free row, and then continue as . In the end, if necessary, we extend leftwards, like we did with . Thus the endpoints of the up-going fragments form a consecutive line as well. These steps do not introduce further shared edges. See Fig. 1(b) for an illustration.
So in the end we may assume we have constructed fragments and for some with . At we proceed analogously, simply mirrored. Therefore we have down-going fragments and left-going fragments . Then we obtain the solution
[TABLE]
Feasibility. Furthermore the only use the lower rows of the grid whereas the use the upper rows. Since , these do not intersect, that is, we do not get further shared edges. The same holds for the and , since .
Let and denote the number of shared edges used to construct the path fragments at , and at respectively. Thus, we have a solution if .
If , then we only use part A. From the -th path to the -th path, every other path adds a new shared edge, so . Furthermore, , so at we also only use part A. This implies . Hence .
If , we still only use part A at getting . But at we also use part B. Assume that lies in the interior of the grid. Then, when completely executing part A, we use shared edges to construct paths. This leaves shared edges for part B. Each of those allows for another path. So we obtain the condition . If lies on the rim or in the corner, then the argument differs slightly, but the condition is the same. So overall we get the condition .
Finally, if , then we use part B at both and . Thus we have . By adding these equalities we obtain . So the solution is feasible.
Optimality. We only give a lower bound for the number of shared edges at . The bound for follows analogously, which then gives the desired bound for .
During part A) of the construction, each contraction may increase the degree of by at most 2. Hence , which shows .
For we present a number of cuts of size . We use rectangles containing , whose right upper corners move along a diagonal. Formally, these are for . Assume that lies inside one of those rectangles. Then for and are --cuts of size , and these are many. In this case we need which only allows the trivial solution. So we may assume that lies outside all of these rectangles. Thus there are many of these cuts and they separate and . Furthermore they are pairwise disjoint. So we get .
Altogether, our construction is optimal. ∎
3.2 Holey Grids
In the previous section we proved that MSE is solvable in linear time on small and large (compared to the number of paths) bounded grids. In this section we study the complexity of MSE on subgraphs of bounded grids, which we call holey grids and show that the problem is -hard on this graph class. To this end we reduce from the well known Vertex Cover problem which is, given a graph and a natural number , to decide whether there exists with such that . More precisely, we use that Vertex Cover remains -complete on graphs with maximum degree three [9]. Note that our reduction adapts the idea of a reduction used in previous work [8].
Theorem 1**.**
MSE on holey grids is -hard.
Proof.
Given an instance of Vertex Cover with , we compute an equivalent instance of MSE on holey grids in polynomial time. We assume that is a power of two (otherwise we add isolated vertices until it is).
Figure 2(d) illustrates the graph obtained by applying the following transformation to the graph shown in Figure 2(a). The main part of the construction is a structure we refer to as meta-grid. The meta-grid encodes the vertex-edge incidence matrix of the original graph. We assume that the obtained graph to be embedded as shown in Figure 2(d), which serves as a reference when we use the terms “left”, “right”, “up”, and “down”. For construction purposes, we refer to paths with vertices as -chains or chains of length . Whenever a chain is added in the construction, all vertices except the two end-vertices are new.
The main component in the construction is a gadget called rainbow (cf. [8]), see Figure 2(b). Figure 2(b) also shows that this gadget is a subgraph of a bounded grid. We use rainbow gadgets where the number of vertices in each band in the spectrum of the rainbow is larger than the number of allowed shared edges. This allows the rainbow gadget to restrict the number of paths that can be routed through it to at most the number of bands in the spectrum. Note that in any rainbow that is satiated with paths edges are shared. We call the number of shared edges in a rainbow the rainbow-offset.
We define and a few other values we need in order to build the graph in the following:
[TABLE]
Here, is the number of rainbow gadgets we construct. The values , , and are chosen to ensure certain constraints when routing paths and sharing edges while can be understood as a scaling constant used to avoid intersections. Why the values are chosen in this way will become clear later in the proof. Next we set for the number of paths and for the number of shared edges in .
In the following we describe the construction of the meta-grid. First, we create a grid of vertices, without any edges, that has rows and columns. We fix an ordering on the set of vertices and use it to identify each row of the grid with a vertex from . Analogously, we fix an order on the edge set and use it to identify each space between two consecutive columns of the grid with an edge in . From here on we will refer to these spaces as columns.
The first vertex in row is denoted , refer to Figure 2(d), the second one is denoted , and so on. If vertex is incident to edge in , then vertices and are connected by a chain of length . If is not incident to in , then vertices and are connected by a chain of length followed by a rainbow. This completes the construction of the rows.
We embed the structure we just created in a grid such that the first vertices are vertically aligned and have vertical distance of . Now we connect each vertex with and with its respective lower neighbour, that is, vertex , by so-called snake-chains of length at least (the wavy vertical lines in Figure 2(d)). Note that these vertices do not necessarily lie above each other. The snake-chains are constructed as follows (refer to Figure 2(c) for an illustration).
In every row except the lowest one, we start with the left most snake-chain. We first route it four steps down, then steps to the right, one down, left again until we are above its end-vertex which we then join it to by a vertical path. Then every further snake-chain is routed the following way: down by the maximum possible number of steps (at most four) such that no previous snake-chain is intersected, then to the right, then the minimum necessary number of steps down, such that the snake-chain can be extended to the left without intersecting a previous snake-chain until it can be routed downwards until it meets its end-vertex.
Note that the above description implies that we reduce the number of steps that a snake-chains is routed downwards every time the previous column did not contain a rainbow. After a rainbow is encountered we start with four steps down again. Since has a maximum degree of three, there are at most three columns in every row without a rainbow, so after at most four consecutive snake-chains we encounter a rainbow in the next column. This way the snake-chains do not intersect or touch each other and the constant ensures that they also do not intersect any rainbows from the next row.
Now we add a source vertex to the left of the meta-grid and construct a complete, binary tree of height with as its root and with leaves pointing in direction of the grid. We construct this tree in such a way that all vertices of the same level lie in the same column of the grid and from one leaf to the next we have distance two in the grid. This is possible since the number of vertices in is a power of two. To make this tree embeddable into a grid we replace every edge by a chain of the minimal required length running along the grid structure. We connect the uppermost leaf to the first row of the meta-grid in a way such that the vertical distance between this leaf and is exactly . More specifically, we add a chain up and to the right until it has length , then add a rainbow of sufficient length and connect it to . Each leaf of the tree is connected by a chain of length and a following rainbow to one of the vertices in the first column of the meta-grid such that the order of the leaves and the vertices is the same. The length is chosen such that all the chains have the same length. To avoid intersections in the -chains these go right first: the chain leading to the row corresponding to is routed steps to the right if and otherwise. Then the chains go up/down to their row and then right until they have length . Note that this tree is symmetrical in the end since we work on an even number of vertices.
The same is done on the right side: we add a vertex and a binary tree to its left with being the root and the leaves are connected to the vertices in the last column of the meta-grid by a chain of length and a rainbow. If the construction of the snake-paths causes some of the snake-paths to “stick out” to the right, then we extend the paths in the rainbows at the leaves of as far as necessary to ensure that nothing intersects. The length of these rainbows is also used to align the leaves of the tree on this side.
Finally, we add chains of length at least , the outer-grid chains, one connecting to and the other connecting to .
Intuitively, the correctness is shown as follows. Recall that . We know that we can route at most paths through a rainbow, this we have to do times. So we can pick of the rows and route paths through each. We route a single path through each of the remaining rows. Now we have to route one additional path, which has to use the outer-grid chains and the snake-chains. This path will verify that the rows we chose to route paths through correspond to vertices of that constitute a vertex cover. Then each column corresponding to an edge of has at least one row where we have a fully shared chain and no rainbow. So the remaining path can be routed through those chains and use the snake-chains to switch between rows. Of course, is chosen in a way that we are forced to use the described approach and that there is no solution if does not have a vertex cover of size . We claim that has a vertex cover of size if and only if has paths from to sharing at most edges.
() Let be a vertex cover of size at most . Without loss of generality we assume . Then for each , we route paths from via the chain of length and through the following rainbow leading to the corresponding vertex . This way each paths cause shared edges within the corresponding chain plus the rainbow-offset of edges, so in total . For all other vertices we route only one path this way. Doing so we cause every edge in the tree on the side of to be shared except on its lowest level, where only branches of the tree are shared, notice that this yields exactly shared edges. So the paths cause shared edges before reaching the meta-grid. Next we route all these paths horizontally through our meta-grid yielding another shared edges.
To route the paths from the meta-grid to we get additional shared edges. So we have paths sharing edges. The number therefore describes exactly the number of edges in the trees at and that are shared.
Next we route one additional path without sharing any additional edges. Starting at we route along the outer-grid chain linking to , the first vertex in the first row. From there has to pass the columns of the meta-grid. Since is a vertex cover there is a covering vertex for every edge. So for every column we take the vertex covering it and route the path to the corresponding row using the snake-chains. Since the vertex is part of the vertex cover the chain crossing this column is already shared, so we can use it to route on to the next column. After has crossed the meta-grid in this fashion it can be routed to the lowest row via the snake-chains and then via the outer-grid chain leading to .
So allows for --paths sharing edges. Hence, a yes-instance.
() Assume that has a solution , a set of --paths with sharing at most edges. First consider how the paths leave . There are ways to get from to the meta-grid. One of those is the outer-grid chain which can only contain one path since it has length . So paths have to be routed through the tree. Also every rainbow can contain at most paths. And due to at most of the -chains in can be shared, which means of the -chains connected to and of the -chains connected to . Consequently, we get that of the rainbows connected to the first column of the meta-grid contain paths each. Let be the first vertices from these rows. The other rainbows connected to the first column then contain exactly one path.
Next we consider what happens inside the meta-grid. Since the snake-chains are the only way to leave a row and those cannot be shared, at most paths can leave a row. So in the last column at least 2 paths are still routed through the rainbow connected to these rows and then via the -chain to . We can do the same maths as before on the side to get that these rainbows have to contain paths as well. Hence, each of this rows induces at least shared edges. Also many shared edges are induced within the trees by construction. Note that . Hence, there are less than shared edges left.
Now let . Assume towards a contradiction that is not a vertex cover. Then there is a column with a rainbow in every of the rows corresponding to the vertices in . That means that the path that is routed via the outer-grid chain connected to cannot pass this column without sharing additional edges, but our budget does not suffice for this. This yields a contradiction to being a yes-instance. ∎
3.3 Manhattan-like Acyclic Digraphs
In the previous section, we proved that MSE is -hard on holey grids, i.e. subgraphs of a bounded grid. Along the line, in this section we prove that the directed version, DMSE, is -hard on the graph class of acyclic directed holey grids (we refer to this class by Manhattan DAGs). We remark that inspired by the street design of Manhattan, New York City, directed bounded grids (referred to as Manhattan street networks) are considered in the literature, also in the context of routing [13, 17].
Observe that MSE reduces to DMSE by replacing each edge by anti-parallel arcs , . The correctness of the reduction follows immediately from the following.
Lemma 3**.**
Let be an instance of DMSE. If is a solution for this instance where two paths and use and its inverted arc , then we can find a solution for the same instance that does not use both of these arcs.
Proof.
The idea is to split both paths by removing those two edges and connect the beginning of the first path to the trailing part of the second path and vice versa, retaining a solution for the instance.
We first introduce some notation: When is a directed path and occur in that order, then we denote the subpath of that starts at and ends at by . If and are two paths and the last vertex of is the same as the first vertex of , then we write for the path resulting by the union of the two paths and removing all cycles.
Assume has a solution with and . Then we can split and into subpaths as follows: and .
Now, by replacing path by and by , we are able to retain a solution in which these two paths do not use and any more.
We can repeat this until one of the two edges is not used any more by any of the paths in the solution, yielding the desired . ∎
However, the directed graph obtained in the reduction is not acyclic. We show next that DMSE remains hard even on acyclic directed holey grids. On a high level, we adapt the construction presented in the proof of Theorem 1. We then direct the edges from left to right, from towards . Finally, we duplicate the horizontal chains (snake chains) and direct one upwards and one downwards.
Theorem 2**.**
DMSE on Manhattan DAGs is -hard.
Proof.
We adapt the reduction for holey grids given in the proof of Theorem 1. To obtain a directed graph, we replace every edge in the corresponding construction by a directed edge: First we ignore the vertical snake-chains and handle the remaining edges. Each horizontal edge is directed to the right, rainbows go up, then right, then down. The tree edges are directed away from and towards . Because each snake-chain has to offer both vertical directions in the new construction without creating a cycle, they are constructed as follows. We replace the undirected snake-chains of the original construction by two snake-chains separated by single edges in their start and end. The single edges are directed to the right, the left of the new snake-chains is directed downwards and the right one upwards. We call a snake-chain outgoing from the row in which it starts and ingoing to the row where it ends. To ensure that we still have enough space for the additional snake-chain, we increase the distance between the rows by defining .
Let be an instance of Vertex Cover and be an instance of MSE constructed using the reduction for holey grids. From this we construct an instance of DMSE according to the additional steps described above. In the construction for holey grids there are chains of length inside the meta-grid. Due to the additional single edges connecting each pair of snake-chains, we get chains of length in this construction. Because is used in the definition of , the incrementation of leads to .
We claim that has a vertex cover of size if and only if has paths from to sharing at most edges.
() This direction of the proof works analogously to the reduction for holey grids using the new instance instead of . The first paths are routed in the same way. Then again we route one additional path by always choosing the corresponding outgoing snake-chain. Since we have a vertex cover, this does not share further edges.
() Let be a solution for . The difference to the reduction for holey grids lies in the number of snake-chains that is doubled in the new construction. Now, after sharing edges (for definition of see the proof of Theorem 1) in the binary trees at and , at most of the -chains between the binary trees and the meta-grid in can be shared.
Since only the outgoing snake-chains can be used to leave a row, we can argue again that there are rows in the meta-grid containing more than one path, each one inducing at least shared edges. Let be the set vertices corresponding to these rows. If is no vertex cover, then we need to share another -chain in the construction adding additional shared edges, which is a contradiction to being a yes-instance. ∎
4 The Nonexistence of Polynomial Kernels
In this section, we consider MSE from a parametrised complexity point of view. MSE is kernelisable but does not admit a polynomial problem kernel when it is parametrised by the number of paths, unless [7]. We strengthen the latter result and complement the intractability of MSE on planar graphs by showing the following.
Theorem 3**.**
Unless , MSE with parameter does not admit a polynomial kernel, even on planar graphs.
In order to prove Theorem 3, we use a so-called OR-cross-composition due to Bodlaender et al. [5]. Therein, one uses a polynomial equivalence relation which is an equivalence relation that is decidable in polynomial time and for each finite set , the number of equivalence classes with respect to , that is, , is polynomially bounded in the size of the largest element in .
Definition 1** (OR-cross-composition [5]).**
Let be some problem and with and be some parametrised problem. Furthermore, let be a polynomial equivalence relation on . An OR-cross-composition is an algorithm that gets instances of as input, all of them belonging to the same equivalence class of , and outputs an instance of such that
- •
if and only if there is at least one such that and
- •
is polynomially bounded in .
If there is an OR-cross-composition from an -hard problem to some parametrised problem , then does not admit a polynomial-size kernel, unless [5]. Using this result, we give an OR-cross-composition to prove Theorem 3. Our construction contains binary trees and we use the following structural result on binary trees with respect to MSE.
Lemma 4**.**
Let be a balanced, binary and complete tree of height with root , where additionally all leaves are identified with the target . Then the only solutions for an MSE-instance with and are to share a complete path from to some leaf, which is only possible for .
Proof.
The idea is again that the contraction of the shared edges must allow a flow of value from to in any solution.
Initially has degree two. Each contraction of an edge may only increase the degree by one. So after contractions the degree is at most , except if the contraction identifies with . This can only happen if a complete path from to is shared. Since such a path has length this is only possible for . Due to the condition there are no other shared edges and . ∎
Next we prove the main result of this section.
Proof of Theorem 3.
We apply the OR-cross-composition framework with MSE on planar graphs where and lie on the outer face as input problem. The -hardness of this problem is shown in Theorem 1 since in the reduction and are on the outer face.
We say an instance of MSE is malformed if (trivial yes-instances), if and are not connected, if and (trivial no-instances), or if . Note that in the last case we can decide the instance in polynomial time, since the problem is fixed-parameter tractable with respect to [7]. Hence we can decide each malformed instance in polynomial time.
We define the equivalence relation as follows: two instances and are -equivalent if both are malformed or if and . Observe that is a polynomial equivalence relation.
Let be non-malformed -equivalent instances of MSE. We assume to be a power of 2 (as otherwise we duplicate instances until it is). We first construct a complete binary tree rooted in with depth such that the are the leaves of , occurring in their canonical order. Conversely, we construct a tree with root and leaves . We subdivide each edge in and to obtain paths of length . In this way we obtain a new graph with and . Furthermore, we define the new parameters and and get the instance , see Fig. 3. Now we claim that is a yes-instance if and only if there is an with that is a yes-instance.
In the trees let denote the path from to in and let denote the path from to in for every .
() Assume that is a yes-instance with solution . We route paths along , through and along sharing at most edges within and additional edges in the trees. Thus in at most edges are shared. Note that every other instance allows for at least one path, since and are connected. So from each vertex of , except , we route an additional path through one of the remaining instances. Thus we get additional paths not sharing any additional edge. So we have paths and therefore a solution for .
() Assume the constructed instance has a solution . Note that in and we share at most of the -paths, but we have to route paths, since . By Lemma 4 this implies that there exist such that and are completely shared. At each vertex of only one path from may branch off, which implies that only paths do so. Hence, at least paths are routed through , leaving the instance at . So must be shared, which implies . Note that therefore shares outside of . That leaves edges that can be shared inside of . So restricted to is a solution for .
This concludes the proof that has a solution if and only if there is an such that has a solution. Finally, we observe that and are polynomially bounded in and . Since we only added binary trees, the maximum degree is increased by at most two. For all and every two vertices in the instances and there is a connecting path via -- of length at most . For all vertices in and we have a connecting path by going to , then through and finally via to the desired vertex. This path has length at most . Hence, the diameter of is at most , which is polynomial in the input size and . The treewidth of is upper-bounded by , because the graph is planar [16]. (Alternatively, there also is a tree decomposition of of treewidth at most .)
So is polynomially bounded by . It follows that MSE parametrised by does not admit a polynomial kernel, even on planar graphs. ∎
Recall that DMSE is -hard on planar acyclic digraphs with and lying on the outerface (Theorem 2). Hence, replacing the input instances by instances from DMSE on the aforementioned graphs, and directing the remaining edges in the trees away from and towards allows us to also exclude polynomial kernels for DMSE parametrised111DMSE is in when parametrised by since the search tree algorithm solving MSE in time [7] can easily be adapted to the directed case. by .
Corollary 1**.**
Unless , DMSE on planar acyclic digraphs with parameter does not admit a polynomial kernel.
5 Conclusion
On the positive side, we proved that Minimum Shared Edges on bounded grids is solvable in linear time when both dimensions are either small or large compared to the number of paths. On the negative side, we proved that MSE becomes -hard on subgraphs of the bounded grid, even if the subgraph is directed and acyclic, and that it does not allow for polynomial kernels on planar graphs when parametrised by a combined parameter , unless .
We conjecture that MSE on -narrow grids is solvable in polynomial time. In particular, we find it interesting whether an arithmetic criterion similar to the -large case (cf. Lemma 2) exists. Furthermore, in our reduction from Vertex Cover, the construction yields a grid with a large amount of edges removed by taking a subgraph. Is MSE parametrised by the number of edges removed from the grid in FPT (or even admits a polynomial-size problem kernel)?
We consider it as interesting to study DMSE on Manhattan street networks (cf. [13]). Recently, MSE is considered with an additional time-aspect [14]. Herein, on a high level, an edge is shared if it appears in at least two paths at the same time. Another future research direction could be to study MSE with the additional time-aspect on grid-like graphs.
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] Samu Alanko, Simon Crevals, Anton Isopoussu, Patric R. J. Östergård, and Ville Pettersson. Computing the domination number of grid graphs. The Electronic Journal of Combinatorics , 18(1), 2011.
- 2[2] Yusuke Aoki, Bjarni V. Halldórsson, Magnús M. Halldórsson, Takehiro Ito, Christian Konrad, and Xiao Zhou. The minimum vulnerability problem on specific graph classes. Journal of Combinatorial Optimization , 32(4):1288–1304, 2016.
- 3[3] Sepehr Assadi, Ehsan Emamjomeh-Zadeh, Ashkan Norouzi-Fard, Sadra Yazdanbod, and Hamid Zarrabi-Zadeh. The minimum vulnerability problem. Algorithmica , 70(4):718–731, 2014.
- 4[4] Dinesh Bhatia, Frank Thomson Leighton, Fillia Makedon, and Carolyn Haibt Norton. Improved algorithms for routing on two-dimensional grids. In Proc. of the 18th International Workshop on Graph-Theoretic Concepts in Computer Science (WG 1992) , volume 657 of LNCS , pages 114–122. Springer, 1992.
- 5[5] Hans L. Bodlaender, Bart M.P. Jansen, and Stefan Kratsch. Kernelization lower bounds by cross-composition. SIAM Journal on Discrete Mathematics , 28(1):277–305, 2014.
- 6[6] Till Fluschnik. The parameterized complexity of finding paths with shared edges. Master’s thesis, TU Berlin, March 2015.
- 7[7] Till Fluschnik, Stefan Kratsch, Rolf Niedermeier, and Manuel Sorge. The parameterized complexity of the minimum shared edges problem. In Proc. of the 35th IARCS Annual Conference on Foundation of Software Technology and Theoretical Computer Science (FSTTCS 2015) , volume 45 of LIP Ics , pages 448–462. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, 2015.
- 8[8] Till Fluschnik and Manuel Sorge. The minimum shared edges problem on planar graphs. ar Xiv preprint ar Xiv:1602.01385 , 2016.
