arXiv subjects

Hoa T. Vu

Publications and source records attributed to Hoa T. Vu.

15 recordsLinked to original sources

arXiv2026

Nearly Optimal Bounds for Computing Decision Tree Splits in Data Streams

We establish nearly optimal upper and lower bounds for approximating decision tree splits in data streams. For regression with labels in the range $\{0,1,\ldots,M\}$, we give a one-pass algorithm using $\tilde{O}(M^2/ε)$ space that outputs a split within additive $ε$ error of the optimal split, improving upon the two-pass algorithm of Pham et al. (ISIT 2025). Furthermore, we provide a matching one-pass lower bound showing that $Ω(M^2/ε)$ space is indeed necessary. For classification, we also obtain a one-pass algorithm using $\tilde{O}(1/ε)$ space for approximating the optimal Gini split, improving upon the previous $\tilde{O}(1/ε^2)$-space algorithm. We complement these results with matching space lower bounds: $Ω(1/ε)$ for Gini impurity and $Ω(1/ε)$ for misclassification (which matches the upper bound obtained by sampling). Our algorithms exploit the Lipschitz property of the loss functions and use reservoir sampling along with Count--Min sketches with range queries. Our lower bounds follow from careful reductions from the INDEX problem.

cs.DS↗

arXiv2026

Fast and Simple Densest Subgraph with Predictions

We study the densest subgraph problem and its NP-hard densest at-most-$k$ subgraph variant through the lens of learning-augmented algorithms. We show that, given a reasonably accurate predictor that estimates whether a node belongs to the solution (e.g., a machine learning classifier), one can design simple linear-time algorithms that achieve a $(1-ε)$approximation. Finally, we present experimental results demonstrating the effectiveness of our methods for the densest at-most-$k$ subgraph problem on real-world graphs.

cs.DS↗

arXiv2025

Constructing Decision Trees from Data Streams

In this work, we present data stream algorithms to compute optimal splits for decision tree learning. In particular, given a data stream of observations $x_i$ and their corresponding labels $y_i$, without the i.i.d. assumption, the objective is to identify the optimal split $j$ that partitions the data into two sets, minimizing the mean squared error (for regression) or the misclassification rate and Gini impurity (for classification). We propose several efficient streaming algorithms that require sublinear space and use a small number of passes to solve these problems. These algorithms can also be extended to the MapReduce model. Our results, while not directly comparable, complements the seminal work of Domingos-Hulten (KDD 2000) and Hulten-Spencer-Domingos (KDD 2001).

cs.DS↗

arXiv2024

Massively Parallel Maximum Coverage Revisited

We study the maximum set coverage problem in the massively parallel model. In this setting, $m$ sets that are subsets of a universe of $n$ elements are distributed among $m$ machines. In each round, these machines can communicate with each other, subject to the memory constraint that no machine may use more than $\tilde{O}(n)$ memory. The objective is to find the $k$ sets whose coverage is maximized. We consider the regime where $k = Ω(m)$, $m = O(n)$, and each machine has $\tilde{O}(n)$ memory. Maximum coverage is a special case of the submodular maximization problem subject to a cardinality constraint. This problem can be approximated to within a $1-1/e$ factor using the greedy algorithm, but this approach is not directly applicable to parallel and distributed models. When $k = Ω(m)$, to obtain a $1-1/e-ε$ approximation, previous work either requires $\tilde{O}(mn)$ memory per machine which is not interesting compared to the trivial algorithm that sends the entire input to a single machine, or requires $2^{O(1/ε)} n$ memory per machine which is prohibitively expensive even for a moderately small value $ε$. Our result is a randomized $(1-1/e-ε)$-approximation algorithm that uses $O(1/ε^3 \cdot \log m \cdot (\log (1/ε) + \log m))$ rounds. Our algorithm involves solving a slightly transformed linear program of the maximum coverage problem using the multiplicative weights update method, classic techniques in parallel computing such as parallel prefix, and various combinatorial arguments.

cs.DS↗

arXiv2023

Towards Better Bounds for Finding Quasi-Identifiers

