Abstract 1 Introduction 2 Total-Secluded Strongly Connected Subgraph 3 Secluded 𝓕-Free subgraph and Secluded DAG 4 Secluded Subgraphs with Small Independence Number References

A Parameterized Study of Secluded Structures in Directed Graphs

Jonas Schmidt ORCID Bocconi University, Milan, Italy Shaily Verma ORCID Hasso Plattner Institute, Potsdam, Germany Nadym Mallek ORCID Hasso Plattner Institute, Potsdam, Germany
Abstract

Given an undirected graph G and an integer k, the Secluded Π-Subgraph problem asks you to find a maximum size induced subgraph that satisfies a property Π and has at most k neighbors in the rest of the graph. This problem has been extensively studied; however, there is no prior study of the problem in directed graphs. This question has been mentioned by Jansen et al. [ISAAC’23].

In this paper, we initiate the study of Secluded Subgraph problems in directed graphs by incorporating different notions of neighborhoods: in-neighborhood, out-neighborhood, and their union. Formally, we call these problems {In, Out, Total}-Secluded Π-Subgraph, where given a directed graph G and an integer k, we want to find an induced subgraph satisfying Π of maximum size that has at most k in/out/total-neighbors in the rest of the graph, respectively. We investigate the parameterized complexity of these problems for different properties Π. In particular, we prove the following parameterized results:

  • We design an FPT algorithm for the Total-Secluded Strongly Connected Subgraph problem when parameterized by k.

  • We show that the Out-Secluded -Free Subgraph problem with parameter k is W[1]-hard, where is a family of directed graphs except any subgraph of a star graph whose edges are directed towards the center. This result also implies that In/Out-Secluded DAG is W[1]-hard, unlike the undirected variants of the two problems, which are FPT.

  • We design an FPT-algorithm for In/Out/Total-Secluded α-Bounded Subgraph when parameterized by k, where α-bounded graphs are a superclass of tournaments.

  • For undirected graphs, we improve the best-known FPT algorithm for Secluded Clique by providing a faster FPT algorithm that runs in time 1.6181kn𝒪(1).

Keywords and phrases:
Secluded Subgraph, Parametrized Complexity, Directed Graphs, Strong Connectivity
Copyright and License:
[Uncaptioned image] © Jonas Schmidt, Shaily Verma, and Nadym Mallek; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Parameterized complexity and exact algorithms
; Theory of computation Graph algorithms analysis
Related Version:
Full Version: https://arxiv.org/abs/2502.06048 [21]
Editors:
Ho-Lin Chen, Wing-Kai Hon, and Meng-Tsung Tsai

1 Introduction

Finding substructures in graphs that satisfy specific properties is a ubiquitous problem. This general class of problems covers many classical graph problems such as finding maximum cliques, Steiner trees, or even shortest paths. Another compelling property to look for in a substructure is its isolation from the remaining graph. This motivated Chechik et al. [1], to introduce the concept of secluded subgraphs. Formally, in the Secluded Π-Subgraph problem, given an undirected graph G, the goal is to find a maximum size subset of vertices SV(G) such that the subgraph induced on S fulfills a property Π and has a neighborhood |N(S)|k where k is a natural number.

This problem has been studied extensively for various properties Π such as paths [23, 17, 8, 1], Steiner trees [1, 8], induced trees [7, 11], subgraphs free of forbidden induced subgraphs [11, 15], and more [22]. Most of these studies focus on the parameterized setting, due to the strong relation to vertex deletion and separator problems, which are foundational in parameterized complexity. Our problem fits in that category since the neighborhood can be considered a (S,VS)-separator.

While the undirected Secluded Π-Subgraph problem has been explored and widely understood in prior work [15, 11, 7], the directed variant has not yet been studied, although it is a natural generalization and was mentioned as an interesting direction by Jansen et al. [15]. Directed graphs naturally model real-world systems with asymmetric interactions, such as social networks with unidirectional follow mechanisms or information flow in communication systems. Furthermore, problems such as Directed Feedback Vertex Set, Directed Multicut, and Directed Multiway Cut underline how directedness can make a fascinating and insightful difference when it comes to parameterized complexity [2, 13, 19, 4]. These problems and their results provide a ground for studying directed secluded subgraph problems, motivating the need to investigate them systematically.

In this paper, we introduce three natural directed variants of the Secluded Π-Subgraph problem, namely Out-Secluded Π-Subgraph, In-Secluded Π-Subgraph, and Total-Secluded Π-Subgraph. These problems limit either the out-neighborhood of S, its in-neighborhood, or the union of both. The out/in-neighborhood of a set S is the set of vertices in V(G)S reachable from S via an outgoing/incoming edge. The problems corresponding to different types of neighborhoods can be encountered in real-life networks. In privacy-aware social network analysis, one might aim to identify a community with minimal external exposure. Similarly, robust substructures with limited connectivity to vulnerable components are critical in cybersecurity. These real-world motivations further emphasize the need to explore and formalize directed variants of the Secluded Π-Subgraph problem.

Table 1: Our main results for directed and undirected problems. WC stands for weakly connected. All FPT results are with respect to parameter k and all hardness results are with respect to parameter k+w. For the entry marked with , the undirected algorithm from [15] immediately generalizes to the total-secluded setting (for finite ). The problems marked with (?) are open.
Property Π In- / Out-Secluded Total-Secluded
WC -Free Subgraph W[1]-hard Thm.˜2 FPT [15]
WC DAG W[1]-hard Cor.˜3 ?
α-Bounded Subgraph FPT Thm.˜4 FPT Thm.˜5
Strongly Connected Subgraph ? FPT Thm.˜1
Clique FPT in time 1.6181kn𝒪(1) Thm.˜6

For any property Π, we formulate our general problem as follows. Notice that in-secluded and out-secluded are equivalent for all properties that are invariant under the transposition of the edges. For this reason, we mostly focus on total-neighborhood and out-neighborhood.

Parameter: An integer k

Input: A directed graph G with vertex weights ω:V and an integer w

Output: An k-X-secluded set SV(G) of weight ω(S)w that satisfies Π, or report that none exists.

Our Contribution

In this subsection, we present the results we obtained for the problem. See Table 1 for an overview of the results we obtained in this paper.

Strongly Connected Subgraph.

We show that the Total-Secluded Strongly Connected Subgraph problem is fixed-parameter tractable when parameterized with k. Precisely, we prove the following result:

Theorem 1.

Total-Secluded Strongly Connected Subgraph is solvable in time 222𝒪(k2)n𝒪(1).

We design our FPT algorithm for Total-Secluded Strongly Connected Subgraph problem using recursive understanding, a technique introduced by [12] and recently used successfully for various parameterized problems [3, 11, 6, 16]. Specifically, [16] prove a meta-result stating that if a problem is FPT on highly-connected graphs and expressible in Counting Monadic Second-Order Logic, it is also FPT on general graphs. Thereby, this theorem allows to shortcut the analysis and algorithm for the breakable case of recursive understanding. However, it comes at the price of being nonconstructive and not giving a concrete bound on the runtime. For this reason, it is still valuable to apply recursive understanding directly. In future work, it could be promising to apply and generalize this theorem for directed graphs. We visualize the overall structure of the algorithm in Figure 1.

Figure 1: An illustration of the general recursive understanding algorithm used in Section 2. There are two recursive calls in total, highlighted with dashed arrows. As defined later, only vertices inside B are allowed to be in the neighborhood of a solution. W is chosen to be the side of the separation with a smaller intersection with T.

