arXiv subjects

Nils Morawietz

Publications and source records attributed to Nils Morawietz.

At least 19 recordsLinked to original sources

arXiv2026

Scalable Neighborhood Local Search for Single-Machine Scheduling with Family Setup Times

In this work, we study the task of scheduling jobs on a single machine with sequence dependent family setup times under the goal of minimizing the makespan, that is, the completion time of the last job in the schedule. This notoriously NP-hard problem is highly relevant in practical productions and requires heuristics that provide good solutions quickly in order to deal with large instances. In this paper, we present a heuristic based on the approach of parameterized local search. That is, we aim to replace a given solution by a better solution having distance at most $k$ in a pre-defined distance measure. This is done multiple times in a hill-climbing manner, until a locally optimal solution is reached. We analyze the trade-off between the allowed distance $k$ and the algorithm's running time for four natural distance measures. Example of allowed operations for our considered distance measures are: swapping $k$ pairs of jobs in the sequence, or rearranging $k$ consecutive jobs. For two distance measures, we show that finding an improvement for given $k$ can be done in $f(k) \cdot n^{\mathcal{O}(1)}$ time, while such a running time for the other two distance measures is unlikely. We provide a preliminary experimental evaluation of our local search approaches.

cs.DS↗

arXiv2026

The Parameter Report: An Orientation Guide for Data-Driven Parameterization

A strength of parameterized algorithmics is that each problem can be parameterized by an essentially inexhaustible set of parameters. Usually, the choice of the considered parameter is informed by the theoretical relations between parameters with the general goal of achieving FPT-algorithms for smaller and smaller parameters. However, the FPT-algorithms for smaller parameters usually have higher running times and it is unclear whether the decrease in the parameter value or the increase in the running time bound dominates in real-world data. This question cannot be answered from purely theoretical considerations and any answer requires knowledge on typical parameter values. To provide a data-driven guideline for parameterized complexity studies of graph problems, we present the first comprehensive comparison of parameter values for a set of benchmark graphs originating from real-world applications. Our study covers degree-related parameters, such as maximum degree or degeneracy, neighborhood-based parameters such as neighborhood diversity and modular-width, modulator-based parameters such as vertex cover number and feedback vertex set number, and the treewidth of the graphs. Our results may help assess the significance of FPT-running time bounds on the solvability of real-world instances. For example, the vertex cover number $vc$ of $n$-vertex graphs is often only slightly below $n/2$. Thus, a running time bound of $O(2^{vc})$ is only slightly better than a running time bound of $O(1.4^{n})$. In contrast, the treewidth $tw$ is almost always below $n/3$ and often close to $n/10$, making a running time of $O(2^{tw})$ much more practical on real-world instances. We make our implementation and full experimental data openly available. In particular, this provides the first implementations for several graph parameters such as 4-path vertex cover number and vertex integrity.

cs.CC↗

arXiv2026

On the Hardness of Finding Temporally Connected Subgraphs of Any Size

Temporal graphs are graphs whose edges are present only at certain points in time. Reachability in these graphs is defined via temporal paths, in which edges are traversed in chronological order. A temporal graph is temporally connected (or TC) if every ordered pair of vertices is connected by a temporal path. When the graph itself is not TC, a natural question is whether it admits a TC subgraph (a.k.a.~closed temporal component) of a given size $k$. This question was one of the earliest and most studied in the field, shown to be NP-hard by Bhadra and Ferreira in 2003. We strengthen this result dramatically, showing that deciding if a temporal graph admits a TC subgraph \emph{of any size} (beyond the trivial case of a single vertex in the directed and a single edge in the undirected case) is already NP-hard. Our result holds for all standard temporal graph settings, answering a series of open questions in the field and strengthening several existing results. This sharply separates closed components from open ones (where temporal paths can travel outside the component), for which the analogous problem is trivially solvable in polynomial time. More precisely, our reductions imply that the size of the largest TC subgraph cannot even be approximated within a factor of~$(1-ε)n$ in directed graphs, and within a factor of~$(1-ε)\frac{n}{2}$ in undirected graphs. They also complete the complexity landscape for TC subgraphs of size exactly $k$ when parameterized by $k$ (answering the missing ``non-strict'' case). Our results also have structural implications. In particular, they imply that there exist arbitrarily large TC graphs without nontrivial TC subgraphs, and that there exist TC graphs of arbitrary girth, both facts being of independent interest.

