arXiv subjects

Hsueh-I Lu

Publications and source records attributed to Hsueh-I Lu.

At least 19 recordsLinked to original sources

arXiv2024

A Simple 2-Approximation for Maximum-Leaf Spanning Tree

For an $m$-edge connected simple graph $G$, finding a spanning tree of $G$ with the maximum number of leaves is MAXSNP-complete. The problem remains NP-complete even if $G$ is planar and the maximal degree of $G$ is at most four. Lu and Ravi gave the first known polynomial-time approximation algorithms with approximation factors $5$ and $3$. Later, they obtained a $3$-approximation algorithm that runs in near-linear time. The best known result is Solis-Oba, Bonsma, and Lowski's $O(m)$-time $2$-approximation algorithm. We show an alternative simple $O(m)$-time $2$-approximation algorithm whose analysis is simpler. This paper is dedicated to the cherished memory of our dear friend, Professor Takao Nishizeki.

cs.DS↗

arXiv2023

An Optimal Multiple-Class Encoding Scheme for a Graph of Bounded Hadwiger Number

Since Jacobson [FOCS89] initiated the investigation of succinct graph encodings 35 years ago, there has been a long list of results on balancing the generality of the class, the speed, the succinctness of the encoding, and the query support. Let Cn denote the set consisting of the graphs in a class C that with at most n vertices. A class C is nontrivial if the information-theoretically min number log |Cn| of bits to distinguish the members of Cn is Omega(n). An encoding scheme based upon a single class C is C-opt if it takes a graph G of Cn and produces in deterministic O(n) time an encoded string of at most log |Cn| + o(log |Cn|) bits from which G can be recovered in O(n) time. Despite the extensive efforts in the literature, trees and general graphs were the only nontrivial classes C admitting C-opt encoding schemes that support the degree query in O(1) time. Basing an encoding scheme upon a single class ignores the possibility of a shorter encoded string using additional properties of the graph input. To leverage the inherent structures of individual graphs, we propose to base an encoding scheme upon of multiple classes: An encoding scheme based upon a family F of classes, accepting all graphs in UF, is F-opt if it is C-opt for each C in F. Having a C-opt encoding scheme for each C in F does not guarantee an F-opt encoding scheme. Under this more stringent criterion, we present an F-opt encoding scheme for a family F of an infinite number of classes such that UF comprises all graphs of bounded Hadwiger numbers. F consists of the nontrivial quasi-monotone classes of k-clique-minor-free graphs for each positive integer k. Our F-opt scheme supports queries of degree, adjacency, neighbor-listing, and bounded-distance shortest path in O(1) time per output. We broaden the graph classes admitting opt encoding schemes that also efficiently support fundamental queries.

cs.DS↗

arXiv2022

Blazing a Trail via Matrix Multiplications: A Faster Algorithm for Non-shortest Induced Paths

For vertices $u$ and $v$ of an $n$-vertex graph $G$, a $uv$-trail of $G$ is an induced $uv$-path of $G$ that is not a shortest $uv$-path of $G$. Berger, Seymour, and Spirkl [Discrete Mathematics 2021] gave the previously only known polynomial-time algorithm, running in $O(n^{18})$ time, to either output a $uv$-trail of $G$ or ensure that $G$ admits no $uv$-trail. We reduce the complexity to the time required to perform a poly-logarithmic number of multiplications of $n^2\times n^2$ Boolean matrices, leading to a largely improved $O(n^{4.75})$-time algorithm.

cs.DS↗

arXiv2022

Improved Algorithms for Recognizing Perfect Graphs and Finding Shortest Odd and Even Holes