On a high level, recursive understanding algorithms work by first finding a small balanced separator of the underlying undirected graph. If no suitable balanced separator exists, the graph must be highly connected, which makes the problem simpler to solve. In the other case, we reduce and simplify one side of the separator while making sure to keep an equivalent set of solutions in the whole graph. By choosing parameters in the right way, this process reduces one side of the separator enough to invalidate the balance of the separator. Therefore, we have made progress and can iterate with another balanced separator or reach the base case.

In our case, looking for a separator of size at most k makes the framework applicable. Crucially, this is because in any secluded subgraph G[S], where SV(G), the neighborhood N(S) acts as a separator between S and V(G)N[S]. Therefore, if no balanced separator of size at most k exists, we can deduce that either S itself or V(G)S must have a small size. This observation makes the problem significantly easier to solve in this case, using the color coding technique developed in [3].

In the other case, we can separate our graph into two balanced parts, U and W, with a separator P of size |P|k. Now, our goal is to solve the same problem recursively for one of the sides, say W and replace that side with an equivalent graph of bounded size that only contains all necessary solutions. However, finding subsets of solutions is not the same as finding solutions; the solution S for the whole graph could heavily depend on including some vertices in U. That being said, the different options for this influence are limited. At most 2k different subsets X of P could be part of the solution. For any such X, the solution can only interact across P in a limited number of ways. For finding strongly connected subgraphs, we have to consider for which pair (x1,x2)X×X there already is a x1-x2-path in the U-part of the complete solution S. This allows us to construct a new instance for every such possibility by encoding X and the existing paths into W. These instances are called boundary complementations. We visualize the idea of this construction in Figure 2.

Fundamentally, we prove that an optimal solution for the original graph exists, that coincides in W with an optimal solution to the boundary complementation graph in which U is replaced. Hence, we restrict the space of solutions to only those whose neighborhood in W coincides with the neighborhood of an optimal solution to some boundary complementation. The restricted instance consists of a bounded-size set B of vertices that could be part of N(S) and components in WB that can only be included in S completely or not at all. We introduce graph extensions to formalize when exactly these components play the same role in a strongly connected subgraph. Equivalent extensions can then be merged and compressed into equivalent extensions of bounded size. In total, this guarantees that W is shrunk enough to invalidate the previous balanced separator, and we can restart the process.

𝓕-Free Subgraph.

For any family of graphs , a graph G is called -Free if it does not contain any graph in as an induced subgraph. Depending on the context both and G are either both undirected or both directed. The widely-studied Secluded -Free Subgraph problem on undirected graphs is FPT (with parameter k) using recursive understanding [11] or branching on important separators [15] when we restrict it to connected solutions. We study the directed version of the problem and surprisingly, it turns out to be W[1]-hard for almost all forbidden graph families even with respect to the parameter k+w. Precisely, we prove the following theorem.

Theorem 2.

Let be a non-empty set of directed graphs such that no F is a subgraph of an inward star. Then, Out-Secluded -Free Weakly Connected Subgraph is W[1]-hard with respect to the parameter k+w for unit weights.

We establish an almost complete dichotomy that highlights the few cases of families for which the problem remains tractable. One of these exceptions is if contains an edgeless graph of any size, where we employ our algorithm for Out-Secluded α-Bounded Subgraph. Theorem 2 also implies the following result for the directed variant of Secluded Tree problem.

Corollary 3.

Out-Secluded Weakly Connected DAG is W[1]-hard with parameter k+w for unit weights.

𝜶-Bounded Subgraph & Clique.

In the undirected setting, the Secluded Clique problem is natural and has been studied specifically. There is an FPT-algorithm running in time 2𝒪(klogk)n𝒪(1) through contracting twins [11]. The previous best algorithm however uses the general result for finding secluded -free subgraphs in time 2𝒪(k)n𝒪(1) [15]. By using important separators, they require time at least 4kn𝒪(1). This property is naturally generalizable to directed graphs via tournament graphs. We go one step further.

The independence number of an undirected or directed graph G is the size of the maximum independent set in G (or its underlying undirected graph). If G has independence number at most α, we also call it α-bounded. This concept has been used to leverage parameterized results from the simpler tournament graphs to the larger graph class of α-bounded graphs [20, 10, 18]. We prove the following results:

Theorem 4.

Out-Secluded α-Bounded Subgraph is solvable in time (2α+2)knα+𝒪(1).

Theorem 5.

Total-Secluded α-Bounded Subgraph is solvable in time (α+1)knα+𝒪(1).

We achieve the goal via a branching algorithm, solving Secluded α-Bounded Subgraph for all neighborhood definitions in FPT time (Theorems 4 and 5). Our algorithm initially picks a vertex subset UV(G) and looks only for solutions in the two-hop neighborhood of U. A structural property of α-bounded graphs guarantees that any optimal solution is found in this way. On a high level, the remaining algorithm depends on two branching strategies. First, we branch on forbidden structures in the two-hop neighborhood of U, to ensure that it becomes α-bounded. Second, we branch on farther away vertices to reach a secluded set.

Note that Theorem 5 is inherently also an undirected result. Furthermore, the ideas behind the algorithm can in turn be used for the simpler undirected Secluded Clique problem. By a closer analysis of these two high-level rules, we arrive at a branching vector of (1,2) for Secluded Clique. This results in the following runtime, a drastic improvement on the previous barrier of 4kn𝒪(1).

Theorem 6.

Secluded Clique is solvable in time 1.6181kn𝒪(1).

Organization.

We consider Total-Secluded Strongly Connected Subgraph and prove Theorem 1 in Section 2. The hardness result about Out-Secluded Weakly Connected Subgraph in Theorem 2 is proved in Section 3. In Section 4, we give the algorithm for Out-Secluded α-Bounded Subgraph and prove Theorem 4. Due to space constraints, the algorithms and proofs of Theorems 5 and 6 can be found in the full version [21]. Proofs of statements marked with () are also deferred to the full version.

Notation.

Let G be a directed graph. For a vertex vV(G), we denote the out-neighborhood by N+(v)={u|(v,u)E(G)} and the in-neighborhood by N(v)={u|(u,v)E(G)}. The total-neighborhood is defined as N(v)=N+(v)N(v). We use the same notation for sets of vertices SV(G) as N+(S)=vSN+(v)S. Furthermore, for all definitions, we also consider their closed version that includes the vertex or vertex set itself, denoted by N+[v]=N+(v){v}. For a vertex set SV(G), we write G[S] for the subgraph induced by S or GS for the subgraph induced by V(G)S. We also use Gv instead of G{v}.

When we refer to a component of a directed graph, we mean a component of the underlying undirected graph, that is, a maximal set that induces a weakly connected subgraph. In contrast, a strongly connected component refers to a maximal set that induces a strongly connected subgraph. For standard parameterized definitions, we refer to [5].

2 Total-Secluded Strongly Connected Subgraph

In this section, we investigate the Total-Secluded Strongly Connected Subgraph problem, or TSSCS for short. First, we prove that the problem is NP-hard in general graphs, motivating analysis of its parameterized complexity.

Theorem 7 ().

TSSCS is NP-hard, even for unit weights.

The proof of Theorem 7 also shows that TSSCS is W[1]-hard when parameterized by w, since w in the proof also only depends on the parameter for Clique. In the following subsections, we describe the recursive understanding algorithm to solve TSSCS parameterized by k. We follow the framework by [3, 11] and first introduce generalized problems in Section 2.1. In Section 2.2, we solve the case of unbreakable graphs. We introduce graph extensions in Section 2.3 as a framework to formulate our reduction rules and full algorithm in Section 2.4.

2.1 Boundaries and boundary complementations