cs.CC↗

arXiv2026

Freeze-Tag with Return

In the standard Freeze-Tag Problem (FTP), an initially awake robot (the source) is in charge of waking up a swarm of sleeping robots by moving towards them, given that all the awake robots can participate in the awakening process. The goal is to minimize the makespan to wake up all robots assuming they move at unit speed. In this paper we introduce the Freeze-Tag-with-Return Problem (FTRP) variant, where the robots must eventually return to their initial positions. In the Euclidean plane with $n$ sleeping robots lying on the unit disk centered at the initial position of the source, we show a non-trivial relationship between FTP and FTRP by proving that the difference between the optimal makespan of both problems never exceeds $1.959$, and is at least $1.732$ in the worst-case. We also present several upper and lower bounds on the optimal makespan. In particular, we show that if the sleeping robots are in convex positions, then the optimal makespan is at most $2 + 2\sqrt{2}$, which is achieved by some instances. From an algorithmic point-of-view, we present single-exponential algorithms for general distance functions. In metric spaces, these algorithms are asymptotically optimal under the ETH, which we show via an NP-hardness reduction on unweighted graphs.

cs.DS↗

arXiv2026

Towards Settling the Complexity of the Lettericity Problem

The lettericity of a graph $G=(V,E)$ is defined as the smallest size of an alphabet $Σ$ such that there is a word $w_1 \dots w_{|V|} \in Σ^*$ and a decoder $\mathcal{D} \subseteq Σ^2$ with the property that $G$ is isomorphic to the letter graph $G(\mathcal{D}, w)$, that is, the graph with vertex set $\{1, \dots, n\}$ and edge set $\{ij \mid 1\leq i < j \leq n, w_iw_j \in \mathcal{D}\}$. Note that $G(\mathcal{D}, w)$ can be seen as a graph with inherent coloring $χ\colon V(G) \rightarrow Σ$. It is unknown whether the lettericity of a given graph can be computed in polynomial time. The problem to determine the lettericity of a given graph is called the lettericity problem. As a step towards answering the complexity of this problem, we investigate the following retrieval problems: given a graph $G$ together with two of the three solution-objects (word $w$, decoder $\mathcal{D}$, and coloring $χ$), the goal is to compute the third solution-object. We show that word retrieval and decoder retrieval are solvable in polynomial time, while coloring retrieval is equivalent to the graph isomorphism problem. Beyond this, we introduce symmetric lettericity which is a restricted version of lettericity where each decoder needs to be symmetrical ($ab\in \mathcal{D}$ if and only if $ba\in \mathcal{D}$). As we show, the symmetric lettericity of a graph always equals the neighborhood diversity of the graph, which in fact can be computed in linear time.

cs.DS↗

arXiv2026

Parameterized Local Search for Vertex Cover: When only the Search Radius is Crucial

A vertex set $W$ in a graph $G$ is a valid $k$-swap for a vertex cover $S$ of $G$ if $W$ has size at most $k$ and $S'=(S \setminus W) \cup (W \setminus S)$, the symmetric difference of $S$ and $W$, is a vertex cover of $G$. If $|S'| < |S|$, then $W$ is improving. In LS Vertex Cover, one is given a vertex cover $S$ of a graph $G$ and wants to know if there is a valid improving $k$-swap for $S$ in $G$. In applications of LS Vertex Cover, $k$ is a very small parameter that can be set by a user to determine the trade-off between running time and solution quality. Consequently, $k$ can be considered to be a constant. Motivated by this and the fact that LS Vertex Cover is W[1]-hard with respect to $k$, we aim for algorithms with running time $\ell^{f(k)}\cdot n^{\mathcal{O}(1)}$ where $\ell$ is a structural graph parameter upper-bounded by $n$. We say that such a running time grows mildly with respect to $\ell$ and strongly with respect to $k$. We obtain algorithms with such a running time for $\ell$ being the $h$-index of $G$, the treewidth of $G$, or the modular-width of $G$. In addition, we consider a novel parameter, the maximum degree over all quotient graphs in a modular decomposition of $G$. Moreover, we adapt these algorithms to the more general problem where each vertex is assigned a weight and where we want to find a valid $d$-improving $k$-swap, that is, a valid $k$-swap which decreases the weight of the vertex cover by at least $d$.