We revisit the problem of finding small $ε$-separation keys introduced by Motwani and Xu (2008). In this problem, the input is $m$-dimensional tuples $x_1,x_2,\ldots,x_n $. The goal is to find a small subset of coordinates that separates at least $(1-ε){n \choose 2}$ pairs of tuples. They provided a fast algorithm that runs on $Θ(m/ε)$ tuples sampled uniformly at random. We show that the sample size can be improved to $Θ(m/\sqrtε)$. Our algorithm also enjoys a faster running time. To obtain this result, we provide upper and lower bounds on the sample size to solve the following decision problem. Given a subset of coordinates $A$, reject if $A$ separates fewer than $(1-ε){n \choose 2}$ pairs, and accept if $A$ separates all pairs. The algorithm must be correct with probability at least $1-δ$ for all $A$. We show that for algorithms based on sampling: - $Θ(m/\sqrtε)$ samples are sufficient and necessary so that $δ\leq e^{-m}$ and - $Ω(\sqrt{\frac{\log m}ε})$ samples are necessary so that $δ$ is a constant. Our analysis is based on a constrained version of the balls-into-bins problem. We believe our analysis may be of independent interest. We also study a related problem that asks for the following sketching algorithm: with given parameters $α,k$ and $ε$, the algorithm takes a subset of coordinates $A$ of size at most $k$ and returns an estimate of the number of unseparated pairs in $A$ up to a $(1\pmε)$ factor if it is at least $α{n \choose 2}$. We show that even for constant $α$ and success probability, such a sketching algorithm must use $Ω(mk \log ε^{-1})$ bits of space; on the other hand, uniform sampling yields a sketch of size $Θ(\frac{mk \log m}{αε^2})$ for this purpose.

cs.DS↗

arXiv2022

On the Locality of Nash-Williams Forest Decomposition and Star-Forest Decomposition