In this subsection, we first define an additional optimization problem that is useful for recursion. Then, we describe a problem-specific boundary complementation. Finally, we define the auxiliary problem that our algorithm solves, which includes solving many similar instances from the optimization problem.

Input: A directed graph G, subsets I,O,BV(G), a weight function ω:V(G), and an integer k

Output: A set SV(G) that maximizes ω(S) subject to IS, OS=, N(S)B, |N(S)|k, and G[S] strongly connected, or report that no feasible solution exists.

Note that this problem generalizes the optimization variant of TSSCS by setting IO and BV(G). However, Max TSSCS allows us to put more constraints on recursive calls, enforcing vertices to be included or excluded from the solution and neighborhood.

(a) A strongly connected subgraph S of a graph G with k=5 neighbors. Black vertices are part of S.
(b) The boundary complementation that admits an equivalent feasible solution when setting kk2.
Figure 2: A visualization of a solution in the original graph and a solution in a boundary complementation. Every partial solution in U can be represented by a boundary complementation.
Definition 8 (Boundary Complementation).

Let =(G,I,O,B,ω,k) be a Max TSSCS instance. Let TV(G) be a set of boundary terminals with a partition X,Y,ZT and let RX×X be a relation on X. Then, we call the instance (G,I,O,B,ω,k) a boundary complementation of and T if

  1. 1.

    G is obtained from G by adding vertices u(a,b) for every (a,b)R and edges (a,u(a,b)), (u(a,b),b), and for every yY additionally (u(a,b),y),

  2. 2.

    IIX{u(a,b)(a,b)R},

  3. 3.

    OOYZ,

  4. 4.

    ω(v)ω(v) for vV(G) and ω(u(a,b))0 for (a,b)R, and

  5. 5.

    kk.

See Figure 2 for an example boundary complementation. The intuition here should be that if we take the union of G with any other graph H and only connect H to G at the vertices in T, then (X,Y,Z,R) encodes all possibilities of how a solution in GH could behave from G’s point of view. So, for any solution S to Max TSSCS in GH, there is some boundary complementation for G in which we can solve and exchange SG for that solution. Later, we prove a statement that is similar to this intuition.

To employ recursive understanding, we need a boundaried version of the problem. Intuitively, this problem is the same as the previous Max TSSCS but for a small part of the graph we want to try out every possibility, giving many very similar instances. This small part will later represent a separator to a different part of the graph.

Input: A Max TSSCS instance =(G,I,O,B,ω,k) and a set of boundary terminals TV(G) with |T|2k

Output: A solution to Max TSSCS for each boundary complementation of and T, or report that no solution exists.

To even have a chance to solve this problem, we need to make sure that there are not too many boundary complementations. The following lemma bounds that number in terms of k.

Lemma 9 ().

For a Max TSSCS instance (G,I,O,B,ω,k) and TV(G), there are at most 3|T|2|T|2(k+1) many boundary complementations, which can be enumerated in time 2𝒪(|T|2)n𝒪(1).

2.2 Unbreakable Case

This subsection gives the algorithm for the base case of our final recursive algorithm, when no balanced separator exists. We start by giving the definitions of separations and unbreakability.

Definition 10 (Separation).

Given two sets A,BV(G) with AB=V(G), we say that (A,B) is a separation of order |AB| if there is no edge with one endpoint in AB and the other endpoint in BA.

Definition 11 (Unbreakability).

Let q,k. An undirected graph G is (q,k)-unbreakable if for every separation (A,B) of G of order at most k, we have |AB|q or |BA|q.

Due to space constraints, we defer any further details on the algorithm for the unbreakable case to the full version [21]. It uses standard color coding techniques from [3, 11].

Theorem 12 ().

Boundaried Max TSSCS on (q,k)-unbreakable graphs can be solved in time 2𝒪(k2log(q))n𝒪(1).

2.3 Compressing Graph Extensions

Before we give the complete algorithm, we define a routine that compresses a part of the graph. We aim for two crucial properties in the compressed part. First, the part after compression should be equivalent to the part before compression in terms of which strongly connected components can be formed. Second, we want the size of the compressed part to be functionally bounded by the size of remaining graph.

To achieve this goal, we first formally define sufficient properties to reason about this equivalence and bound the number of equivalence classes. First, we define the notion of a graph extension, a way to extend one graph with another. The extension will play the role of the compressed part of the graph. This concept allows us to speak more directly about graph properties before and after exchanging a part of the graph with a different one.

Definition 13 (Extension).

Given a directed graph G, we call a pair (D,EGD) an extension of G if D is a directed graph and EGD(V(G)×V(D))(V(D)×V(G)) is a set of pairs between G and D. We name the graph ExtG(D,EGD)(V(G)V(D),E(G)E(D)EGD), that can be created from the extension, G extended by (D,EGD).

We use extensions to construct extended graphs. Intuitively, an extension of G is a second graph D together with an instruction EGD on how to connect D to G.

Next, we identify three important attributes of extensions in our context. Later, we show that these give a sufficient condition on when two extensions form the same strongly connected subgraphs. For this, consider a directed graph G with an extension (D,EGD). For UV(D), we write NEGD(U) as a shorthand for NExtG(D,EGD)(U), that is, all vV(G) with (v,u)EGD for some uU. Define NEGD+(v) analogously. Write SCC(D) for the condensation of D, where every strongly connected component C of D is contracted into a single vertex. Define 𝒮(D,EGD),𝒯(D,EGD)2V(G) such that

𝒮(D,EGD) {NEGD(U)|UV(D) is a source component in SCC(D)} and
𝒯(D,EGD) {NEGD+(U)|UV(D) is a sink component in SCC(D)},

that is, for every strongly connected source component C in SCC(D), 𝒮(D,EGD) contains the set of all vV(G) such that (v,u)EGD for some uC and analogously for 𝒯(D,EGD). Furthermore, define

𝒞(D,EGD){(a,b)V(G)2|there is a d1-d2-path in D with (a,d1),(d2,b)EGD},

that is, all (a,b) such that there is an a-b-path in ExtG(D,EGD), whose intermediate vertices and edges belongs to D. Refer to Figure 3 for examples of extensions and the three sets.

Definition 14 (Equivalent Extensions).

Let G be a directed graph. We say that two extensions (D1,EGD1) and (D2,EGD2) of G are equivalent if

(𝒮(D1,EGD1),𝒯(D1,EGD1),𝒞(D1,EGD1))=(𝒮(D2,EGD2),𝒯(D2,EGD2),𝒞(D2,EGD2)).

Clearly, extension equivalence defines an equivalence relation. The next statement reveals the motivation behind the definition of extension equivalence. It gives us a sufficient condition for two extensions being exchangeable in a strongly connected subgraph.

Lemma 15.

Let G be a directed graph with two equivalent extensions (D1,EGD1) and (D2,EGD2). Let UV(G) be nonempty such that the extended graph ExtG[U](D1,EG[U]D1) is strongly connected. Then ExtG[U](D2,EG[U]D2) is also strongly connected.

Proof.

We construct a v1-v2-path for all v1,v2UV(D2) that only uses edges in E(D2), EGD2, and G[U] by case distinction.

Paths UU.

Let u1,u2U. If there is a path from u1 to u2 in G[U], this path also exists after exchanging (D1,EGD1) to (D2,EGD2). If the path passes through D1, since 𝒞(D1,EGD1)=𝒞(D2,EGD2), we can exchange all subpaths through D1 by subpaths through D2.

Paths V(D2)U.