cs.DS↗

arXiv2026

Realization of Temporally Connected Graphs Based on Degree Sequences

Given an undirected graph $G$, the problem of deciding whether $G$ admits a simple and proper time-labeling that makes it temporally connected is known to be NP-hard (Göbel et al., 1991). In this article, we relax this problem and ask whether a given degree sequence can be realized as a temporally connected graph. Our main results are a complete characterization of the feasible cases, and a recognition algorithm that runs in $O(n)$ time for graphical degree sequences (realized as simple temporal graphs) and in $O(n+m)$ time for multigraphical degree sequences (realized as non-simple temporal graphs, where the number of time labels on an edge corresponds to the multiplicity of the edge in the multigraph). In fact, these algorithms can be made constructive at essentially no cost. Namely, we give a constructive $O(n+m)$ time algorithm that outputs, for a given (multi)graphical degree sequence $\mathbf{d}$, a temporally connected graph whose underlying (multi)graph is a realization of $\mathbf{d}$, if one exists.

cs.DS↗

arXiv2026

Fantastic Flips and Where to Find Them: A General Framework for Parameterized Local Search on Partitioning Problems

Parameterized local search combines classic local search heuristics with the paradigm of parameterized algorithmics. While most local search algorithms aim to improve given solutions by performing one single operation on a given solution, the parameterized approach aims to improve a solution by performing $k$ simultaneous operations. Herein, $k$ is a parameter called search radius for which the value can be chosen by a user. One major goal in the field of parameterized local search is to outline the trade-off between the size of $k$ and the running time of the local search step. In this work, we introduce an abstract framework that generalizes natural parameterized local search approaches for a large class of partitioning problems: Given $n$ items that are partitioned into $b$ bins and a target function that evaluates the quality of the current partition, one asks whether it is possible to improve the solution by removing up to $k$ items from their current bins and reassigning them to other bins. Among others, our framework applies for the local search versions of problems like Cluster Editing, Vector Bin Packing, and Nash Social Welfare. Motivated by a real-world application of the problem Vector Bin Packing, we introduce a parameter called number of types $τ\le n$ and show that all problems fitting in our framework can be solved in $τ^k 2^{O(k)} |I|^{O(1)}$ time, where $|I|$ denotes the total input size. In case of Cluster Editing, the parameter $τ$ generalizes the well-known parameter neighborhood diversity of the input graph. We complement this by showing that for all considered problems, an algorithm significantly improving over our algorithm with running time $τ^k 2^{O(k)} |I|^{O(1)}$ would contradict the ETH. Additionally, we show that even on very restricted instances, all considered problems are W[1]-hard when parameterized by the search radius $k$ alone.

cs.DS↗

arXiv2026

In search of the lost tree: Hardness and relaxation of spanning trees in temporal graphs

A temporal graph is a graph whose edges appear at certain points in time. These graphs are temporally connected (in class TC) if all vertices can reach each other by temporal paths (traversing the edges in chronological order). Reachability based on temporal paths is not transitive, with important consequences. For instance, TC graphs do not always admit TC spanning trees. In this paper, we show that deciding if a given temporal graph admits a TC spanning tree is actually NP-complete. Then, we explore possible relaxations. A key feature of TC spanning trees is to support reachability along the same paths in both directions. We show that this property is not equivalent to TC spanning trees, it is more general and it can be tested in polynomial time. Still, minimizing the size of a spanner preserving this property -- a bidirectional spanner -- is \textsf{NP}-hard even more generally than TC spanning tree, including the setting of simple temporal graphs. Along the way, we show that deciding the existence of TC spanning tree is FPT when parameterized by the feedback edge set number (fes) of the underlying graph, and deciding bidirectional spanners of size $k$ is FPT when parameterized by fes + $\ell$ (the maximum number of labels per edge). On the structural side, we show that TC trees always admit a pivot vertex or a pivot edge -- reachable by all vertices by a certain time and able to reach all vertices afterward -- a fact that may be of independent interest.

