arXiv subjects

Meng-Tsung Tsai

Publications and source records attributed to Meng-Tsung Tsai.

12 recordsLinked to original sources

arXiv2026

Efficient Streaming Algorithms for Two-Dimensional Congruence Testing and Congruence Hashing

Geometric congruence asks whether two point multisets are identical up to translation and rotation, while congruence hashing seeks compact encodings that support efficient congruence queries. We study these problems in the streaming model under finite-precision rational inputs, where each coordinate is $p/q$ with $|p|,|q|\le U$. Our main results are two randomized polylogarithmic-space algorithms for 2D congruence identification (CI), which additionally requires outputting a valid transformation when congruent. With probability at least $1-δ$, our 3-pass product-anchor algorithm uses $O((\log n+\log U+\log \frac{1}δ)\log\log n\log \frac{1}δ)$ space in the turnstile model, while our 3-pass complex-moment algorithm uses $O(\log n(\log n+\log U+\log \frac{1}δ))$ space in the insertion-only model. Using CI as a building block, we obtain a 4-pass insertion-only congruence hashing algorithm over $m$ query sets using $O(m(\log n+\log U+\log m+\log \frac{1}δ))$ space and producing signatures of length $O(\log \frac{1}δ+\log U+\log m)$. Both algorithms presample primes for modular hashing to handle precision. The former algorithm uses finite-field embeddings and number-theoretic guarantees to recover rotations, and the latter hinges on a new non-vanishing complex moment criterion, thus avoiding additional number-theoretic conditions and the classical vanishing-moment obstacle. For the hardness results, we prove that any $p$-pass randomized streaming algorithm for 2D CI with error at most $δ$ requires $Ω(\frac{1}{p}(\log n+\log U+\log \frac{1}δ))$ space, matching the turnstile upper bound up to a $\log\log n$ factor. Moreover, approximate CI requires $\text{poly}(n)$ space even with $\text{poly}(n)$ passes. This sharply contrasts with the RAM model, where both exact and approximate versions are solvable in polynomial time.

cs.DS↗

arXiv2026

Local Certification of Vertex and Edge Connectivity

Local certification is a framework for verifying global graph properties using only local information. In this model, a prover assigns short labels, called certificates, to the vertices of a graph. Each vertex then exchanges certificates with its neighbors and performs a purely local check to determine whether the graph satisfies the desired property. This line of research has led to efficient certification schemes for a broad range of graph classes, including minor-closed families, topological graph classes, and graphs defined by forbidden subgraphs. In this paper, we study the local certification of graph connectivity. Prior work by Bousquet, Feuilloley, and Pierron (JPDC 2024) showed that $2$-vertex-connectivity, $2$-edge-connectivity, and $3$-vertex-connectivity admit $O(\log n)$-bit certificates, leveraging structural characterizations such as ear decompositions. We go substantially beyond these cases and investigate general $k$-vertex-connectivity and $k$-edge-connectivity. We develop new approaches that exploit connections between connectivity and combinatorial structures, including branchings, Eulerian subgraphs, and independent spanning trees. For $k$-edge-connectivity, we obtain an $O_k(\log n)$-bit certification scheme and prove a matching $Ω_k(\log n)$ lower bound for every $k\ge 3$. The lower bound also applies to $k$-vertex-connectivity. For $k$-vertex-connectivity, we obtain $\tilde{O}_k(\sqrt{n})$-bit certificates for every $k$ under a conjecture of Itai and Zehavi. We further show that, for $k=2$, the logarithmic barrier can be broken on sparse graph classes: $2$-edge-connectivity admits constant-size certificates in bounded-expansion graphs, and $2$-vertex-connectivity admits constant-size certificates in bounded-degree graphs. In contrast, for $2$-vertex-connectivity in general graphs, we prove an $Ω(\log(\log^\ast n))$-bit lower bound.

cs.DC↗

arXiv2026

Independence-Number Parameterized Space Complexity for Directed Connectivity Certificate