Let vV(D2),uU. We construct a v-u-path by first walking from v to any sink component T in SCC(D2). If there is no edge (t,u)EGD2 with tT,uU that we can append, since 𝒯(D1,(D1,EGD1))=𝒯(D2,(D2,EGD2)), there must also be a sink component in SCC(D1) with no outgoing edge to U. However, this is a contradiction to the fact that ExtG[U](D1,EG[U]D1) is strongly connected with nonempty U. Therefore, we can find a (t,u) to append for some tT,uU. From u, there is already a path to u, as proven in the first case.

Paths UV(D2).

Next, we construct a u-v-path backwards by walking from v backwards to a source s in D2. Analogously, there is an edge (u,s)EGD2 for some uU since 𝒮(D1,EGD1)=𝒮(D2,EGD2), which we append. From u, there is a path to u, as proven in the first case, which we prepend to the rest of the path.

Paths V(D2)V(D2).

Let v1,v2V(D2). To construct a v1-v2-path, we can just walk from v1 to any uU and from there to v2 as shown before.

Furthermore, observe that the union of two extensions creates another extension where source, sink and connection sets correspond exactly to the union of the previous sets. Hence, the union of two equivalent extensions will again be equivalent. This fact is formalized in the next observation and will turn out useful in later reduction rules.

Figure 3: Two example extensions of a graph G. Observe that 𝒮(D,EGD)={{v1}}, 𝒯(D,EGD)={{v3}}, and 𝒞(D,EGD)={(v1,v2),(v1,v3)}. The extension (D,EGD) not only has the same sets 𝒮,𝒯,𝒞 and is thereby equivalent; it is also the compressed extension of (D,EGD). Since all sources d1,d2,d3 have the same in-neighborhood, they are represented by the single vertex vS.
Observation 16.

Let G be a directed graph with two equivalent extensions (D1,EGD1) and (D2,EGD2). Consider the extension defined by D(V(D1)V(D2),E(D1)E(D2)) and EGDEGD1EGD2. Then (D,EGD) is equivalent to (D1,EGD1) and (D2,EGD2).

Now, we finally define our compression routine, which compresses an extension to a bounded size equivalent extension. If an extension is strongly connected, it is easy to convince yourself that it is always possible to compress the extension to a single vertex. Otherwise, we add one source vertex per neighborhood set in 𝒮(D,EGD) as well as one sink vertex per neighborhood set in 𝒯(D,EGD), realizing the same 𝒮 and 𝒯. Then, we add vertices in between suitable source and sink vertices to realize exactly the same connections in 𝒞 without creating additional ones. The result of a compression is visualized in Figure 3. Now, we describe the procedure formally.

Let G be a directed graph with an extension (D,EGD). Our compression routine returns an extension that we call compressed extension, denoted as CompG(D,EGD).

Compression Routine.

  • If D is strongly connected, we contract D to one vertex v and remove self-loops and multiple edges. We adjust EGD by using v instead of V(D) and removing multiple edges.

  • Otherwise, CompG(D,EGD)(D,EGD), where (D,EGD) is an extension such that

    V(D) {vS|S𝒮(D,EGD)}{vT|T𝒯(D,EGD)}{vc|c𝒞(D,EGD)},
    EGD {(s,vS)|S𝒮(D,EGD),sS}{(vT,t)|T𝒯(D,EGD),tT}
    {(a,vc),(vc,b)|c=(a,b)𝒞(D,EGD)}.

    To define E(D), consider every source component Cs and sink component Ct in SCC(D) such that Ct is reachable from Cs in D. Let SNEGD(Cs) and TNEGD(Ct) be the corresponding sets in 𝒮(D,EGD) and 𝒯(D,EGD).

    • Add the edge (vS,vT) to E(D).

    • For every c=(a,b)𝒞(D,EGD) that satisfies (s,b)𝒞(D,EGD) and (a,t)𝒞(D,EGD) for every sS,tT, add the edges (vS,vc) and (vc,vT) to E(D).

Now we go on to prove the properties that are maintained while compressing. Then, we bound the size of a compressed extension and thus also the number of equivalence classes.

Lemma 17.

Let G be a directed graph with an extension (D,EGD) and let (D,EGD) be the compressed extension of (D,EGD). Then, the following are true.

  1. 1.

    If D is weakly connected, then D is also weakly connected.

  2. 2.

    D is strongly connected if and only if D is strongly connected.

  3. 3.

    (D,EGD) is equivalent to (D,EGD).

Proof.

For the first property, assume that D is weakly connected. We know by definition that every sink in D is reached by at least one source. Consider a vc with c=(a,b)𝒞(D,EGD). To show that vc is connected to some vS and vT, consider the path from d1 to d2 in D that realizes this connection. There must be a source component CS and a sink component CT in SCC(D) such that d1 is reachable from CS and CT is reachable from d2. Therefore, any vertex in CS can also reach d2 and d1 can reach every vertex in CT. By definition of compression, these two components ensure that vc is connected.

It remains to show that any source is reachable by any other source in the underlying undirected graph. Let vS,vS be two sources in D with corresponding source components C, C in SCC(D). Since D is weakly connected, there is a path from C to C in the underlying undirected graph. Whenever the undirected path uses an edge in a different direction than the one before, we extend the path to first keep using edges in the same direction until a source or sink component is reached and then go back to the switching point. This new path can directly be transferred to D, where we only keep the vertices corresponding to source and sink components. By definition, this is still a path in D that connects vS to vS, and D is weakly connected

The second property is simple to verify, since strongly connected graphs are by definition compressed to single vertices. If D is not strongly connected, D will have at least one source and one sink that are not the same.

Regarding the equivalence, we create one source for every S𝒮(D,EGD) with the same set of incoming neighbors and create no other sources. Therefore, 𝒮(D,EGD)=𝒮(D,EGD) and 𝒯(D,EGD)=𝒯(D,EGD) follows analogously. For every connection c𝒞(D,EGD), we create vc in D that realizes this connection. Therefore, we know that 𝒞(D,EGD)𝒞(D,EGD). Since vc is only reachable from sources and reaches only sinks that do not give new connections, we arrive at 𝒞(D,EGD)=𝒞(D,EGD).

We also bound the number of possible different compression outputs as well as their size.

Lemma 18 ().

For a directed graph G, there can be at most 222|V(G)|+|V(G)|2 different compressed extensions. Furthermore, every compressed extension has at most 2|V(G)|+1+|V(G)|2 vertices.

In the past section, we have defined graph extensions and an equivalence relation on them that captures the role they can play in forming strongly connected subgraphs. We have presented a way to compress an extension such that its size only depends on the size of G, while remaining equivalent. In the next section, we will use this theory to design reduction rules for Boundaried Max TSSCS. Crucially, we view components outside of the set B as extensions, which allows us to keep only one compressed extension of each equivalence class.

2.4 Solving Boundaried Max TSSCS

We start by giving some reduction rules for a Boundaried Max TSSCS instance =(G,I,O,B,ω,k,T). Additionally, we assume that TB to ensure that we do not change T when changing GB. This condition will always be satisfied in our algorithm. A () after a reduction rule denotes that its proof of safeness can be found in the full version [21].

The first reduction rule extends the sets I and O to whole components of GB. This is possible since no solution can include only part of a component without its neighborhood intersecting the component. Remember that components always refer to weakly connected components.

Reduction Rule 19 ().

Let Q be a component of GB. If QO, set O=ON[Q]. If N[Q]I, set I=IQ. If both cases apply, the instance has no solution.

If this reduction rule is no longer applicable, every component in GB is either completely in I, completely in O, or intersects with none of the two.