Given a graph $G=(V,E)$ with arboricity $α$, we study the problem of decomposing the edges of $G$ into $(1+ε)α$ disjoint forests in the distributed LOCAL model. Barenboim and Elkin [PODC `08] gave a LOCAL algorithm that computes a $(2+ε)α$-forest decomposition using $O(\frac{\log n}ε)$ rounds. Ghaffari and Su [SODA `17] made further progress by computing a $(1+ε) α$-forest decomposition in $O(\frac{\log^3 n}{ε^4})$ rounds when $εα= Ω(\sqrt{α\log n})$, i.e. the limit of their algorithm is an $(α+ Ω(\sqrt{α\log n}))$-forest decomposition. This algorithm, based on a combinatorial construction of Alon, McDiarmid \& Reed [Combinatorica `92], in fact provides a decomposition of the graph into \emph{star-forests}, i.e. each forest is a collection of stars. Our main result in this paper is to reduce the threshold of $εα$ in $(1+ε)α$-forest decomposition and star-forest decomposition. This further answers the $10^{\text{th}}$ open question from Barenboim and Elkin's "Distributed Graph Algorithms" book. Moreover, it gives the first $(1+ε)α$-orientation algorithms with {\it linear dependencies} on $ε^{-1}$. At a high level, our results for forest-decomposition are based on a combination of network decomposition, load balancing, and a new structural result on local augmenting sequences. Our result for star-forest decomposition uses a more careful probabilistic analysis for the construction of Alon, McDiarmid, \& Reed; the bounds on star-arboricity here were not previously known, even non-constructively.

cs.DS↗

arXiv2022

Distributed Dense Subgraph Detection and Low Outdegree Orientation

The densest subgraph problem, introduced in the 80s by Picard and Queyranne as well as Goldberg, is a classic problem in combinatorial optimization with a wide range of applications. The lowest outdegree orientation problem is known to be its dual problem. We study both the problem of finding dense subgraphs and the problem of computing a low outdegree orientation in the distributed settings. Suppose $G=(V,E)$ is the underlying network as well as the input graph. Let $D$ denote the density of the maximum density subgraph of $G$. Our main results are as follows. Given a value $\tilde{D} \leq D$ and $0 < ε< 1$, we show that a subgraph with density at least $(1-ε)\tilde{D}$ can be identified deterministically in $O((\log n) / ε)$ rounds in the LOCAL model. We also present a lower bound showing that our result for the LOCAL model is tight up to an $O(\log n)$ factor. In the CONGEST model, we show that such a subgraph can be identified in $O((\log^3 n) / ε^3)$ rounds with high probability. Our techniques also lead to an $O(diameter + (\log^4 n)/ε^4)$-round algorithm that yields a $1-ε$ approximation to the densest subgraph. This improves upon the previous $O(diameter /ε\cdot \log n)$-round algorithm by Das Sarma et al. [DISC 2012] that only yields a $1/2-ε$ approximation. Given an integer $\tilde{D} \geq D$ and $Ω(1/\tilde{D}) < ε< 1/4$, we give a deterministic, $\tilde{O}((\log^2 n) /ε^2)$-round algorithm in the CONGEST model that computes an orientation where the outdegree of every vertex is upper bounded by $(1+ε)\tilde{D}$. Previously, the best deterministic algorithm and randomized algorithm by Harris [FOCS 2019] run in $\tilde{O}((\log^6 n)/ ε^4)$ rounds and $\tilde{O}((\log^3 n) /ε^3)$ rounds respectively and only work in the LOCAL model.

cs.DS↗

arXiv2022

Revisiting Maximum Satisfiability and Related Problems in Data Streams

We revisit the MaxSAT problem in the data stream model. In this problem, the stream consists of $m$ clauses that are disjunctions of literals drawn from $n$ Boolean variables. The objective is to find an assignment to the variables that maximizes the number of satisfied clauses. Chou et al. (FOCS 2020) showed that $Ω(\sqrt{n})$ space is necessary to yield a $\sqrt{2}/2+ε$ approximation of the optimum value; they also presented an algorithm that yields a $\sqrt{2}/2-ε$ approximation of the optimum value using $O(\log n/ε^2)$ space. In this paper, we focus not only on approximating the optimum value, but also on obtaining the corresponding Boolean assignment using sublinear $o(mn)$ space. We present randomized single-pass algorithms that w.h.p. yield: 1) A $1-ε$ approximation using $\tilde{O}(n/ε^3)$ space and exponential post-processing time and 2) A $3/4-ε$ approximation using $\tilde{O}(n/ε)$ space and polynomial post-processing time. Our ideas also extend to dynamic streams. On the other hand, we show that the streaming kSAT problem that asks to decide whether one can satisfy all size-$k$ input clauses must use $Ω(n^k)$ space. We also consider other related problems in this setting.

cs.DS↗

arXiv2021

Maximum Coverage in the Data Stream Model: Parameterized and Generalized

We present algorithms for the Max-Cover and Max-Unique-Cover problems in the data stream model. The input to both problems are $m$ subsets of a universe of size $n$ and a value $k\in [m]$. In Max-Cover, the problem is to find a collection of at most $k$ sets such that the number of elements covered by at least one set is maximized. In Max-Unique-Cover, the problem is to find a collection of at most $k$ sets such that the number of elements covered by exactly one set is maximized. Our goal is to design single-pass algorithms that use space that is sublinear in the input size. Our main algorithmic results are: If the sets have size at most $d$, there exist single-pass algorithms using $\tilde{O}(d^{d+1} k^d)$ space that solve both problems exactly. This is optimal up to polylogarithmic factors for constant $d$. If each element appears in at most $r$ sets, we present single pass algorithms using $\tilde{O}(k^2 r/ε^3)$ space that return a $1+ε$ approximation in the case of Max-Cover. We also present a single-pass algorithm using slightly more memory, i.e., $\tilde{O}(k^3 r/ε^{4})$ space, that $1+ε$ approximates Max-Unique-Cover. In contrast to the above results, when $d$ and $r$ are arbitrary, any constant pass $1+ε$ approximation algorithm for either problem requires $Ω(ε^{-2}m)$ space but a single pass $O(ε^{-2}mk)$ space algorithm exists. In fact any constant-pass algorithm with an approximation better than $e/(e-1)$ and $e^{1-1/k}$ for Max-Cover and Max-Unique-Cover respectively requires $Ω(m/k^2)$ space when $d$ and $r$ are unrestricted. En route, we also obtain an algorithm for a parameterized version of the streaming Set-Cover problem.

cs.DS↗

arXiv2019

Distributed Data Summarization in Well-Connected Networks

We study distributed algorithms for some fundamental problems in data summarization. Given a communication graph $G$ of $n$ nodes each of which may hold a value initially, we focus on computing $\sum_{i=1}^N g(f_i)$, where $f_i$ is the number of occurrences of value $i$ and $g$ is some fixed function. This includes important statistics such as the number of distinct elements, frequency moments, and the empirical entropy of the data. In the CONGEST model, a simple adaptation from streaming lower bounds shows that it requires $\tildeΩ(D+ n)$ rounds, where $D$ is the diameter of the graph, to compute some of these statistics exactly. However, these lower bounds do not hold for graphs that are well-connected. We give an algorithm that computes $\sum_{i=1}^{N} g(f_i)$ exactly in $τ_G \cdot 2^{O(\sqrt{\log n})}$ rounds where $τ_G$ is the mixing time of $G$. This also has applications in computing the top $k$ most frequent elements. We demonstrate that there is a high similarity between the GOSSIP model and the CONGEST model in well-connected graphs. In particular, we show that each round of the GOSSIP model can be simulated almost-perfectly in $\tilde{O}(τ_G $ rounds of the CONGEST model. To this end, we develop a new algorithm for the GOSSIP model that $1\pm ε$ approximates the $p$-th frequency moment $F_p = \sum_{i=1}^N f_i^p$ in $\tilde{O}(ε^{-2} n^{1-k/p})$ rounds, for $p \geq2$, when the number of distinct elements $F_0$ is at most $O\left(n^{1/(k-1)}\right)$. This result can be translated back to the CONGEST model with a factor $\tilde{O}(τ_G)$ blow-up in the number of rounds.

cs.DS↗

arXiv2019

Towards the Locality of Vizing's Theorem

Vizing showed that it suffices to color the edges of a simple graph using $Δ+ 1$ colors, where $Δ$ is the maximum degree of the graph. However, up to this date, no efficient distributed edge-coloring algorithms are known for obtaining such a coloring, even for constant degree graphs. The current algorithms that get closest to this number of colors are the randomized $(Δ+ \tildeΘ(\sqrtΔ))$-edge-coloring algorithm that runs in $\text{polylog}(n)$ rounds by Chang et al. (SODA '18) and the deterministic $(Δ+ \text{polylog}(n))$-edge-coloring algorithm that runs in $\text{poly}(Δ, \log n)$ rounds by Ghaffari et al. (STOC '18). We present two distributed edge-coloring algorithms that run in $\text{poly}(Δ,\log n)$ rounds. The first algorithm, with randomization, uses only $Δ+2$ colors. The second algorithm is a deterministic algorithm that uses $Δ+ O(\log n/ \log \log n)$ colors. Our approach is to reduce the distributed edge-coloring problem into an online, restricted version of balls-into-bins problem. If $\ell$ is the maximum load of the bins, our algorithm uses $Δ+ 2\ell - 1$ colors. We show how to achieve $\ell = 1$ with randomization and $\ell = O(\log n / \log \log n)$ without randomization.

cs.DS↗

arXiv2018

Better Streaming Algorithms for the Maximum Coverage Problem

We study the classic NP-Hard problem of finding the maximum $k$-set coverage in the data stream model: given a set system of $m$ sets that are subsets of a universe $\{1,\ldots,n \}$, find the $k$ sets that cover the most number of distinct elements. The problem can be approximated up to a factor $1-1/e$ in polynomial time. In the streaming-set model, the sets and their elements are revealed online. The main goal of our work is to design algorithms, with approximation guarantees as close as possible to $1-1/e$, that use sublinear space $o(mn)$. Our main results are: Two $(1-1/e-ε)$ approximation algorithms: One uses $O(ε^{-1})$ passes and $\tilde{O}(ε^{-2} k)$ space whereas the other uses only a single pass but $\tilde{O}(ε^{-2} m)$ space. We show that any approximation factor better than $(1-(1-1/k)^k)$ in constant passes requires $Ω(m)$ space for constant $k$ even if the algorithm is allowed unbounded processing time. We also demonstrate a single-pass, $(1-ε)$ approximation algorithm using $\tilde{O}(ε^{-2} m \cdot \min(k,ε^{-1}))$ space. We also study the maximum $k$-vertex coverage problem in the dynamic graph stream model. In this model, the stream consists of edge insertions and deletions of a graph on $N$ vertices. The goal is to find $k$ vertices that cover the most number of distinct edges. We show that any constant approximation in constant passes requires $Ω(N)$ space for constant $k$ whereas $\tilde{O}(ε^{-2}N)$ space is sufficient for a $(1-ε)$ approximation and arbitrary $k$ in a single pass. For regular graphs, we show that $\tilde{O}(ε^{-3}k)$ space is sufficient for a $(1-ε)$ approximation in a single pass. We generalize this to a $(κ-ε)$ approximation when the ratio between the minimum and maximum degree is bounded below by $κ$.

cs.DS↗

arXiv2018

Finding Subcube Heavy Hitters in Analytics Data Streams

Data streams typically have items of large number of dimensions. We study the fundamental heavy-hitters problem in this setting. Formally, the data stream consists of $d$-dimensional items $x_1,\ldots,x_m \in [n]^d$. A $k$-dimensional subcube $T$ is a subset of distinct coordinates $\{ T_1,\cdots,T_k \} \subseteq [d]$. A subcube heavy hitter query ${\rm Query}(T,v)$, $v \in [n]^k$, outputs YES if $f_T(v) \geq γ$ and NO if $f_T(v) < γ/4$, where $f_T$ is the ratio of number of stream items whose coordinates $T$ have joint values $v$. The all subcube heavy hitters query ${\rm AllQuery}(T)$ outputs all joint values $v$ that return YES to ${\rm Query}(T,v)$. The one dimensional version of this problem where $d=1$ was heavily studied in data stream theory, databases, networking and signal processing. The subcube heavy hitters problem is applicable in all these cases. We present a simple reservoir sampling based one-pass streaming algorithm to solve the subcube heavy hitters problem in $\tilde{O}(kd/γ)$ space. This is optimal up to poly-logarithmic factors given the established lower bound. In the worst case, this is $Θ(d^2/γ)$ which is prohibitive for large $d$, and our goal is to circumvent this quadratic bottleneck. Our main contribution is a model-based approach to the subcube heavy hitters problem. In particular, we assume that the dimensions are related to each other via the Naive Bayes model, with or without a latent dimension. Under this assumption, we present a new two-pass, $\tilde{O}(d/γ)$-space algorithm for our problem, and a fast algorithm for answering ${\rm AllQuery}(T)$ in $O(k/γ^2)$ time. Our work develops the direction of model-based data stream analysis, with much that remains to be explored.

cs.DS↗

arXiv2015

Densest Subgraph in Dynamic Graph Streams

In this paper, we consider the problem of approximating the densest subgraph in the dynamic graph stream model. In this model of computation, the input graph is defined by an arbitrary sequence of edge insertions and deletions and the goal is to analyze properties of the resulting graph given memory that is sub-linear in the size of the stream. We present a single-pass algorithm that returns a $(1+ε)$ approximation of the maximum density with high probability; the algorithm uses $O(ε^{-2} n \polylog n)$ space, processes each stream update in $\polylog (n)$ time, and uses $\poly(n)$ post-processing time where $n$ is the number of nodes. The space used by our algorithm matches the lower bound of Bahmani et al.~(PVLDB 2012) up to a poly-logarithmic factor for constant $ε$. The best existing results for this problem were established recently by Bhattacharya et al.~(STOC 2015). They presented a $(2+ε)$ approximation algorithm using similar space and another algorithm that both processed each update and maintained a $(4+ε)$ approximation of the current maximum density in $\polylog (n)$ time per-update.

cs.DS↗

arXiv2015

Run Generation Revisited: What Goes Up May or May Not Come Down

In this paper, we revisit the classic problem of run generation. Run generation is the first phase of external-memory sorting, where the objective is to scan through the data, reorder elements using a small buffer of size M , and output runs (contiguously sorted chunks of elements) that are as long as possible. We develop algorithms for minimizing the total number of runs (or equivalently, maximizing the average run length) when the runs are allowed to be sorted or reverse sorted. We study the problem in the online setting, both with and without resource augmentation, and in the offline setting. (1) We analyze alternating-up-down replacement selection (runs alternate between sorted and reverse sorted), which was studied by Knuth as far back as 1963. We show that this simple policy is asymptotically optimal. Specifically, we show that alternating-up-down replacement selection is 2-competitive and no deterministic online algorithm can perform better. (2) We give online algorithms having smaller competitive ratios with resource augmentation. Specifically, we exhibit a deterministic algorithm that, when given a buffer of size 4M , is able to match or beat any optimal algorithm having a buffer of size M . Furthermore, we present a randomized online algorithm which is 7/4-competitive when given a buffer twice that of the optimal. (3) We demonstrate that performance can also be improved with a small amount of foresight. We give an algorithm, which is 3/2-competitive, with foreknowledge of the next 3M elements of the input stream. For the extreme case where all future elements are known, we design a PTAS for computing the optimal strategy a run generation algorithm must follow. (4) Finally, we present algorithms tailored for nearly sorted inputs which are guaranteed to have optimal solutions with sufficiently long runs.

cs.DS↗