We study the space complexity of computing a sparse subgraph of a directed graph that certifies connectivity in the streaming and distributed models. Formally, for a directed graph $G=(V,A)$ and $k\in \mathbb{N}$, a $k$-node strong connectivity certificate is a subgraph $H=(V,A')\subseteq G$ such that for every pair of distinct nodes $s,t\in V$, the number of pairwise internally node-disjoint paths from $s$ to $t$ in $H$ is at least $k$ or the corresponding number in $G$. In light of the inherent hardness of directed connectivity problems, several prior work focused on restricted graph classes, showing that several problems that are hard in general become efficiently solvable when the input graph is a tournament (i.e., a directed complete graph) (Chakrabarti et al. [SODA 2020]; Baweja, Jia, and Woddruff [ITCS 2022]), or close to a tournament in edit distance (Ghosh and Kuchlous [ESA 2024]). Extending this line of work, our main result shows, at a qualitative level, that the streaming complexity of strong connectivity certificates and related problems is parameterized by independence number, demonstrating a continuum of hardness for directed graph connectivity problems. Quantitatively, for an $n$-node graph with independence number $α$, we give $p$-pass randomized algorithms that compute a $k$-node strong connectivity certificate of size $O(αn)$ using $\tilde{O}(k^{1-1/p}αn^{1+1/p})$ space in the insertion-only model. For the lower bound, we show that even when $k=1$, any $p$-pass streaming algorithm for a 1-node strong connectivity certificate in the insertion-only model requires $Ω(αn/p)$ space. To derive these lower bounds, we introduce the gadget-embedding tournament framework to construct direct-sum-type hard instances with a prescribed independence number, which is applicable to lower-bounding a wide range of directed graph problems.

cs.DS↗

arXiv2026

Space Complexity Dichotomies for Subgraph Finding Problems in the Streaming Model

We study the space complexity of four variants of the standard subgraph finding problem in the streaming model. Specifically, given an $n$-vertex input graph and a fixed-size pattern graph, we consider two settings: undirected simple graphs, denoted by $G$ and $H$, and oriented graphs, denoted by $\vec{G}$ and $\vec{H}$. Depending on the setting, the task is to decide whether $G$ contains $H$ as a subgraph or as an induced subgraph, or whether $\vec{G}$ contains $\vec{H}$ as a subgraph or as an induced subgraph. Let Sub$(H)$, IndSub$(H)$, Sub$(\vec{H})$, and IndSub$(\vec{H})$ denote these four variants, respectively. An oriented graph is well-oriented if it admits a bipartition in which every arc is oriented from one part to the other, and a vertex is non-well-oriented if both its in-degree and out-degree are non-zero. For each variant, we obtain a complete dichotomy theorem, briefly summarized as follows. (1) Sub$(H)$ can be solved by an $\tilde{O}(1)$-pass $n^{2-Ω(1)}$-space algorithm if and only if $H$ is bipartite. (2) IndSub$(H)$ can be solved by an $\tilde{O}(1)$-pass $n^{2-Ω(1)}$-space algorithm if and only if $H \in \{P_3, P_4, co\mbox{-}P_3\}$. (3) Sub$(\vec{H})$ can be solved by a single-pass $n^{2-Ω(1)}$-space algorithm if and only if every connected component of $\vec H$ is either a well-oriented bipartite graph or a tree containing at most one non-well-oriented vertex. (4) IndSub$(\vec{H})$ can be solved by an $\tilde{O}(1)$-pass $n^{2-Ω(1)}$-space algorithm if and only if the underlying undirected simple graph $H$ is a $co\mbox{-}P_3$.

cs.DS↗

arXiv2026

Determining the Outerthickness of Graphs Is NP-Hard

We give a short, self-contained, and easily verifiable proof that determining the outerthickness of a general graph is NP-hard. This resolves a long-standing open problem on the computational complexity of outerthickness. Moreover, our hardness result applies to a more general covering problem $P_F$, defined as follows. Fix a proper graph class $F$ whose membership is decidable. Given an undirected simple graph $G$ and an integer $k$, the task is to cover the edge set $E(G)$ by at most $k$ subsets $E_1,\ldots,E_k$ such that each subgraph $(V(G),E_i)$ belongs to $F$. Note that if $F$ is monotone (in particular, when $F$ is the class of all outerplanar graphs), any such cover can be converted into an edge partition by deleting overlaps; hence, in this case, covering and partitioning are equivalent. Our result shows that for every proper graph class $F$ whose membership is decidable and that satisfies all of the following conditions: (a) $F$ is closed under topological minors, (b) $F$ is closed under $1$-sums, and (c) $F$ contains a cycle of length $3$, the problem $P_F$ is NP-hard for every fixed integer $k\ge 3$. In particular: For $F$ equal to the class of all outerplanar graphs, our result settles the long-standing open problem on the complexity of determining outerthickness. For $F$ equal to the class of all planar graphs, our result complements Mansfield's NP-hardness result for the thickness, which applies only to the case $k=2$. It is also worth noting that each of the three conditions above is necessary. If $F$ is the class of all eulerian graphs, then cond. (a) fails. If $F$ is the class of all pseudoforests, then cond. (b) fails. If $F$ is the class of all forests, then cond. (c) fails. For each of these three classes $F$, the problem $P_F$ is solvable in polynomial time for every fixed integer $k\ge 3$, showing that none of the three conditions can be dropped.

cs.CC↗

arXiv2025

A Framework for the Design of Efficient Diversification Algorithms to NP-Hard Problems

There has been considerable recent interest in computing a diverse collection of solutions to a given optimization problem, both in the AI and theory communities. Given a classical optimization problem $Π$ (e.g., spanning tree, minimum cuts, maximum matching, minimum vertex cover) with input size $n$ and an integer $k\geq 1$, the goal is to generate a collection of $k$ maximally diverse solutions to $Π$. This diverse-X paradigm not only allows the user to generate very different solutions, but also helps make systems more secure and robust by handling uncertainty, and achieve energy efficiency. For problems $Π$ in P (such as spanning tree and minimum cut), there are efficient $\text{poly}(n,k)$ approximation algorithms available for the diverse variants [Hanaka et al. AAAI 2021, 2022, 2023, Gao et al. LATIN 2022, de Berg et al. ISAAC 2023]. In contrast, only FPT algorithms are known for NP-hard problems such as vertex covers and independent sets [Baste et al. IJCAI 2020, Eiben et al. SODA 2024, Misra et al. ISAAC 2024, Austrin et al. ICALP 2025], but in the worst case, these algorithms run in time $\exp((kn)^c)$ for some $c>0$. In this work, we address this gap and give $\text{poly}(n,k)$ or $f(k)\text{poly}(n)$ time approximation algorithms for diversification variants of several NP-hard problems such as knapsack, maximum weight independent sets (MWIS) and minimum vertex covers in planar graphs, geometric (rectangle) knapsack, enclosing points by polygon, and MWIS in unit-disk-graphs of points in convex position. Our results are achieved by developing a general framework and applying it to problems with textbook dynamic-programming algorithms to find one solution.

cs.CG↗

arXiv2025

Computing Diverse and Nice Triangulations

We initiate the study of computing diverse triangulations to a given polygon. Given a simple $n$-gon $P$, an integer $ k \geq 2 $, a quality measure $σ$ on the set of triangulations of $P$ and a factor $ α\geq 1 $, we formulate the Diverse and Nice Triangulations (DNT) problem that asks to compute $k$ \emph{distinct} triangulations $T_1,\dots,T_k$ of $P$ such that a) their diversity, $\sum_{i < j} d(T_i,T_j) $, is as large as possible \emph{and} b) they are nice, i.e., $σ(T_i) \leq ασ^* $ for all $1\leq i \leq k$. Here, $d$ denotes the symmetric difference of edge sets of two triangulations, and $σ^*$ denotes the best quality of triangulations of $P$, e.g., the minimum Euclidean length. As our main result, we provide a $\mathrm{poly}(n,k)$-time approximation algorithm for the DNT problem that returns a collection of $k$ distinct triangulations whose diversity is at least $1 - Θ(1/k)$ of the optimal, and each triangulation satisfies the quality constraint. This is accomplished by studying \emph{bi-criteria triangulations} (BCT), which are triangulations that simultaneously optimize two criteria, a topic of independent interest. We complement our approximation algorithms by showing that the DNT problem and the BCT problem are NP-hard. Finally, for the version where diversity is defined as $\min_{i < j} d(T_i,T_j) $, we show a reduction from the problem of computing optimal Hamming codes, and provide an $n^{O(k)}$-time $\tfrac12$-approximation algorithm. This improves over the naive ${C_{n-2} \choose k} \approx 2^{O(nk)}$ time bound for enumerating all $k$-tuples among the triangulations of a simple $n$-gon, where $C_n$ denotes the $n$-th Catalan number.

