arXiv subjects

Brendan Mumey

Publications and source records attributed to Brendan Mumey.

18 recordsLinked to original sources

arXiv2026

Approximation Algorithms for Perfect Fair-Triangle Packing

In this paper, we study the {\em perfect fair-triangle packing} problem (abbreviated as PFTP), which incorporates the fairness criterion from {\em fair clustering} into the {\em maximum-weight triangle packing} problem. Specifically, the input is an edge-weighted complete graph $G = (V, E)$ with $|V| = 3n$, where each vertex is colored red or blue. A {\em fair triangle} is a triangle containing vertices of both colors. PFTP asks for a partition of $V$ into $n$ fair triangles such that the total edge weight is maximized. To the best of our knowledge, this is the first paper to study PFTP. PFTP is NP-hard. Our main contributions are a deterministic $\frac 13$-approximation algorithm running in $O(n^3)$ time and an improved randomized $(\frac {16}{47}-ε)$-approximation algorithm running in $O(n^4)$ time, where $ε> 0$ is a fixed small constant. The deterministic algorithm is matching-based whereas the randomized algorithm employs several additional techniques, including maximum-weight $[1, 2]$-factor, a random cycle-breaking procedure, and maximum-weight matchings. Keywords: Triangle packing; fairness; approximation algorithms; randomized algorithms

cs.DS↗

arXiv2026

Parametric Shortest Paths in a Linearly Interpolated Graph

We consider the parametric shortest paths problem in a linearly interpolated graph. Given two positively-weighted directed graphs $G_0=(V,E,ω_0)$ and $G_1=(V,E,ω_1),$ the linearly interpolated graph is the family of graphs $(1-λ)G_0+λG_1$, parameterized by $λ\in [0,1]$. The problem is to compute all distinct parametric shortest paths. We compute a data structure in $Θ(k|E|\log |V|)$ time, where~$k$ is the number of distinct parametric shortest paths over all~$λ\in [0,1]$ that exist for a nontrivial interval of parameters, each corresponding to a linear function in a maximal sub-interval of $[0,1]$. Using this data structure, a shortest path query takes~$Θ(\log k)$ time.

cs.CG↗

arXiv2026

Offline green bin packing and its constrained variant

In this paper, we study the {\em green bin packing} (GBP) problem where $β\ge 0$ and $G \in [0, 1]$ are two given values as part of the input. The energy consumed by a bin is $\max \{0, β(x-G) \}$ where $x$ is the total size of the items packed into the bin. The GBP aims to pack all items into a set of unit-capacity bins so that the number of bins used plus the total energy consumption is minimized. When $β= 0$ or $G = 1$, GBP is reduced to the classic bin packing (BP) problem. In the {\em constrained green bin packing} (CGBP) problem, the objective is to minimize the number of bins used to pack all items while the total energy consumption does not exceed a given upper bound $U$. We present an APTAS and a $\frac 32$-approximation algorithm for both GBP and CGBP, where the ratio $\frac 32$ matches the lower bound of BP. Keywords: Green bin packing; constrained green bin packing; approximation scheme; offline algorithms

cs.DS↗

arXiv2026

Fast Order Statistics with Group Inequality Testing