Various classes of induced subgraphs are involved in the deepest results of graph theory and graph algorithms. A prominent example concerns the {\em perfection} of $G$ that the chromatic number of each induced subgraph $H$ of $G$ equals the clique number of $H$. The seminal Strong Perfect Graph Theorem confirms that the perfection of $G$ can be determined by detecting odd holes in $G$ and its complement. Chudnovsky et al. show in 2005 an $O(n^9)$ algorithm for recognizing perfect graphs, which can be implemented to run in $O(n^{6+ω})$ time for the exponent $ω<2.373$ of square-matrix multiplication. We show the following improved algorithms. 1. The tractability of detecting odd holes was open for decades until the major breakthrough of Chudnovsky et al. in 2020. Their $O(n^9)$ algorithm is later implemented by Lai et al. to run in $O(n^8)$ time, leading to the best formerly known algorithm for recognizing perfect graphs. Our first result is an $O(n^7)$ algorithm for detecting odd holes, implying an $O(n^7)$ algorithm for recognizing perfect graphs. 2. Chudnovsky et al. extend in 2021 the $O(n^9)$ algorithms for detecting odd holes (2020) and recognizing perfect graphs (2005) into the first polynomial algorithm for obtaining a shortest odd hole, which runs in $O(n^{14})$ time. We reduce the time for finding a shortest odd hole to $O(n^{13})$. 3. Conforti et al. show in 1997 the first polynomial algorithm for detecting even holes, running in about $O(n^{40})$ time. It then takes a line of intensive efforts in the literature to bring down the complexity to $O(n^{31})$, $O(n^{19})$, $O(n^{11})$, and finally $O(n^9)$. On the other hand, the tractability of finding a shortest even hole has been open for 16 years until the very recent $O(n^{31})$ algorithm of Cheong and Lu in 2022. We improve the time of finding a shortest even hole to $O(n^{23})$.

cs.DS↗

arXiv2020

Finding a Shortest Even Hole in Polynomial Time

An even (respectively, odd) hole in a graph is an induced cycle with even (respectively, odd) length that is at least four. Bienstock [DM 1991 and 1992] proved that detecting an even (respectively, odd) hole containing a given vertex is NP-complete. Conforti, Chornuéjols, Kappor, and Vušković [FOCS 1997] gave the first known polynomial-time algorithm to determine whether a graph contains even holes. Chudnovsky, Kawarabayashi, and Seymour [JGT 2005] estimated that Conforti et al.'s algorithm runs in $O(n^{40})$ time on an $n$-vertex graph and reduced the required time to $O(n^{31})$. Subsequently, da~Silva and Vušković~[JCTB 2013], Chang and Lu [JCTB 2017], and Lai, Lu, and Thorup [STOC 2020] improved the time to $O(n^{19})$, $O(n^{11})$, and $O(n^9)$, respectively. The tractability of determining whether a graph contains odd holes has been open for decades until the algorithm of Chudnovsky, Scott, Seymour, and Spirkl [JACM 2020] that runs in $O(n^9)$ time, which Lai et al. also reduced to $O(n^8)$. By extending Chudnovsky et al.'s techniques for detecting odd holes, Chudnovsky, Scott, and Seymour [Combinatorica 2020 to appear] (respectively, [arXiv 2020]) ensured the tractability of finding a long (respectively, shortest) odd hole. They also ensured the NP-hardness of finding a longest odd hole, whose reduction also works for finding a longest even hole. Recently, Cook and Seymour ensured the tractability of finding a long even hole. An intriguing missing piece is the tractability of finding a shortest even hole, left open for at least 15 years by, e.g., Chudnovsky et al. [JGT 2005] and Johnson [TALG 2005]. We resolve this long-standing open problem by giving the first known polynomial-time algorithm, running in $O(n^{31})$ time, for finding a shortest even hole in an $n$-vertex graph that contains even holes.

cs.DS↗

arXiv2020

Three-in-a-Tree in Near Linear Time

The three-in-a-tree problem is to determine if a simple undirected graph contains an induced subgraph which is a tree connecting three given vertices. Based on a beautiful characterization that is proved in more than twenty pages, Chudnovsky and Seymour [Combinatorica 2010] gave the previously only known polynomial-time algorithm, running in $O(mn^2)$ time, to solve the three-in-a-tree problem on an $n$-vertex $m$-edge graph. Their three-in-a-tree algorithm has become a critical subroutine in several state-of-the-art graph recognition and detection algorithms. In this paper we solve the three-in-a-tree problem in $\tilde{O}(m)$ time, leading to improved algorithms for recognizing perfect graphs and detecting thetas, pyramids, beetles, and odd and even holes. Our result is based on a new and more constructive characterization than that of Chudnovsky and Seymour. Our new characterization is stronger than the original, and our proof implies a new simpler proof for the original characterization. The improved characterization gains the first factor $n$ in speed. The remaining improvement is based on dynamic graph algorithms.