From this point, we will use extensions from the previous section for components of GB. Namely, for a component Q of GB, let EBQ be all the edges with exactly one endpoint in B and one in Q. Then, (G[Q],EBQ) defines an extension of GQ. For simplicity, we also refer to this extension as (Q,EBQ). Hence, we also use 𝒮, 𝒯, and 𝒞, as well as CompGQ for these extensions.

The next reduction rule identifies a condition under which a component Q can never be part of a solution, namely, if Q includes strongly connected components with no in-neighbors or no out-neighbors, which is exactly the case if the empty set is in 𝒮(Q,EBQ) or 𝒯(Q,EBQ).

Reduction Rule 20 ().

Let Q be a component of GB such that G[Q] is not strongly connected. If 𝒮(Q,EBQ)𝒯(Q,EBQ), include Q into O.

Note that after Reduction Rules 19 and 20 have been applied exhaustively, every source in Q has incoming edges from B, and every sink in Q has outgoing edges to B. Finally, we have one more simple rule, which removes vertices vOB. It relies on the fact that by Reduction Rule 19, we also have N(v)O.

Reduction Rule 21.

If Reduction Rule 19 is not applicable, remove OB from G.

The previous reduction rules were useful to remove trivial cases and extend I and O. From now on, we assume that the instance is exhaustively reduced by Reduction Rules 21, 20, and 19. Therefore, any component of GB is either contained in I or does not intersect I and O.

The next two rules will be twin type reduction rules that allow us to bound the number of remaining components. If there are two components of GB that form equivalent extensions it is enough to keep one of them, since they fulfill the same role in forming a strongly connected subgraph. The reduction rules rely on Lemmas 15 and 16 to show that equivalent extensions can replace each other and can be added to any solution.

Reduction Rule 22.

Let Q1,Q2 be components of GB such that both G[Q1] and G[Q2] are not strongly connected and (Q1,EBQ1) and (Q2,EBQ2) are equivalent. Delete Q2 and increase the weight of some qQ1 by ω(Q2). If Q2I, set I=IQ1.

Proof of Safeness.

By the previous reduction rules, components of GB can only be included as a whole or not at all. Notice that since 𝒞(Q1,EBQ1)=𝒞(Q2,EBQ2) and Reduction Rule 20, we get N(Q1)=N(Q2). Let S be a solution to the old instance. We differentiate some cases.

If S(Q1Q2)=, we know that also N(S)(Q1Q2)=. Therefore, the neighborhood size and strong connectivity of S do not change in the new instance, and it is also a solution. If S includes only one of Q1 and Q2, assume without loss of generality S(Q1Q2)=Q1, since Q1 is not strongly connected by itself, the solution must include vertices of B. Because N(Q1)=N(Q2), the solution must also include Q2, a contradiction. If S includes both Q1 and Q2, we claim that SSQ2 is a solution for the new instance. The neighborhood size and weight clearly remain unchanged. Strong connectivity follows by Observation 16 and Lemma 15. The last two cases also show that if a solution had to include at least one of Q1 and Q2, that is, (Q1Q2)I, any solution for the reduced instance must also include Q1. Therefore, the adaptation to I is correct.

Let S be a solution to the reduced instance. Again, if S does not include vertices from Q1, then S will immediately be a solution to the old instance. If Q1S, then SSQ2 will be a solution to the old instance by Observation 16 and Lemma 15.

For strongly connected components, the rule is different, since we have to acknowledge the fact that they can be a solution by themselves. For every such component we destroy strong connectivity of smaller-weight equivalent component, which can then be reduced by Reduction Rule 22.

Reduction Rule 23.

Let Q1,Q2 be components of GB that are also strongly connected with (Q1,EBQ1) and (Q2,EBQ2) equivalent and ω(Q1)ω(Q2). Add a vertex q2 with edges (q2,q2) and (q2,v), for all q2Q2 and vN(Q2). Set ω(q2)=0.

Proof of Safeness.

Let S be a solution of the old instance. If S(Q1Q2)=, then S is also a solution for the new instance. If S includes only one of Q1 and Q2, then we must have S{Q1,Q2}, so SQ1 is a solution for the new instance with ω(S)ω(S). If S includes both Q1 and Q2, adding q2 to S obviously gives a solution of the same weight.

For a solution of the reduced instance S, we can simply remove q2 if it is inside for a solution to the old instance.

Using both Reduction Rules 22 and 23 exhaustively makes sure that there are at most two components per extension equivalence class left. The last rule compresses the remaining components to equivalent components of bounded size.

Reduction Rule 24.

Let Q be a component of GB that is not equal to its compressed extension. Replace Q by its equivalent compressed extension and set the weight such that ω(Q)=ω(Q). If QI, set I=IQ.

Proof of Safeness.

Since Q is not strongly connected, it can only be part of a solution that includes some vertices from GQ. Thus, we can apply Lemmas 15 and 17, and the old instance and the new instance have exactly the same strongly connected subgraphs. Because of 𝒞(Q,EBQ)=𝒞(Q,EBQ) and Reduction Rule 20, we get N(Q)=N(Q). Since ω(Q)=ω(Q), the rule is safe.

This finally allows us to bound the size of GB. In the next lemma, we summarize the progress of our reduction rules and apply the bounds from the previous section. Note that we need the stronger bound using the neighborhood of the components instead of simply B.

Lemma 25 ().

Let 𝒬 be a set of components of GB with total neighborhood size h|Q𝒬N(Q)|. Then we can reduce the instance, or there are at most 22h+1+h2(2h+1+h2)=2𝒪(2h) vertices in 𝒬 in total.

Executing the reduction rules in the proposed order guarantees termination after 𝒪(n) applications. The total execution takes at most n𝒪(1) time.

Lemma 26 ([11, Lemma 3]).

Given an undirected graph G, there is an algorithm with runtime 2𝒪(min{q,k}log(q+k))n𝒪(1) that either finds a (q,k)-separation of G or correctly reports that G is ((2q+1)q2k,k)-unbreakable.

Now, we have all that it takes to solve our intermediate problem. The main idea of the algorithm is to shrink B to a bounded size, by solving the problem recursively. Once B is bounded, we apply our reduction rules by viewing components of GB as extensions, removing redundant equivalent extensions and compressing them. Thereby, we also bound the size and number of components of GB in terms of |B| using Lemma 25. By choosing suitable constants, we can show that this decreases the total size of G, which will make progress to finally reduce it to the unbreakable case.

Algorithm 1 The recursive understanding algorithm for Boundaried Max TSSCS.
Theorem 27 ().

Boundaried Max TSSCS can be solved in time 222𝒪(k2)n𝒪(1).

Proof.

Let =(G,I,O,B,ω,k,T) be our Boundaried Max TSSCS instance. See Algorithm 1 for a more compact description of the algorithm. A high level display of the approach can be found in Figure 1. Define q=222ck2 for a constant c. We later show that a suitable c must exist.

First, we run the algorithm from Lemma 26 on the underlying undirected graph of G with q and k. If it is ((2q+1)q2k,k)-unbreakable, we solve the instance directly using the algorithm from Theorem 12.

Therefore, assume that we have a (q,k)-separation (U,W). Without loss of generality, since |T|2k we can assume that |TWU|k. Thus, we can construct a new instance to solve the easier side of the separation. Take G~=G[W],I~=IW,O~=OW,B~=BW, write ω~ for the restriction of ω to W, and set T~=(TW)(UW). Since |UW|k, also |T~|2k holds and I~(G~,I~,O~,B~,ω~,k,T~) is a valid instance, which we solve recursively.

Let be the set of solutions found in the recursive call. For R, define NR=N(R)W. Define 𝒩=T~RNR.