cs.CG↗

arXiv2022

Obtaining Approximately Optimal and Diverse Solutions via Dispersion

There has been a long-standing interest in computing diverse solutions to optimization problems. Motivated by reallocation of governmental institutions in Sweden, in 1995 J. Krarup posed the problem of finding $k$ edge-disjoint Hamiltonian Circuits of minimum total weight, called the peripatetic salesman problem (PSP). Since then researchers have investigated the complexity of finding diverse solutions to spanning trees, paths, vertex covers, matchings, and more. Unlike the PSP that has a constraint on the total weight of the solutions, recent work has involved finding diverse solutions that are all optimal. However, sometimes the space of exact solutions may be too small to achieve sufficient diversity. Motivated by this, we initiate the study of obtaining sufficiently-diverse, yet approximately-optimal solutions to optimization problems. Formally, given an integer $k$, an approximation factor $c$, and an instance $I$ of an optimization problem, we aim to obtain a set of $k$ solutions to $I$ that a) are all $c$ approximately-optimal for $I$ and b) maximize the diversity of the $k$ solutions. Finding such solutions, therefore, requires a better understanding of the global landscape of the optimization function. We show that, given any metric on the space of solutions, and the diversity measure as the sum of pairwise distances between solutions, this problem can be solved by combining ideas from dispersion and multicriteria optimization. We first provide a general reduction to an associated budget-constrained optimization (BCO) problem, where one objective function is to be maximized (minimized) subject to a bound on the second objective function. We then prove that bi-approximations to the BCO can be used to give bi-approximations to the diverse approximately optimal solutions problem with a little overhead.