cs.DS↗

arXiv2017

Minimum Cuts and Shortest Cycles in Directed Planar Graphs via Noncrossing Shortest Paths

Let $G$ be an $n$-node simple directed planar graph with nonnegative edge weights. We study the fundamental problems of computing (1) a global cut of $G$ with minimum weight and (2) a~cycle of $G$ with minimum weight. The best previously known algorithm for the former problem, running in $O(n\log^3 n)$ time, can be obtained from the algorithm of \Lacki, Nussbaum, Sankowski, and Wulff-Nilsen for single-source all-sinks maximum flows. The best previously known result for the latter problem is the $O(n\log^3 n)$-time algorithm of Wulff-Nilsen. By exploiting duality between the two problems in planar graphs, we solve both problems in $O(n\log n\log\log n)$ time via a divide-and-conquer algorithm that finds a shortest non-degenerate cycle. The kernel of our result is an $O(n\log\log n)$-time algorithm for computing noncrossing shortest paths among nodes well ordered on a common face of a directed plane graph, which is extended from the algorithm of Italiano, Nussbaum, Sankowski, and Wulff-Nilsen for an undirected plane graph.

cs.DS↗

arXiv2015

A Faster Algorithm to Recognize Even-Hole-Free Graphs

We study the problem of determining whether an $n$-node graph $G$ has an even hole, i.e., an induced simple cycle consisting of an even number of nodes. Conforti, Cornuéjols, Kapoor, and Vušković gave the first polynomial-time algorithm for the problem, which runs in $O(n^{40})$ time. Later, Chudnovsky, Kawarabayashi, and Seymour reduced the running time to $O(n^{31})$. The best previously known algorithm for the problem, due to da Silva and Vušković, runs in $O(n^{19})$ time. In this paper, we solve the problem in $O(n^{11})$ time. Moreover, if $G$ has even holes, our algorithm also outputs an even hole of $G$ in $O(n^{11})$ time.

cs.DS↗

arXiv2014

Linear-Time Compression of Bounded-Genus Graphs into Information-Theoretically Optimal Number of Bits

A $\textit{compression scheme}$ $A$ for a class $\mathbb{G}$ of graphs consists of an encoding algorithm $\textit{Encode}_A$ that computes a binary string $\textit{Code}_A(G)$ for any given graph $G$ in $\mathbb{G}$ and a decoding algorithm $\textit{Decode}_A$ that recovers $G$ from $\textit{Code}_A(G)$. A compression scheme $A$ for $\mathbb{G}$ is $\textit{optimal}$ if both $\textit{Encode}_A$ and $\textit{Decode}_A$ run in linear time and the number of bits of $\textit{Code}_A(G)$ for any $n$-node graph $G$ in $\mathbb{G}$ is information-theoretically optimal to within lower-order terms. Trees and plane triangulations were the only known nontrivial graph classes that admit optimal compression schemes. Based upon Goodrich's separator decomposition for planar graphs and Djidjev and Venkatesan's planarizers for bounded-genus graphs, we give an optimal compression scheme for any hereditary (i.e., closed under taking subgraphs) class $\mathbb{G}$ under the premise that any $n$-node graph of $\mathbb{G}$ to be encoded comes with a genus-$o(\frac{n}{\log^2 n})$ embedding. By Mohar's linear-time algorithm that embeds a bounded-genus graph on a genus-$O(1)$ surface, our result implies that any hereditary class of genus-$O(1)$ graphs admits an optimal compression scheme. For instance, our result yields the first-known optimal compression schemes for planar graphs, plane graphs, graphs embedded on genus-$1$ surfaces, graphs with genus $2$ or less, $3$-colorable directed plane graphs, $4$-outerplanar graphs, and forests with degree at most $5$. For non-hereditary graph classes, we also give a methodology for obtaining optimal compression schemes. From this methodology, we give the first known optimal compression schemes for triangulations of genus-$O(1)$ surfaces and floorplans.

cs.DS↗

arXiv2013

Replacement Paths via Row Minima of Concise Matrices