We now restrict B in W to use only vertices in the neighborhood that have been neighbors in a solution in , that is, only vertices in 𝒩. Define B^=(BU)(B𝒩). We now replace B in our instance with B^ and apply all our reduction rules exhaustively to arrive at the instance (G,I,O,B^,ω,k,T). Finally, we also solve this instance recursively and return the solutions after undoing the reduction rules.

Correctness.

We already proved that the reduction rules and the algorithm for the unbreakable case are correct. The main statement we have to show is that we can replace B with B^ without throwing away important solutions. That means that the instances (G,I,O,B,ω,k,T) and ^(G,I,O,B^,ω,k,T) are equivalent in the sense that any solution set for one instance can be transformed to a solution set to the other instance with at least the same weights. This justifies solving ^ instead of . Consider the boundary complementation (G,I,O,B,ω,k) and ^(G,I,O,B^,ω,k) that are caused by the same (X,Y,Z,R). To show the claim, we consider the two directions. Any solution for ^ is immediately a solution for the same boundary complementation for since the only difference is that we limit the possible neighborhood to a subset of B.

For the other direction, consider a solution S to , and we want to show that there is a solution S^ to ^ using only vertices of B^ in the neighborhood with ω(S^)ω(S). If SW=, then S is also immediately a solution for ^. Therefore, assume SW. Define X~T~S, Y~T~NG(WU)(S), and Z~T~(X~Y~). Let R~ be the set of (a,b)X~×X~ such that there is an a-b-path in G[SWU]. Finally, let k~|N(S)W|. Thus, we can construct a boundary complementation instance (G~,I~,O~,B~,w~,k~) from (X~,Y~,Z~,R~). One can easily verify that (SV(G~)){ur|rR~} is a feasible solution to this instance. Furthermore, the maximum solution S~ to this instance gives a new set S^(S~W)(SU)V(G) that has at least the same weight as S. We also know that N(S^)B^ and |N(S^)|k. See Figure 2 for a visualization of the construction corresponding to a solution S.

All that remains is to verify that S^ is strongly connected. For v1,v2S~W, we can simply use the v1-v2-path in S~, replacing subpaths via ur for rR~ with the actual paths in SU. If v1S~W and v2SU, we can walk to any xX~ which must have a path to v2 in S, in which may need to replace subpaths via W. This can be done, since S~W connects all pairs of x1,x2X that are not connected via SU. The two remaining cases follow by symmetry, justifying the replacement of B with B^.

Finally, we have to show that the recursion terminates for the right choice of c; that is, both recursively solved instances have strictly smaller sizes than the original graph. For the first recursive call, note that the boundary complementation adds at most k2q vertices to G~. Since |UW|>q, we have |V(G~)|<|V(G)|.

For the second recursive call, since |T~|2k and by Lemma 9, we have |𝒩|2k+(k+1)k2c1k22c2k2 for constants c1 and c2. After applying all our reduction rules, by Lemma 25 for a suitable choice of c3 and c we get

|W||𝒩|+22|𝒩|+1+|𝒩|2(2|𝒩|+1+|𝒩|2)2c32|𝒩|2c322c2k2222ck2q.

Since before the reductions, we had |WU|>q, the reduced graph G also has fewer vertices than G. Therefore, this recursive call also makes progress and the recursion terminates.

Runtime.

We follow the analysis of [3]. With Lemma 26, we can test if the undirected version of G is unbreakable in time 2klogq+kn𝒪(1)222𝒪(k2)n𝒪(1). If the graph turns out to be unbreakable, the algorithm of Theorem 12 solves it in time 2𝒪(k2logq)222𝒪(k2)n𝒪(1). Executing the reduction rules takes polynomial time in n by Lemma 25.

All that is left to do is analyze the recursion. Let n|W|. By the separation property, we know that q<n<nq. From the correctness section, we get |V(G)||V(G)|n+q. Note that the recursion stops when the original graph is (q,k)-unbreakable, which must be the case if |V(G)|2q. We arrive at the recurrence