cs.DS↗

arXiv2020

Streaming Complexity of Spanning Tree Computation

The semi-streaming model is a variant of the streaming model frequently used for the computation of graph problems. It allows the edges of an $n$-node input graph to be read sequentially in $p$ passes using $\tilde{O}(n)$ space. In this model, some graph problems, such as spanning trees and $k$-connectivity, can be exactly solved in a single pass; while other graph problems, such as triangle detection and unweighted all-pairs shortest paths, are known to require $\tildeΩ(n)$ passes to compute. For many fundamental graph problems, the tractability in these models is open. In this paper, we study the tractability of computing some standard spanning trees. Our results are: (1) Maximum-Leaf Spanning Trees. This problem is known to be APX-complete with inapproximability constant $ρ\in[245/244,2)$. By constructing an $\varepsilon$-MLST sparsifier, we show that for every constant $\varepsilon > 0$, MLST can be approximated in a single pass to within a factor of $1+\varepsilon$ w.h.p. (albeit in super-polynomial time for $\varepsilon \le ρ-1$ assuming $\mathrm{P} \ne \mathrm{NP}$). (2) BFS Trees. It is known that BFS trees require $ω(1)$ passes to compute, but the naïve approach needs $O(n)$ passes. We devise a new randomized algorithm that reduces the pass complexity to $O(\sqrt{n})$, and it offers a smooth tradeoff between pass complexity and space usage. (3) DFS Trees. The current best algorithm by Khan and Mehta {[}STACS 2019{]} takes $\tilde{O}(h)$ passes, where $h$ is the height of computed DFS trees. Our contribution is twofold. First, we provide a simple alternative proof of this result, via a new connection to sparse certificates for $k$-node-connectivity. Second, we present a randomized algorithm that reduces the pass complexity to $O(\sqrt{n})$, and it also offers a smooth tradeoff between pass complexity and space usage.