cs.DM↗

arXiv2026

The Descriptive Complexity of Relation Modification Problems

A relation modification problem gets a logical structure and a natural number k as input and asks whether k modifications of the structure suffice to make it satisfy a predefined property. We provide a complete classification of the classical and parameterized complexity of relation modification problems - the latter w. r. t. the modification budget k - based on the descriptive complexity of the respective target property. We consider different types of logical structures on which modifications are performed: Whereas monadic structures and undirected graphs without self-loops each yield their own complexity landscapes, we find that modifying undirected graphs with self-loops, directed graphs, or arbitrary logical structures is equally hard w. r. t. quantifier patterns. Moreover, we observe that all classes of problems considered in this paper are subject to a strong dichotomy in the sense that they are either very easy to solve (that is, they lie in paraAC^{0\uparrow} or TC^0) or intractable (that is, they contain W[2]-hard or NP-hard problems).

cs.LO↗

arXiv2026

A Parameterized-Complexity Framework for Finding Local Optima

Local search is a fundamental optimization technique that is both widely used in practice and deeply studied in theory, yet its computational complexity remains poorly understood. The traditional frameworks, PLS and the standard algorithm problem, introduced by Johnson, Papadimitriou, and Yannakakis (1988) fail to capture the methodology of local search algorithms: PLS is concerned with finding a local optimum and not with using local search, while the standard algorithm problem restricts each improvement step to follow a fixed pivoting rule. In this work, we introduce a novel formulation of local search which provides a middle ground between these models. In particular, the task is to output not only a local optimum but also a chain of local improvements leading to it. With this framework, we aim to capture the challenge in designing a good pivoting rule. Especially, when combined with the parameterized complexity paradigm, it enables both strong lower bounds and meaningful tractability results. Unlike previous works that combined parameterized complexity with local search, our framework targets the whole task of finding a local optimum and not only a single improvement step. Focusing on two representative meta-problems -- Subset Weight Optimization Problem with the $c$-swap neighborhood and Weighted Circuit with the flip neighborhood -- we establish fixed-parameter tractability results related to the number of distinct weights, while ruling out an analogous result when parameterized by the distance to the nearest optimum via a new type of reduction.

cs.CC↗

arXiv2025

Timeline Problems in Temporal Graphs: Vertex Cover vs. Dominating Set

A temporal graph is a finite sequence of graphs, called snapshots, over the same vertex set. Many temporal graph problems turn out to be much more difficult than their static counterparts. One such problem is \textsc{Timeline Vertex Cover} (also known as \textsc{MinTimeline$_\infty$}), a temporal analogue to the classical \textsc{Vertex Cover} problem. In this problem, one is given a temporal graph $\mathcal{G}$ and two integers $k$ and $\ell$, and the goal is to cover each edge of each snapshot by selecting for each vertex at most $k$ activity intervals of length at most $\ell$ each. Here, an edge $uv$ in the $i$th snapshot is covered, if an activity interval of $u$ or $v$ is active at time $i$. In this work, we continue the algorithmic study of \textsc{Timeline Vertex Cover} and introduce the \textsc{Timeline Dominating Set} problem where we want to dominate all vertices in each snapshot by the selected activity intervals. We analyze both problems from a classical and parameterized point of view and also consider partial problem versions, where the goal is to cover (dominate) at least $t$ edges (vertices) of the snapshots. With respect to the parameterized complexity, we consider the temporal graph parameters vertex-interval-membership-width $(vimw)$ and interval-membership-width $(imw)$. We show that all considered problems admit FPT-algorithms when parameterized by $vimw + k+\ell$. This provides a smaller parameter combination than the ones used for previously known FPT-algorithms for \textsc{Timeline Vertex Cover}. Surprisingly, for $imw+ k+\ell$, \textsc{Timeline Dominating Set} turns out to be easier than \textsc{Timeline Vertex Cover}, by also admitting an FPT-algorithm, whereas the vertex cover version is NP-hard even if $imw+\, k+\ell$ is constant. We also consider parameterization by combinations of $n$, the vertex set size, with $k$ or $\ell$ and parameterization by $t$.