T(n)={222𝒪(k2),for n2q;(maxq<n<nqT(n+k2)+T(nn+q))+222𝒪(k2)n𝒪(1),otherwise.

Notice that 222𝒪(k2) appears in every summand of the expanded recurrence and can be ignored here and multiplied later. Furthermore, n𝒪(1) is bounded from above by a convex polynomial. Therefore, it is enough to consider the extremes of the maximum expression. For n=q+1, the first recursive call evaluates to T(q+1+k2)T(2q)222𝒪(k2). The second call only introduces an additional factor of n. For n=nq1, the second expression evaluates to T(2q+1) which is clearly also bounded by 222𝒪(k2). Thus, we arrive at the final runtime of 222𝒪(k2)n𝒪(1).

Finally, we can use Boundaried Max TSSCS to solve TSSCS. Since in our original problem every vertex could be part of the solution or its neighborhood, we initially set IO and BV(G). Furthermore, we only want to consider the boundary complementation that changes nothing, which we achieve by setting T.

Theorem 1. [Restated, see original statement.]

Total-Secluded Strongly Connected Subgraph is solvable in time 222𝒪(k2)n𝒪(1).

3 Secluded 𝓕-Free subgraph and Secluded DAG

In this section, we show that Out-Secluded -Free Subgraph is W[1]-hard for almost all choices of , even if we enforce weakly connected solutions. Except for a few missing cases, we establish a complete dichotomy when Out-Secluded -Free Weakly Connected Subgraph (Out-Secluded -Free WCS) is hard and when it is FPT. This is a surprising result compared to undirected graphs and shows that out-neighborhood behaves completely different. The same problem was studied before in undirected graphs, where it admits FPT-algorithms using recursive understanding [11] and branching on important separators [15]. For total neighborhood, both algorithms still work efficiently since the seclusion condition acts exactly the same as in undirected graphs. However, the result changes when we look at out-neighborhood, where we show hardness in Theorem 2 for almost all choices of . To formalize for which kind of the problem becomes W[1]-hard, we need one more definition.

Definition 28 (Inward Star).

We say that a directed graph G is an inward star, if there is one vertex vV(G) such that E(G)={(u,v)|uV(G){v}}, that is, the underlying undirected graph of G is a star and all edges are directed towards the center.

Due to the nature of the construction, we show that if no inward star contains any F as a subgraph, the problem becomes W[1]-hard. Besides this restriction, the statement holds for all non-empty , even families with only a single forbidden induced subgraph. Later, we explain how some other cases of can be categorized as FPT or W[1]-hard.

Theorem 2. [Restated, see original statement.]

Let be a non-empty set of directed graphs such that no F is a subgraph of an inward star. Then, Out-Secluded -Free Weakly Connected Subgraph is W[1]-hard with respect to the parameter k+w for unit weights.

Proof Sketch.

Let F. We give a reduction from Clique, inspired by [9]. Given an undirected graph G, k, and w, consider the incidence graph, which we modify in the following. We add k+2 copies of F and a single vertex s. For every edge e={u,v}E, we add the edges (e,u), (e,v), and (e,s). Furthermore, we add an edge from every vertex vVV to every vertex in every copy of F. For two different copies F1 and F2 of F, we add edges in both directions between every vertex vf1F1 and vf2 in F2. Denote this newly constructed graph by G. Finally, set kk and w(k2)+1.

The proof follows by showing that a clique of size k corresponds exactly to an out-secluded F-free weakly connected subgraph in G with parameters k and w. More details can be found in the full version [21].

Note that Theorem 2 is very general and excludes many properties Π immediately from admitting FPT-algorithms. Another interesting example is finding secluded DAGs, a very natural extension of secluded trees, studied in [11, 7]. There we choose to be the set of all directed cycles. Although this set is not finite, hardness follows from Theorem 2.

Corollary 3. [Restated, see original statement.]

Out-Secluded Weakly Connected DAG is W[1]-hard with parameter k+w for unit weights.

Finally, we analyze some of the more remaining cases in the following paragraphs.

Trivial Cases.

If contains the graph with only a single vertex, the empty set is the only -free solution. If contains two vertices connected by a single edge, weakly connected solutions can only consist of a single vertex or contain bidirectional edges (u,v) and (v,u) for u,vV(G). Both of these problems are clearly solvable in FPT-time, the second one via our algorithm for Secluded Clique. Additionally, if =, we can clearly choose the maximum weight component of G as the solution.

Independent Sets.

An independent set is a subgraph of an inward star. One kind of graph that cannot be included in such that Theorem 2 shows hardness are independent sets. Surprisingly, the problem becomes FPT if includes an independent set of any size. First, notice that independent sets that are part of can be ignored if there is a smaller independent set in . Suppose the size of the smallest independent set is α+1. This means that any solution must be an α-bounded graph, i.e., a graph without an independent set of size α.

We have shown already how these can be enumerated efficiently with the algorithm in the proof of Theorem 4. For every enumerated subgraph, we can simply check if it is -free in time ||n. Therefore, this case is also FPT with parameter k if is finite.

Theorem 29.

Let be a finite family of directed graphs that contains an independent set. Then Out-Secluded -Free WCS is solvable in time ||(2α+2)kn+α+𝒪(1).

Inward Stars.

Consider what happens when contains an inward star F with two leaves. Then, the weakly connected F-free graphs are exactly the rooted trees where the root could be a cycle instead of a single vertex, with potentially added bidirectional edges. For F, we do not have a solution, but we conjecture that the FPT branching algorithm for Secluded Tree by [7] can be transferred to the directed setting.

If ={F} for a star F with more than two leaves, the problem remains W[1]-hard. We can slightly modify the construction in the proof of Theorem 2 such that there is not one extra vertex s, but one extra vertex se for every eE(G). We connect all se internally in a directed path. A solution for Out-Secluded -Free WCS can then include the whole extra path and the edges encoding the clique. This avoids inward star structures with more than two leaves, showing hardness in this case. For only one single forbidden induced subgraph F, we therefore conjecture, that Out-Secluded -Free WCS is FPT with parameter k if and only if F has no edges or is an inward star with at most two leaves. For all other cases, we have proven W[1]-hardness with parameter k+w for unit weights.

Remaining Cases.

The previous paragraphs resolve almost all possible cases for , except for a few cases which are difficult to characterize. For example, we could have {Fs,Fp}, where Fs is an inward star and Fp is a path, which makes a new connecting construction instead of s and the se necessary. The above characterization is still enough to give an understanding of which cases are hard and which are FPT for all natural choices of .

4 Secluded Subgraphs with Small Independence Number

In this section, we consider a generalization of the undirected Secluded Clique problem to directed graphs. We generalize this property in the following way.

Definition 30 (α-Bounded).

A directed graph G is called α-bounded if G includes no independent set of size α+1, that is, for all SV(G) with |S|=α+1, the graph G[S] includes at least one edge.

Our problem of interest will be the Out-Secluded α-Bounded Subgraph problem (Out-Secluded α-BS). Note that α is part of the problem and therefore a constant. In the directed case, α=1 is analogous to the Out-Secluded Tournament problem, except that tournaments cannot include more than one edge between a pair of vertices.

In this section, we show how to solve Out-Secluded α-BS with a branching algorithm. The general nature of these branching rules allows us to transfer and optimize them, to significantly improve the best known runtime for the Secluded Clique problem to 1.6181kn𝒪(1) in the full version.

Our branching algorithm starts by selecting one part of the solution and then relies on the fact that the remaining solution has to be close around the selected part. More concretely, we start by picking an independent set that is part of the solution and build the remaining solution within its two-hop neighborhood. The following lemma justifies this strategy. The proof of this lemma was sketched on Mathematics Stack Exchange [14], we give an inspired proof again for completeness.

Lemma 31.

In every directed graph G, there is an independent set UV(G), such that every vertex in V(G)U is reachable from an uU via a path of length at most 2.

Proof.

We prove the statement by induction on |V(G)|. For |V(G)|=1, it clearly holds. Assume the statement holds for all graphs with fewer than |V(G)| vertices, we want to prove it for G. Let vV(G) be a vertex. If v reaches every other vertex via at most 2 edges, {v} is our desired independent set. Otherwise, TV(G)N+[v] is non-empty. Since |T|<|V(G)|, we can apply the induction hypothesis. So, let TT be an independent set in G[T] that reaches every vertex of T via at most two edges. We consider the edges between v and T.

Since TN+(v)=, there cannot be an edge (v,t) for any tT. If there is an edge (t,v) for some tT, then T is also a solution for G since t can reach N+[v] via at most 2 edges. Finally, if there is no edge between v and T, then T{v} is an independent set. Also T{v} reaches by definition all of TN+[v] via at most 2 edges.

For α-bounded graphs, all independent set have size at most α, so trying every subset of V(G) of size at most α allows us to find a set that plays the role of U in Lemma 31 in our solution. Hence, the first step of our algorithm will be iterate over all such sets. From then on, we only consider solutions SN+[N+[U]].

Then, our algorithm uses two branching rules. Both rules have in common that in contrast to many well-known branching algorithms [5, Chapter 3], we never include vertices into a partial solution. Instead, due to our parameter, we only decide that vertices should be part of the final neighborhood. This means that we remove the vertex from the graph and decrease the parameter by 1. Our first branching rule branches on independent sets of size α+1 in N+[N+[U]], to ensure that N+[N+[U]] becomes α-bounded. The second rule is then used to decrease the size of the neighborhood of N+[N+[U]], until it becomes secluded.

To formalize which vertices exactly to branch on, we use some new notation. For a vertex vV(G) and a vertex set UV(G), pick an arbitrary shortest path from U to v if there exists one. Define PU(v) to be the vertices on that path including v but excluding the first vertex uU. Note that after removing vertices from the graph, PU(v) might change.

Now, we can give our algorithm for finding secluded α-bounded graphs.

Theorem 4. [Restated, see original statement.]

Out-Secluded α-Bounded Subgraph is solvable in time (2α+2)knα+𝒪(1).

Proof.

Algorithm 2 The branching algorithm for Out-Secluded α-BS that returns a solution including the set UV(G).

Let (G,ω,w,k) be an instance of Out-Secluded α-BS. We guess a vertex set UV(G) that should be part of a desired solution S. Furthermore, we want to find a solution S to the instance such that SN+[N+[U]], that is, every vS should be reachable from U via at most two edges. We give a recursive branching algorithm that finds the optimal solution under these additional constraints. The algorithm is also described in Algorithm 2.

When deciding that a vertex should be part of the final neighborhood, we can simply delete it and decrease k by one. In case k decreases below 0, there is no solution. If N+[N+[U]] is a solution to the instance, we return it. Otherwise we apply the following branching rules and repeat the algorithm for all non-empty independent sets UV(G) of size at most α.

Case 1. N+[N+[U]] is not α-bounded.

In this case, there must be an independent set IN+[N+[U]] of size α+1. Clearly, not all of I can be part of the solution, so there is a vertex wIS. This means that either w or a vertex on every path from U to w must be in N+(S). The set PU(w) is one such path of length at most 2. Thus, one of wIPU(w) must be part of the out-neighborhood of S and we branch on all of these vertices. For one vertex, delete it and decrease k by 1.

Case 2. N+[N+[U]] is α-bounded, but has additional neighbors.

Consider one of these neighbors wN+(N+[N+[U]]). Since w is not reachable from U via at most two edges, we should not include it in the solution. Now, PU(w) is a path of length 3, and one of its vertices must be in N+(S). We again branch on all options, delete the corresponding vertex and decrease k by 1.

By Lemma 31, there is a suitable choice of U for every solution. Therefore, if we can find the maximum solution containing U if one exists in every iteration with our branching algorithm, the total algorithm is correct. Also notice that the branching rules are a complete case distinction; if none of the rules apply, the algorithm reaches a base case. The remaining proof of correctness follows from a simple induction.

We initially have to consider all subsets of V(G) of size at most α while rejecting subsets that are not an independent set in time nα+1. To bound the runtime of the branching algorithm, notice that in each case we branch and make progress decreasing k by 1. In the first cases, the independent set I has size α+1 for every wI, the path PU(w) includes at most 2 vertices. Hence, there are at most 2(α+1) branches in this case. The second case gives exactly 3 branches and is thus dominated by the first rule. This gives the claimed runtime and concludes the proof.

References

  • [1] Shiri Chechik, Matthew P Johnson, Merav Parter, and David Peleg. Secluded connectivity problems. Algorithmica, 79:708–741, 2017. doi:10.1007/s00453-016-0222-z.
  • [2] Jianer Chen, Yang Liu, Songjian Lu, Barry O’sullivan, and Igor Razgon. A fixed-parameter algorithm for the directed feedback vertex set problem. Journal of the ACM, 55:1–19, 2008. doi:10.1145/1411509.1411511.
  • [3] Rajesh Chitnis, Marek Cygan, Mohammad Taghi Hajiaghayi, Marcin Pilipczuk, and Michał Pilipczuk. Designing fpt algorithms for cut problems using randomized contractions. SIAM Journal on Computing, 45:1171–1229, 2016. doi:10.1137/15M1032077.
  • [4] Rajesh Chitnis, MohammadTaghi Hajiaghayi, and Dániel Marx. Fixed-parameter tractability of directed multiway cut parameterized by the size of the cutset. SIAM Journal on Computing, 42:1674–1696, 2013. doi:10.1137/12086217X.
  • [5] Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, Dániel Marx, Marcin Pilipczuk, Michal Pilipczuk, and Saket Saurabh. Parameterized Algorithms. Springer, 2015. doi:10.1007/978-3-319-21275-3.
  • [6] Marek Cygan, Daniel Lokshtanov, Marcin Pilipczuk, Michał Pilipczuk, and Saket Saurabh. Minimum bisection is fixed-parameter tractable. SIAM Journal on Computing, 48:417–450, 2019. doi:10.1137/140988553.
  • [7] Huib Donkers, Bart M.P. Jansen, and Jari J.H. de Kroon. Finding k-secluded trees faster. Journal of Computer and System Sciences, 138:103461, 2023. doi:10.1016/j.jcss.2023.05.006.
  • [8] Fedor V. Fomin, Petr A. Golovach, Nikolay Karpov, and Alexander S. Kulikov. Parameterized complexity of secluded connectivity problems. Theory of Computing Systems, 61:795–819, 2017. doi:10.1007/s00224-016-9717-x.
  • [9] Fedor V Fomin, Petr A Golovach, and Janne H Korhonen. On the parameterized complexity of cutting a few vertices from a graph. In Mathematical Foundations of Computer Science, pages 421–432, 2013. doi:10.1007/978-3-642-40313-2_38.
  • [10] Alexandra Fradkin and Paul Seymour. Edge-disjoint paths in digraphs with bounded independence number. Journal of Combinatorial Theory, Series B, 110:19–46, 2015. doi:10.1016/j.jctb.2014.07.002.
  • [11] Petr A. Golovach, Pinar Heggernes, Paloma T. Lima, and Pedro Montealegre. Finding connected secluded subgraphs. Journal of Computer and System Sciences, 113:101–124, 2020. doi:10.1016/j.jcss.2020.05.006.
  • [12] Martin Grohe, Ken-ichi Kawarabayashi, Dániel Marx, and Paul Wollan. Finding topological subgraphs is fixed-parameter tractable. In Proceedings of the Forty-Third Annual ACM Symposium on Theory of Computing (STOC 2011), pages 479–488, 2011. doi:10.1145/1993636.1993700.
  • [13] Meike Hatzel, Lars Jaffke, Paloma T Lima, Tomáš Masařík, Marcin Pilipczuk, Roohani Sharma, and Manuel Sorge. Fixed-parameter tractability of directed multicut with three terminal pairs parameterized by the size of the cutset: twin-width meets flow-augmentation. In Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 3229–3244, 2023. doi:10.1137/1.9781611977554.ch123.
  • [14] Sera Gunn (https://math.stackexchange.com/users/437127/sera gunn). Independent set of vertices in a directed graph. Mathematics Stack Exchange, 2017. URL: https://math.stackexchange.com/q/2292101.
  • [15] Bart M. P. Jansen, Jari J. H. de Kroon, and Michał Włodarczyk. Single-exponential FPT algorithms for enumerating secluded f-free subgraphs and deleting to scattered graph classes. In 34th International Symposium on Algorithms and Computation (ISAAC 2023), pages 42:1–42:18, 2023. doi:10.4230/LIPIcs.ISAAC.2023.42.
  • [16] Daniel Lokshtanov, M. S. Ramanujan, Saket Saurabh, and Meirav Zehavi. Reducing CMSO Model Checking to Highly Connected Graphs. In 45th International Colloquium on Automata, Languages, and Programming (ICALP 2018), volume 107, pages 135:1–135:14, 2018. doi:10.4230/LIPIcs.ICALP.2018.135.
  • [17] Max-Jonathan Luckow and Till Fluschnik. On the computational complexity of length-and neighborhood-constrained path problems. Information Processing Letters, 156:105913, 2020. doi:10.1016/j.ipl.2019.105913.
  • [18] Pranabendu Misra, Saket Saurabh, Roohani Sharma, and Meirav Zehavi. Sub-exponential time parameterized algorithms for graph layout problems on digraphs with bounded independence number. Algorithmica, 85:2065–2086, 2023. doi:10.1007/s00453-022-01093-w.
  • [19] Marcin Pilipczuk and Magnus Wahlström. Directed multicut is W[1]-hard, even for four terminal pairs. ACM Transactions on Computation Theory, 10:1–18, 2018. doi:10.1145/3201775.
  • [20] Abhishek Sahu and Saket Saurabh. Kernelization of arc disjoint cycle packing in α-bounded digraphs. Theory of Computing Systems, 67:221–233, 2023. doi:10.1007/s00224-022-10114-8.
  • [21] Jonas Schmidt, Shaily Verma, and Nadym Mallek. A parameterized study of secluded structures in directed graphs. arXiv preprint arXiv:2502.06048, 2025. doi:10.48550/arXiv.2502.06048.
  • [22] René van Bevern, Till Fluschnik, George B. Mertzios, Hendrik Molter, Manuel Sorge, and Ondřej Suchý. The parameterized complexity of finding secluded solutions to some classical optimization problems on graphs. Discrete Optimization, 30:20–50, 2018. doi:10.1016/j.disopt.2018.05.002.
  • [23] René van Bevern, Till Fluschnik, and Oxana Yu Tsidulko. Parameterized algorithms and data reduction for the short secluded s-t-path problem. Networks, 75(1):34–63, 2020. doi:10.1002/NET.21904.