cs.DS↗

arXiv2018

Optimal Ball Recycling

Balls-and-bins games have been a wildly successful tool for modeling load balancing problems. In this paper, we study a new scenario, which we call the ball recycling game, defined as follows: Throw m balls into n bins i.i.d. according to a given probability distribution p. Then, at each time step, pick a non-empty bin and recycle its balls: take the balls from the selected bin and re-throw them according to p. This balls-and-bins game closely models memory-access heuristics in databases. The goal is to have a bin-picking method that maximizes the recycling rate, defined to be the expected number of balls recycled per step in the stationary distribution. We study two natural strategies for ball recycling: Fullest Bin, which greedily picks the bin with the maximum number of balls, and Random Ball, which picks a ball at random and recycles its bin. We show that for general p, Random Ball is constant-optimal, whereas Fullest Bin can be pessimal. However, when p = u, the uniform distribution, Fullest Bin is optimal to within an additive constant.

cs.DS↗

arXiv2018

Streaming Algorithms for Planar Convex Hulls

Many classical algorithms are known for computing the convex hull of a set of $n$ point in $\mathbb{R}^2$ using $O(n)$ space. For large point sets, whose size exceeds the size of the working space, these algorithms cannot be directly used. The current best streaming algorithm for computing the convex hull is computationally expensive, because it needs to solve a set of linear programs. In this paper, we propose simpler and faster streaming and W-stream algorithms for computing the convex hull. Our streaming algorithm has small pass complexity, which is roughly a square root of the current best bound, and it is simpler in the sense that our algorithm mainly relies on computing the convex hulls of smaller point sets. Our W-stream algorithms, one of which is deterministic and the other of which is randomized, have nearly-optimal tradeoff between the pass complexity and space usage, as we established by a new unconditional lower bound.

cs.CG↗

arXiv2015

On the complexity of computing prime tables

Many large arithmetic computations rely on tables of all primes less than $n$. For example, the fastest algorithms for computing $n!$ takes time $O(M(n\log n) + P(n))$, where $M(n)$ is the time to multiply two $n$-bit numbers, and $P(n)$ is the time to compute a prime table up to $n$. The fastest algorithm to compute $\binom{n}{n/2}$ also uses a prime table. We show that it takes time $O(M(n) + P(n))$. In various models, the best bound on $P(n)$ is greater than $M(n\log n)$, given advances in the complexity of multiplication \cite{Furer07,De08}. In this paper, we give two algorithms to computing prime tables and analyze their complexity on a multitape Turing machine, one of the standard models for analyzing such algorithms. These two algorithms run in time $O(M(n\log n))$ and $O(n\log^2 n/\log \log n)$, respectively. We achieve our results by speeding up Atkin's sieve. Given that the current best bound on $M(n)$ is $n\log n 2^{O(\log^*n)}$, the second algorithm is faster and improves on the previous best algorithm by a factor of $\log^2\log n$. Our fast prime-table algorithms speed up both the computation of $n!$ and $\binom{n}{n/2}$. Finally, we show that computing the factorial takes $Ω(M(n \log^{4/7 - ε} n))$ for any constant $ε> 0$ assuming only multiplication is allowed.

cs.CC↗