Matrix $M$ is {\em $k$-concise} if the finite entries of each column of $M$ consist of $k$ or less intervals of identical numbers. We give an $O(n+m)$-time algorithm to compute the row minima of any $O(1)$-concise $n\times m$ matrix. Our algorithm yields the first $O(n+m)$-time reductions from the replacement-paths problem on an $n$-node $m$-edge undirected graph (respectively, directed acyclic graph) to the single-source shortest-paths problem on an $O(n)$-node $O(m)$-edge undirected graph (respectively, directed acyclic graph). That is, we prove that the replacement-paths problem is no harder than the single-source shortest-paths problem on undirected graphs and directed acyclic graphs. Moreover, our linear-time reductions lead to the first $O(n+m)$-time algorithms for the replacement-paths problem on the following classes of $n$-node $m$-edge graphs (1) undirected graphs in the word-RAM model of computation, (2) undirected planar graphs, (3) undirected minor-closed graphs, and (4) directed acyclic graphs.

cs.DS↗

arXiv2013

Computing the Girth of a Planar Graph in Linear Time

The girth of a graph is the minimum weight of all simple cycles of the graph. We study the problem of determining the girth of an n-node unweighted undirected planar graph. The first non-trivial algorithm for the problem, given by Djidjev, runs in O(n^{5/4} log n) time. Chalermsook, Fakcharoenphol, and Nanongkai reduced the running time to O(n log^2 n). Weimann and Yuster further reduced the running time to O(n log n). In this paper, we solve the problem in O(n) time.

cs.DS↗

arXiv2003

An Optimal Algorithm for the Maximum-Density Segment Problem

We address a fundamental problem arising from analysis of biomolecular sequences. The input consists of two numbers $w_{\min}$ and $w_{\max}$ and a sequence $S$ of $n$ number pairs $(a_i,w_i)$ with $w_i>0$. Let {\em segment} $S(i,j)$ of $S$ be the consecutive subsequence of $S$ between indices $i$ and $j$. The {\em density} of $S(i,j)$ is $d(i,j)=(a_i+a_{i+1}+...+a_j)/(w_i+w_{i+1}+...+w_j)$. The {\em maximum-density segment problem} is to find a maximum-density segment over all segments $S(i,j)$ with $w_{\min}\leq w_i+w_{i+1}+...+w_j \leq w_{\max}$. The best previously known algorithm for the problem, due to Goldwasser, Kao, and Lu, runs in $O(n\log(w_{\max}-w_{\min}+1))$ time. In the present paper, we solve the problem in O(n) time. Our approach bypasses the complicated {\em right-skew decomposition}, introduced by Lin, Jiang, and Chao. As a result, our algorithm has the capability to process the input sequence in an online manner, which is an important feature for dealing with genome-scale sequences. Moreover, for a type of input sequences $S$ representable in $O(m)$ space, we show how to exploit the sparsity of $S$ and solve the maximum-density segment problem for $S$ in $O(m)$ time.

cs.DS↗

arXiv2003

Compact Floor-Planning via Orderly Spanning Trees

Floor-planning is a fundamental step in VLSI chip design. Based upon the concept of orderly spanning trees, we present a simple O(n)-time algorithm to construct a floor-plan for any n-node plane triangulation. In comparison with previous floor-planning algorithms in the literature, our solution is not only simpler in the algorithm itself, but also produces floor-plans which require fewer module types. An equally important aspect of our new algorithm lies in its ability to fit the floor-plan area in a rectangle of size (n-1)x(2n+1)/3. Lower bounds on the worst-case area for floor-planning any plane triangulation are also provided in the paper.

cs.DS↗

arXiv2002

Improved Compact Visibility Representation of Planar Graph via Schnyder's Realizer