cs.DS↗

arXiv2025

Foremost, Fastest, Shortest: Temporal Graph Realization under Various Path Metrics

In this work, we follow the current trend on temporal graph realization, where one is given a property P and the goal is to determine whether there is a temporal graph, that is, a graph where the edge set changes over time, with property P . We consider the problems where as property P , we are given a prescribed matrix for the duration, length, or earliest arrival time of pairwise temporal paths. That is, we are given a matrix D and ask whether there is a temporal graph such that for any ordered pair of vertices (s, t), Ds,t equals the duration (length, or earliest arrival time, respectively) of any temporal path from s to t minimizing that specific temporal path metric. For shortest and earliest arrival temporal paths, we are the first to consider these problems as far as we know. We analyze these problems for many settings like: strict and non-strict paths, periodic and non-periodic temporal graphs, and limited number of labels per edge (that is, limited occurrence number per edge over time). In contrast to all other path metrics, we show that for the earliest arrival times, we can achieve polynomial-time algorithms in periodic and non-periodic temporal graphs and for strict and and non-strict paths. However, the problem becomes NP-hard when the matrix does not contain a single integer but a set or range of possible allowed values. As we show, the problem can still be solved efficiently in this scenario, when the number of entries with more than one value is small, that is, we develop an FPT-algorithm for the number of such entries. For the setting of fastest paths, we achieve new hardness results that answers an open question by Klobas, Mertzios, Molter, and Spirakis [Theor. Comput. Sci. '25] about the parameterized complexity of the problem with respect to the vertex cover number and significantly improves over a previous hardness result for the feedback vertex set number. When considering shortest paths, we show that the periodic versions are polynomial-time solvable whereas the non-periodic versions become NP-hard.

cs.DS↗

arXiv2025

Complexity of Local Search for Euclidean Clustering Problems

We show that the simplest local search heuristics for two natural Euclidean clustering problems are PLS-complete. First, we show that the Hartigan--Wong method for $k$-Means clustering is PLS-complete, even when $k = 2$. Second, we show the same result for the Flip heuristic for Max Cut, even when the edge weights are given by the (squared) Euclidean distances between the points in some set $\mathcal{X} \subseteq \mathbb{R}^d$; a problem which is equivalent to Min Sum 2-Clustering.

cs.CC↗

arXiv2025

Realizing temporal transportation trees

In this paper, we study the complexity of the periodic temporal graph realization problem with respect to upper bounds on the fastest path durations among its vertices. This constraint with respect to upper bounds appears naturally in transportation network design applications where, for example, a road network is given, and the goal is to appropriately schedule periodic travel routes, while not exceeding some desired upper bounds on the travel times. In our work, we focus only on underlying tree topologies, which are fundamental in many transportation network applications. As it turns out, the periodic upper-bounded temporal tree realization problem (TTR) has a very different computational complexity behavior than both (i) the classic graph realization problem with respect to shortest path distances in static graphs and (ii) the periodic temporal graph realization problem with exact given fastest travel times (which was recently introduced). First, we prove that, surprisingly, TTR is NP-hard, even for a constant period $Δ$ and when the input tree $G$ satisfies at least one of the following conditions: (a) $G$ is a star, or (b) $G$ has constant maximum degree. Second, we prove that TTR is fixed-parameter tractable (FPT) with respect to the number of leaves in the input tree $G$, via a novel combination of techniques for totally unimodular matrices and mixed integer linear programming.

cs.DS↗

arXiv2025

Temporal Graph Realization With Bounded Stretch

A periodic temporal graph, in its simplest form, is a graph in which every edge appears exactly once in the first $Δ$ time steps, and then it reappears recurrently every $Δ$ time steps, where $Δ$ is a given period length. This model offers a natural abstraction of transportation networks where each transportation link connects two destinations periodically. From a network design perspective, a crucial task is to assign the time-labels on the edges in a way that optimizes some criterion. In this paper we introduce a very natural optimality criterion that captures how the temporal distances of all vertex pairs are `stretched', compared to their physical distances, i.e. their distances in the underlying static (non-temporal) graph. Given a static graph $G$, the task is to assign to each edge one time-label between 1 and $Δ$ such that, in the resulting periodic temporal graph with period~$Δ$, the duration of the fastest temporal path from any vertex $u$ to any other vertex $v$ is at most $α$ times the distance between $u$ and $v$ in $G$. Here, the value of $α$ measures how much the shortest paths are allowed to be \emph{stretched} once we assign the periodic time-labels. Our results span three different directions: First, we provide a series of approximation and NP-hardness results. Second, we provide approximation and fixed-parameter algorithms. Among them, we provide a simple polynomial-time algorithm (the \textit{radius-algorithm}) which always guarantees an approximation strictly smaller than $Δ$, and which also computes the optimum stretch in some cases. Third, we consider a parameterized local search extension of the problem where we are given the temporal labeling of the graph, but we are allowed to change the time-labels of at most $k$ edges; for this problem we prove that it is W[2]-hard but admits an XP algorithm with respect to $k$.

cs.DS↗

arXiv2025

Recognizing and Realizing Temporal Reachability Graphs

A temporal graph $\mathcal{G}=(G,λ)$ can be represented by an underlying graph $G=(V,E)$ together with a function $λ$ that assigns to each edge $e\in E$ the set of time steps during which $e$ is present. The reachability graph of $\mathcal{G}$ is the directed graph $D=(V,A)$ with $(u,v)\in A$ if only if there is a temporal path from $u$ to $v$. We study the Reachability Graph Realizability (RGR) problem that asks whether a given directed graph $D=(V,A)$ is the reachability graph of some temporal graph. The question can be asked for undirected or directed temporal graphs, for reachability defined via strict or non-strict temporal paths, and with or without restrictions on $λ$ (proper, simple, or happy). Answering an open question posed by Casteigts et al. (Theoretical Computer Science 991 (2024)), we show that all variants of the problem are NP-complete, except for two variants that become trivial in the directed case. For undirected temporal graphs, we consider the complexity of the problem with respect to the solid graph, that is, the graph containing all edges that could potentially receive a label in any realization. We show that the RGR problem is polynomial-time solvable if the solid graph is a tree and fixed-parameter tractable with respect to the feedback edge set number of the solid graph. As we show, the latter parameter can presumably not be replaced by smaller parameters like feedback vertex set or treedepth, since the problem is W[2]-hard with respect to these parameters.

cs.CC↗

arXiv2024

Parameterized Local Search for Max $c$-Cut

In the NP-hard Max $c$-Cut problem, one is given an undirected edge-weighted graph $G$ and aims to color the vertices of $G$ with $c$ colors such that the total weight of edges with distinctly colored endpoints is maximal. The case with $c=2$ is the famous Max Cut problem. To deal with the NP-hardness of this problem, we study parameterized local search algorithms. More precisely, we study LS Max $c$-Cut where we are also given a vertex coloring and an integer $k$ and the task is to find a better coloring that changes the color of at most $k$ vertices, if such a coloring exists; otherwise, the given coloring is $k$-optimal. We show that, for all $c\ge 2$, LS Max $c$-Cut presumably cannot be solved in $f(k)\cdot n^{\mathcal{O}(1)}$ time even on bipartite graphs. We then present an algorithm for LS Max $c$-Cut with running time $\mathcal{O}((3eΔ)^k\cdot c\cdot k^3\cdotΔ\cdot n)$, where $Δ$ is the maximum degree of the input graph. Finally, we evaluate the practical performance of this algorithm in a hill-climbing approach as a post-processing for a state-of-the-art heuristic for Max $c$-Cut. We show that using parameterized local search, the results of this state-of-the-art heuristic can be further improved on a set of standard benchmark instances.

cs.CC↗