Suppose that a group test operation is available for checking order relations in a set, can this speed up problems like finding the minimum/maximum element, determining the rank of element, and computing order statistics? We consider a one-sided group inequality test to be available, where queries are of the form $u \le_Q V$ or $V \le_Q u$, and the answer is `yes' if and only if there is some $v \in V$ such that $u \le v$ or $v \le u$, respectively. We restrict attention to total orders and focus on query-complexity; for min or max finding, we give a Las Vegas algorithm that makes $\mathcal{O}(\log^2 n)$ expected queries. We observe that rank determination can be solved with existing ``defect-counting'' algorithms, but also give a simple Monte Carlo approximation algorithm with expected query complexity $\tilde{\mathcal{O}}(\frac{1}{δ^2} \log \frac{1}ε)$, where $1-ε$ is the probability that the algorithm succeeds and we allow a relative error of $1 \pm δ$ for $δ> 0$ in the estimated rank. We then give a Monte Carlo algorithm for approximate selection that has expected query complexity $\tilde{\mathcal{O}}(\frac{1}{δ^4}\log \frac{1}{εδ^2} )$; it has probability at least $\frac{1}{2}$ to output an element $x$, and if so, $x$ has the desired approximate rank with probability $1-ε$. Keywords: Order statistics, Group inequality testing, Randomized algorithms

cs.DS↗

arXiv2026

Approximately Partitioning Vertices into Short Paths

Given a fixed positive integer $k$ and a simple undirected graph $G = (V, E)$, the {\em $k^-$-path partition} problem, denoted by $k$PP for short, aims to find a minimum collection $\cal{P}$ of vertex-disjoint paths in $G$ such that each path in $\cal{P}$ has at most $k$ vertices and each vertex of $G$ appears in one path in $\cal{P}$. In this paper, we present a $\frac {k+4}5$-approximation algorithm for $k$PP when $k\in\{9,10\}$ and an improved $(\frac{\sqrt{11}-2}7 k + \frac {9-\sqrt{11}}7)$-approximation algorithm when $k \ge 11$. Our algorithms achieve the current best approximation ratios for $k \in \{ 9, 10, \ldots, 18 \}$. Our algorithms start with a maximum triangle-free path-cycle cover $\cal{F}$, which may not be feasible because of the existence of cycles or paths with more than $k$ vertices. We connect as many cycles in $\cal{F}$ with $4$ or $5$ vertices as possible by computing another maximum-weight path-cycle cover in a suitably constructed graph so that $\cal{F}$ can be transformed into a $k^-$-path partition of $G$ without losing too many edges. Keywords: $k^-$-path partition; Triangle-free path-cycle cover; $[f, g]$-factor; Approximation algorithm

cs.DS↗

arXiv2026

Approximation algorithms for scheduling with rejection in green manufacturing

Motivated by green manufacturing, this paper investigates a scheduling with rejection problem subject to an energy consumption constraint. Machines are associated with non-uniform energy consumption rates, defined as the energy consumed per unit time. Each job is either rejected with a rejection penalty or accepted and scheduled on some machine for processing, which incurs energy consumption. The problem aims to minimize the makespan of the accepted jobs plus the total penalty of the rejected jobs while the total energy consumption is bounded by a given threshold. In this paper, when the number of machines is part of the input, we develop the first $(2+ε)$-approximation algorithm for any fixed constant $ε$ and a simple QPTAS as well as a PTAS for uniform energy consumption rates. Moreover, we present an FPTAS when the number of machines is a fixed constant.

cs.DS↗

arXiv2025

Width Parameters for Minimum Flow Decomposition

Minimum flow decomposition (MFD) is the strongly NP-hard problem of finding a smallest set of integer weighted $s$-$t$ paths in an $s$-$t$ DAG $G$ whose weighted sum is equal to a given flow $f$ on $G$. Despite its many practical applications, we lack an understanding of graph structures that make MFD easy or hard. Recent progress is due to Cáceres et al. [ACM TALG 2024], who showed that the DAG width, the minimum number of paths to cover all edges, plays an essential role in the approximation of the problem. Our first set of results regard the computational complexity of MFD parameterised by the width. This question was previously open, because MFD on width-1 DAGs (paths) is trivially solvable, and the existing NP-hardness proofs use DAGs of unbounded width. We show that MFD on width-2 DAGs is already NP-hard and that MFD on width-3 DAGs is strongly NP-hard. Our main contribution complements these hardness bounds, as we show that weak NP-hardness is the best we can hope for on width-2 DAGs. In fact, we prove the more general statement that MFD with unary coded input can be solved in quasi-polynomial time on DAGs of constant parallel-width, which includes width-2 DAGs. The parallel-width of a DAG $G$ (par-width$(G)$) was defined by Deligkas and Meir [MFCS 2017] as the size of the largest minimal $s$-$t$ cut-set. We obtain these results by, a) interpreting flow decompositions as a sequence of certain digraph minor operations defined by Deligkas and Meir [MFCS 2017], and b) defining a new notion of width of a flow network, flow-width of $(G,f)$, defined as the minimum number of paths covering all edges of $G$, where every edge $e$ can be covered by at most $f(e)$ paths. Using (a) and (b), we show as an intermediate result, an improved upper bound $(\lfloor\log \Vert f\Vert\rfloor+1) \cdot \text{par-width}(G)$ for MFD, where $\Vert f\Vert$ is the largest flow weight of all edges.

cs.DS↗

arXiv2025

An improved local search based algorithm for $k^-$-star partition

We study the $k^-$-star partition problem that aims to find a minimum collection of vertex-disjoint stars, each having at most $k$ vertices to cover all vertices in a simple undirected graph $G = (V, E)$. Our main contribution is an improved $O(|V|^3)$-time $(\frac k2 - \frac {k-2}{8k-14})$-approximation algorithm. Our algorithm starts with a $k^-$-star partition with the least $1$-stars and a key idea is to distinguish critical vertices, each of which is either in a $2$-star or is the center of a $3$-star in the current solution. Our algorithm iteratively updates the solution by three local search operations so that the vertices in each star in the final solution produced cannot be adjacent to too many critical vertices. We present an amortization scheme to prove the approximation ratio in which the critical vertices are allowed to receive more tokens from the optimal solution.

cs.DS↗

arXiv2023

Minimum Path Cover: The Power of Parameterization

Computing a minimum path cover (MPC) of a directed acyclic graph (DAG) is a fundamental problem with a myriad of applications, including reachability. Although it is known how to solve the problem by a simple reduction to minimum flow, recent theoretical advances exploit this idea to obtain algorithms parameterized by the number of paths of an MPC, known as the width. These results obtain fast [Mäkinen et al., TALG] and even linear time [Cáceres et al., SODA 2022] algorithms in the small-width regime. In this paper, we present the first publicly available high-performance implementation of state-of-the-art MPC algorithms, including the parameterized approaches. Our experiments on random DAGs show that parameterized algorithms are orders-of-magnitude faster on dense graphs. Additionally, we present new pre-processing heuristics based on transitive edge sparsification. We show that our heuristics improve MPC-solvers by orders-of-magnitude.

cs.DS↗

arXiv2023

Width Helps and Hinders Splitting Flows

Minimum flow decomposition (MFD) is the NP-hard problem of finding a smallest decomposition of a network flow/circulation $X$ on a directed graph $G$ into weighted source-to-sink paths whose superposition equals $X$. We show that, for acyclic graphs, considering the \emph{width} of the graph (the minimum number of paths needed to cover all of its edges) yields advances in our understanding of its approximability. For the version of the problem that uses only non-negative weights, we identify and characterise a new class of \emph{width-stable} graphs, for which a popular heuristic is a \gwsimple-approximation ($|X|$ being the total flow of $X$), and strengthen its worst-case approximation ratio from $Ω(\sqrt{m})$ to $Ω(m / \log m)$ for sparse graphs, where $m$ is the number of edges in the graph. We also study a new problem on graphs with cycles, Minimum Cost Circulation Decomposition (MCCD), and show that it generalises MFD through a simple reduction. For the version allowing also negative weights, we give a $(\lceil \log \Vert X \Vert \rceil +1)$-approximation ($\Vert X \Vert$ being the maximum absolute value of $X$ on any edge) using a power-of-two approach, combined with parity fixing arguments and a decomposition of unitary circulations ($\Vert X \Vert \leq 1$), using a generalised notion of width for this problem. Finally, we disprove a conjecture about the linear independence of minimum (non-negative) flow decompositions posed by Kloster et al. [ALENEX 2018], but show that its useful implication (polynomial-time assignments of weights to a given set of paths to decompose a flow) holds for the negative version.

cs.DS↗

arXiv2023

A Safety Framework for Flow Decomposition Problems via Integer Linear Programming

Many important problems in Bioinformatics (e.g., assembly or multi-assembly) admit multiple solutions, while the final objective is to report only one. A common approach to deal with this uncertainty is finding safe partial solutions (e.g., contigs) which are common to all solutions. Previous research on safety has focused on polynomially-time solvable problems, whereas many successful and natural models are NP-hard to solve, leaving a lack of "safety tools" for such problems. We propose the first method for computing all safe solutions for an NP-hard problem, minimum flow decomposition. We obtain our results by developing a "safety test" for paths based on a general Integer Linear Programming (ILP) formulation. Moreover, we provide implementations with practical optimizations aimed to reduce the total ILP time, the most efficient of these being based on a recursive group-testing procedure. Results: Experimental results on the transcriptome datasets of Shao and Kingsford (TCBB, 2017) show that all safe paths for minimum flow decompositions correctly recover up to 90% of the full RNA transcripts, which is at least 25% more than previously known safe paths, such as (Caceres et al. TCBB, 2021), (Zheng et al., RECOMB 2021), (Khan et al., RECOMB 2022, ESA 2022). Moreover, despite the NP-hardness of the problem, we can report all safe paths for 99.8% of the over 27,000 non-trivial graphs of this dataset in only 1.5 hours. Our results suggest that, on perfect data, there is less ambiguity than thought in the notoriously hard RNA assembly problem. Availability: https://github.com/algbio/mfd-safety

cs.DS↗

arXiv2023

Minimum Flow Decomposition in Graphs with Cycles using Integer Linear Programming

Minimum flow decomposition (MFD) -- the problem of finding a minimum set of weighted source-to-sink paths that perfectly decomposes a flow -- is a classical problem in Computer Science, and variants of it are powerful models in different fields such as Bioinformatics and Transportation. Even on acyclic graphs, the problem is NP-hard, and most practical solutions have been via heuristics or approximations. While there is an extensive body of research on acyclic graphs, currently, there is no \emph{exact} solution on graphs with cycles. In this paper, we present the first ILP formulation for three natural variants of the MFD problem in graphs with cycles, asking for a decomposition consisting only of weighted source-to-sink paths or cycles, trails, and walks, respectively. On three datasets of increasing levels of complexity from both Bioinformatics and Transportation, our approaches solve any instance in under 10 minutes. Our implementations are freely available at github.com/algbio/MFD-ILP.

cs.DS↗

arXiv2022

Minimum Path Cover in Parameterized Linear Time

cs.DS↗

arXiv2022

Fast, Flexible, and Exact Minimum Flow Decompositions via ILP

Minimum flow decomposition (MFD) (the problem of finding a minimum set of paths that perfectly decomposes a flow) is a classical problem in Computer Science, and variants of it are powerful models in multiassembly problems in Bioinformatics (e.g. RNA assembly). However, because this problem and its variants are NP-hard, practical multiassembly tools either use heuristics or solve simpler, polynomial-time solvable versions of the problem, which may yield solutions that are not mini-mal or do not perfectly decompose the flow. Many RNA assemblers also use integer linear programming(ILP) formulations of such practical variants, having the major limitation they need to encode all the potentially exponentially many solution paths. Moreover, the only exact solver for MFD does not scale to large instances and cannot be efficiently generalized to practical MFD variants. In this work, we provide the first practical ILP formulation for MFD (and thus the first fast and exact solver for MFD), based on encoding all of the exponentially many solution paths using only a quadratic number of variables. On both simulated and real flow graphs, our approach solves any instance in under 13 seconds. We also show that our ILP formulation can be easily and efficiently adapted for many practical variants, such as incorporating longer or paired-end reads or minimizing flow errors. We hope that our results can remove the current tradeoff between the complexity of a multi assembly model and its tractability and can lie at the core of future practical RNA assembly tools.

q-bio.GN↗

arXiv2022

Fast Circular Pattern Matching

The Exact Circular Pattern Matching (ECPM) problem consists of reporting every occurrence of a rotation of a pattern $P$ in a text $T$. In many real-world applications, specifically in computational biology, circular rotations are of interest because of their prominence in virus DNA. Thus, given no restrictions on pre-processing time, how quickly all such circular rotation occurrences is of interest to many areas of study. We highlight, to the best of our knowledge, a novel approach to the ECPM problem and present four data structures that accompany this approach, each with their own time-space trade-offs, in addition to experimental results to determine the most computationally feasible data structure.

cs.DS↗

arXiv2021

Sparsifying, Shrinking and Splicing for Minimum Path Cover in Parameterized Linear Time

A minimum path cover (MPC) of a directed acyclic graph (DAG) $G = (V,E)$ is a minimum-size set of paths that together cover all the vertices of the DAG. Computing an MPC is a basic polynomial problem, dating back to Dilworth's and Fulkerson's results in the 1950s. Since the size $k$ of an MPC (also known as the width) can be small in practical applications, research has also studied algorithms whose complexity is parameterized on $k$. We obtain two new MPC parameterized algorithms for DAGs running in time $O(k^2|V|\log{|V|} + |E|)$ and $O(k^3|V| + |E|)$. We also obtain a parallel algorithm running in $O(k^2|V| + |E|)$ parallel steps and using $O(\log{|V|})$ processors (in the PRAM model). Our latter two algorithms are the first solving the problem in parameterized linear time. Finally, we present an algorithm running in time $O(k^2|V|)$ for transforming any MPC to another MPC using less than $2|V|$ distinct edges, which we prove to be asymptotically tight. As such, we also obtain edge sparsification algorithms preserving the width of the DAG with the same running time as our MPC algorithms. At the core of all our algorithms we interleave the usage of three techniques: transitive sparsification, shrinking of a path cover, and the splicing of a set of paths along a given path.

cs.DS↗

arXiv2021

A linear-time parameterized algorithm for computing the width of a DAG

The width $k$ of a directed acyclic graph (DAG) $G = (V, E)$ equals the largest number of pairwise non-reachable vertices. Computing the width dates back to Dilworth's and Fulkerson's results in the 1950s, and is doable in quadratic time in the worst case. Since $k$ can be small in practical applications, research has also studied algorithms whose complexity is parameterized on $k$. Despite these efforts, it is still open whether there exists a linear-time $O(f(k)(|V| + |E|))$ parameterized algorithm computing the width. We answer this question affirmatively by presenting an $O(k^24^k|V| + k2^k|E|)$ time algorithm, based on a new notion of frontier antichains. As we process the vertices in a topological order, all frontier antichains can be maintained with the help of several combinatorial properties, paying only $f(k)$ along the way. The fact that the width can be computed by a single $f(k)$-sweep of the DAG is a new surprising insight into this classical problem. Our algorithm also allows deciding whether the DAG has width at most $w$ in time $O(f(\min(w,k))(|V|+|E|))$.

cs.DS↗

arXiv2021

A Note on Indexing Point Sets for Approximate Bottleneck Distance Queries

The {\em bottleneck distance} is a natural measure of the distance between two finite point sets of equal cardinality, defined as the minimum over all bijections between the point sets of the maximum distance between any pair of points put in correspondence by the bijection. In this work, we consider the problem of building a data structure $\mathbb{D}$ that indexes a collection of $m$ planar point sets (of varying sizes) and supports nearest bottleneck distance queries: given a query point set $Q$ of size $n$, we would like to find the point set(s) $P \in \mathbb{D}$ of size $n$ that are closest in terms of bottleneck distance. Without loss of generality, we assume that all point sets belong to the unit box $[0,1]^2$ in the plane and focus on the $L_\infty$ norm, although the techniques can also be used for other norms. The main contribution is a {\em trie}-based data structure finds a $6$-approximate nearest neighbor in $O(-\lg(d_B(\mathbb{D},Q)) n)$ time, where $d_B(\mathbb{D},Q)$ is the minimum bottleneck distance from $Q$ to any point set in $\mathbb{D}$.

cs.CG↗