Let $G$ be an $n$-node planar graph. In a visibility representation of $G$, each node of $G$ is represented by a horizontal line segment such that the line segments representing any two adjacent nodes of $G$ are vertically visible to each other. In the present paper we give the best known compact visibility representation of $G$. Given a canonical ordering of the triangulated $G$, our algorithm draws the graph incrementally in a greedy manner. We show that one of three canonical orderings obtained from Schnyder's realizer for the triangulated $G$ yields a visibility representation of $G$ no wider than $\frac{22n-40}{15}$. Our easy-to-implement O(n)-time algorithm bypasses the complicated subroutines for four-connected components and four-block trees required by the best previously known algorithm of Kant. Our result provides a negative answer to Kant's open question about whether $\frac{3n-6}{2}$ is a worst-case lower bound on the required width. Also, if $G$ has no degree-three (respectively, degree-five) internal node, then our visibility representation for $G$ is no wider than $\frac{4n-9}{3}$ (respectively, $\frac{4n-7}{3}$). Moreover, if $G$ is four-connected, then our visibility representation for $G$ is no wider than $n-1$, matching the best known result of Kant and He. As a by-product, we obtain a much simpler proof for a corollary of Wagner's Theorem on realizers, due to Bonichon, Saëc, and Mosbah.

cs.DS↗

arXiv2002

Linear-Time Algorithms for Computing Maximum-Density Sequence Segments with Bioinformatics Applications

We study an abstract optimization problem arising from biomolecular sequence analysis. For a sequence A of pairs (a_i,w_i) for i = 1,..,n and w_i>0, a segment A(i,j) is a consecutive subsequence of A starting with index i and ending with index j. The width of A(i,j) is w(i,j) = sum_{i <= k <= j} w_k, and the density is (sum_{i<= k <= j} a_k)/ w(i,j). The maximum-density segment problem takes A and two values L and U as input and asks for a segment of A with the largest possible density among those of width at least L and at most U. When U is unbounded, we provide a relatively simple, O(n)-time algorithm, improving upon the O(n \log L)-time algorithm by Lin, Jiang and Chao. When both L and U are specified, there are no previous nontrivial results. We solve the problem in O(n) time if w_i=1 for all i, and more generally in O(n+n\log(U-L+1)) time when w_i>=1 for all i.

cs.DS↗

arXiv2002

Detecting Race Conditions in Parallel Programs that Use Semaphores

We address the problem of detecting race conditions in programs that use semaphores for synchronization. Netzer and Miller showed that it is NP-complete to detect race conditions in programs that use many semaphores. We show in this paper that it remains NP-complete even if only two semaphores are used in the parallel programs. For the tractable case, i.e., using only one semaphore, we give two algorithms for detecting race conditions from the trace of executing a parallel program on p processors, where n semaphore operations are executed. The first algorithm determines in O(n) time whether a race condition exists between any two given operations. The second algorithm runs in O(np log n) time and outputs a compact representation from which one can determine in O(1) time whether a race condition exists between any two given operations. The second algorithm is near-optimal in that the running time is only O(log n) times the time required simply to write down the output.

cs.DS↗

arXiv2002

Orderly Spanning Trees with Applications

We introduce and study the {\em orderly spanning trees} of plane graphs. This algorithmic tool generalizes {\em canonical orderings}, which exist only for triconnected plane graphs. Although not every plane graph admits an orderly spanning tree, we provide an algorithm to compute an {\em orderly pair} for any connected planar graph $G$, consisting of a plane graph $H$ of $G$, and an orderly spanning tree of $H$. We also present several applications of orderly spanning trees: (1) a new constructive proof for Schnyder's Realizer Theorem, (2) the first area-optimal 2-visibility drawing of $G$, and (3) the best known encodings of $G$ with O(1)-time query support. All algorithms in this paper run in linear time.

cs.DS↗

arXiv2001

Optimal Bid Sequences for Multiple-Object Auctions with Unequal Budgets

In a multiple-object auction, every bidder tries to win as many objects as possible with a bidding algorithm. This paper studies position-randomized auctions, which form a special class of multiple-object auctions where a bidding algorithm consists of an initial bid sequence and an algorithm for randomly permuting the sequence. We are especially concerned with situations where some bidders know the bidding algorithms of others. For the case of only two bidders, we give an optimal bidding algorithm for the disadvantaged bidder. Our result generalizes previous work by allowing the bidders to have unequal budgets. One might naturally anticipate that the optimal expected numbers of objects won by the bidders would be proportional to their budgets. Surprisingly, this is not true. Our new algorithm runs in optimal O(n) time in a straightforward manner. The case with more than two bidders is open.

cs.CE↗