Searcharxiv⌕ Search

arXiv subjects

Qizheng He

Publications and source records attributed to Qizheng He.

15 recordsLinked to original sources
arXiv2026

Distributed Edge Coloring with Small Palettes and a Special Case of the Constructive Lovász Local Lemma

We explore the complexity of edge coloring in the LOCAL model in different palette size regimes. 1. Lower Bounds: First, we simplify the round elimination technique of Brandt et al. and prove that $(2Δ-2)$-edge coloring requires $Ω(\log_Δ\log n)$ time w.h.p. and $Ω(\log_Δn)$ time deterministically, even on trees. Second, we show that a natural approach to computing $(Δ+1)$-edge colorings (Vizing's theorem) via extending partial colorings by iteratively re-coloring parts of the graph in the worst case requires recoloring subgraphs of diameter $Ω(Δ\log n)$. 2. Upper Bounds on General Graphs: We give a randomized edge coloring algorithm that can use palette sizes as small as $Δ+ \tilde{O}(\sqrtΔ)$, which is a natural barrier for randomized approaches. Our algorithm employs a permissive version of the constructive Lovasz local lemma as a black box. The runtime of algorithm varies for different choices of $Δ$ and palette size. For example, our algorithm computes a $(1+ε)Δ$-edge coloring in $O(\log n)$ time when $ε\geq (\log^3 Δ) / \sqrtΔ$, or $O(\log_Δ n) + (\log \log n)^{3 + o(1)}$ time when $ε= Ω(1)$. 3. Upper Bounds on Trees: We show that the $Ω(\log_Δ\log n)$ lower bound can be nearly matched on trees. To establish this result, we develop a new distributed Lovasz local lemma algorithm for tree-structured dependency graphs. Specifically, our $(1+ε)Δ$-edge coloring algorithm for trees takes $O(\log(1 / ε)) \cdot \max\{\frac{\log\log n}{\log\log\log n},\, \log_{\log Δ} \log n\}$ time when $ε\geq (\log^3 Δ) / \sqrtΔ$, or $O\left( \max\{\frac{\log\log n}{\log\log\log n},\, \log_Δ \log n\}\right)$ time when $ε= Ω(1)$.

cs.DC↗
arXiv2026

How to Catch $k$ Grid Points

Given a positive integer $k$, we study the problem of finding a convex polygon of minimum perimeter that encloses exactly $k$ points of $\mathbf{Z}^2$. We show that an optimal polygon is contained in a circular annulus of width $O(k^{1/6})$, has $Θ(k^{1/3})$ boundary grid points, and its longest edge has length $Θ(k^{1/4})$. Using these structural bounds, we present a deterministic algorithm that computes an optimal polygon in $O(k^{29/18+o(1)})$ time, improving over the previous $O(k^3)$-time algorithm.

cs.CG↗
arXiv2024

Counting numbers that are divisible by the product of their digits

Let $b \geq 3$ be a positive integer. A natural number is said to be a base-$b$ Zuckerman number if it is divisible by the product of its base-$b$ digits. Let $\mathcal{Z}_b(x)$ be the set of base-$b$ Zuckerman numbers that do not exceed $x$, and assume that $x \to +\infty$. First, we prove an upper bound of the form $|\mathcal{Z}_b(x)| < x^{z_b^{+} + o(1)}$, where $z_b^{+} \in (0,1)$ is an effectively computable constant. In particular, we have that $z_{10}^+ = 0.665{\scriptstyle\ldots}$, which improves upon the previous upper bound $|\mathcal{Z}_{10}(x)| < x^{0.717}$ due to Sanna. Moreover, we prove that $|\mathcal{Z}_{10}(x)| > x^{0.204}$, which improves upon the previous lower bound $|\mathcal{Z}_{10}(x)| > x^{0.122}$, due to De Koninck and Luca. Second, we provide a heuristic suggesting that $|\mathcal{Z}_b(x)| = x^{z_b + o(1)}$, where $z_b \in (0,1)$ is an effectively computable constant. In particular, we have that $z_{10} = 0.419{\scriptstyle\ldots}$. Third, we provide algorithms to count, respectively enumerate, the elements of $\mathcal{Z}_b(x)$, and we determine their complexities. Implementing one of such counting algorithms, we computed $|\mathcal{Z}_b(x)|$ for $b=3,\dots,12$ and large values of $x$ (depending on $b$), and we showed that the results are consistent with our heuristic.

math.NT↗
arXiv2024

Enclosing Points with Geometric Objects

Let $X$ be a set of points in $\mathbb{R}^2$ and $\mathcal{O}$ be a set of geometric objects in $\mathbb{R}^2$, where $|X| + |\mathcal{O}| = n$. We study the problem of computing a minimum subset $\mathcal{O}^* \subseteq \mathcal{O}$ that encloses all points in $X$. Here a point $x \in X$ is enclosed by $\mathcal{O}^*$ if it lies in a bounded connected component of $\mathbb{R}^2 \backslash (\bigcup_{O \in \mathcal{O}^*} O)$. We propose two algorithmic frameworks to design polynomial-time approximation algorithms for the problem. The first framework is based on sparsification and min-cut, which results in $O(1)$-approximation algorithms for unit disks, unit squares, etc. The second framework is based on LP rounding, which results in an $O(α(n)\log n)$-approximation algorithm for segments, where $α(n)$ is the inverse Ackermann function, and an $O(\log n)$-approximation algorithm for disks.

cs.CG↗
arXiv2023

Improved Algorithms for Integer Complexity

The integer complexity $f(n)$ of a positive integer $n$ is defined as the minimum number of 1's needed to represent $n$, using additions, multiplications and parentheses. We present two simple and faster algorithms for computing the integer complexity: 1) A near-optimal $O(N\mathop{\mathrm{polylog}} N)$-time algorithm for computing the integer complexity of all $n\leq N$, improving the previous $O(N^{1.223})$ one [Cordwell et al., 2017]. 2) The first sublinear-time algorithm for computing the integer complexity of a single $n$, with running time $O(n^{0.6154})$. The previous algorithms for computing a single $f(n)$ require computing all $f(1),\dots,f(n)$.

cs.DS↗
arXiv2023

Simple and Faster Algorithms for Knapsack

In this paper, we obtain a number of new simple pseudo-polynomial time algorithms on the well-known knapsack problem, focusing on the running time dependency on the number of items $n$, the maximum item weight $w_\mathrm{max}$, and the maximum item profit $p_\mathrm{max}$. Our results include: - An $\widetilde{O}(n^{3/2}\cdot \min\{w_\mathrm{max},p_\mathrm{max}\})$-time randomized algorithm for 0-1 knapsack, improving the previous $\widetilde{O}(\min\{n w_\mathrm{max} p_\mathrm{max}^{2/3},n p_\mathrm{max} w_\mathrm{max}^{2/3}\})$ [Bringmann and Cassis, ESA'23] for the small $n$ case. - An $\widetilde{O}(n+\min\{w_\mathrm{max},p_\mathrm{max}\}^{5/2})$-time randomized algorithm for bounded knapsack, improving the previous $O(n+\min\{w_\mathrm{max}^3,p_\mathrm{max}^3\})$ [Polak, Rohwedder and Wegrzyck, ICALP'21].

cs.DS↗
arXiv2023

Logical Entity Representation in Knowledge-Graphs for Differentiable Rule Learning

Probabilistic logical rule learning has shown great strength in logical rule mining and knowledge graph completion. It learns logical rules to predict missing edges by reasoning on existing edges in the knowledge graph. However, previous efforts have largely been limited to only modeling chain-like Horn clauses such as $R_1(x,z)\land R_2(z,y)\Rightarrow H(x,y)$. This formulation overlooks additional contextual information from neighboring sub-graphs of entity variables $x$, $y$ and $z$. Intuitively, there is a large gap here, as local sub-graphs have been found to provide important information for knowledge graph completion. Inspired by these observations, we propose Logical Entity RePresentation (LERP) to encode contextual information of entities in the knowledge graph. A LERP is designed as a vector of probabilistic logical functions on the entity's neighboring sub-graph. It is an interpretable representation while allowing for differentiable optimization. We can then incorporate LERP into probabilistic logical rule learning to learn more expressive rules. Empirical results demonstrate that with LERP, our model outperforms other rule learning methods in knowledge graph completion and is comparable or even superior to state-of-the-art black-box methods. Moreover, we find that our model can discover a more expressive family of logical rules. LERP can also be further combined with embedding learning methods like TransE to make it more interpretable.

cs.AI↗
arXiv2023

On the Fine-Grained Complexity of Small-Size Geometric Set Cover and Discrete $k$-Center for Small $k$

We study the time complexity of the discrete $k$-center problem and related (exact) geometric set cover problems when $k$ or the size of the cover is small. We obtain a plethora of new results: - We give the first subquadratic algorithm for rectilinear discrete 3-center in 2D, running in $\widetilde{O}(n^{3/2})$ time. - We prove a lower bound of $Ω(n^{4/3-δ})$ for rectilinear discrete 3-center in 4D, for any constant $δ>0$, under a standard hypothesis about triangle detection in sparse graphs. - Given $n$ points and $n$ weighted axis-aligned unit squares in 2D, we give the first subquadratic algorithm for finding a minimum-weight cover of the points by 3 unit squares, running in $\widetilde{O}(n^{8/5})$ time. We also prove a lower bound of $Ω(n^{3/2-δ})$ for the same problem in 2D, under the well-known APSP Hypothesis. For arbitrary axis-aligned rectangles in 2D, our upper bound is $\widetilde{O}(n^{7/4})$. - We prove a lower bound of $Ω(n^{2-δ})$ for Euclidean discrete 2-center in 13D, under the Hyperclique Hypothesis. This lower bound nearly matches the straightforward upper bound of $\widetilde{O}(n^ω)$, if the matrix multiplication exponent $ω$ is equal to 2. - We similarly prove an $Ω(n^{k-δ})$ lower bound for Euclidean discrete $k$-center in $O(k)$ dimensions for any constant $k\ge 3$, under the Hyperclique Hypothesis. This lower bound again nearly matches known upper bounds if $ω=2$. - We also prove an $Ω(n^{2-δ})$ lower bound for the problem of finding 2 boxes to cover the largest number of points, given $n$ points and $n$ boxes in 12D. This matches the straightforward near-quadratic upper bound.

cs.CG↗
arXiv2021

Dynamic Geometric Set Cover, Revisited

Geometric set cover is a classical problem in computational geometry, which has been extensively studied in the past. In the dynamic version of the problem, points and ranges may be inserted and deleted, and our goal is to efficiently maintain a set cover solution (satisfying certain quality requirement). In this paper, we give a plethora of new dynamic geometric set cover data structures in 1D and 2D, which significantly improve and extend the previous results: 1. The first data structure for $(1+\varepsilon)$-approximate dynamic interval set cover with polylogarithmic amortized update time. Specifically, we achieve an update time of $O(\log^3 n/\varepsilon)$, improving the $O(n^δ/\varepsilon)$ bound of Agarwal et al. [SoCG'20], where $δ>0$ denotes an arbitrarily small constant. 2. A data structure for $O(1)$-approximate dynamic unit-square set cover with $2^{O(\sqrt{\log n})}$ amortized update time, substantially improving the $O(n^{1/2+δ})$ update time of Agarwal et al. [SoCG'20]. 3. A data structure for $O(1)$-approximate dynamic square set cover with $O(n^{1/2+δ})$ randomized amortized update time, improving the $O(n^{2/3+δ})$ update time of Chan and He [SoCG'21]. 4. A data structure for $O(1)$-approximate dynamic 2D halfplane set cover with $O(n^{17/23+δ})$ randomized amortized update time. The previous solution for halfplane set cover by Chan and He [SoCG'21] is slower and can only report the size of the approximate solution. 5. The first sublinear results for the \textit{weighted} version of dynamic geometric set cover. Specifically, we give a data structure for $(3+o(1))$-approximate dynamic weighted interval set cover with $2^{O(\sqrt{\log n \log\log n})}$ amortized update time and a data structure for $O(1)$-approximate dynamic weighted unit-square set cover with $O(n^δ)$ amortized update time.

cs.CG↗
arXiv2021

More on Change-Making and Related Problems

Given a set of $n$ integer-valued coin types and a target value $t$, the well-known change-making problem asks for the minimum number of coins that sum to $t$, assuming an unlimited number of coins in each type. In the more general all-targets version of the problem, we want the minimum number of coins summing to $j$, for every $j=0,\ldots,t$. For example, the textbook dynamic programming algorithms can solve the all-targets problem in $O(nt)$ time. Recently, Chan and He (SOSA'20) described a number of $O(t\,\textrm{polylog}\,t)$-time algorithms for the original (single-target) version of the change-making problem, but not the all-targets version. We obtain a number of new results on change-making and related problems, including: 1. A new algorithm for the all-targets change-making problem with running time $\tilde{O}(t^{4/3})$, improving a previous $\tilde{O}(t^{3/2})$-time algorithm. 2. A very simple $\tilde{O}(u^2+t)$-time algorithm for the all-targets change-making problem, where $u$ denotes the maximum coin value. The analysis of the algorithm uses a theorem of Erdős and Graham (1972) on the Frobenius problem. This algorithm can be extended to solve the all-capacities version of the unbounded knapsack problem (for integer item weights bounded by $u$). 3. For the original (single-target) coin changing problem, we describe a simple modification of one of Chan and He's algorithms that runs in $\tilde{O}(u)$ time (instead of $\tilde{O}(t)$). 4. For the original (single-capacity) unbounded knapsack problem, we describe a simple algorithm that runs in $\tilde{O}(nu)$ time, improving previous near-$u^2$-time algorithms. 5. We also observe how one of our ideas implies a new result on the minimum word break problem, an optimization version of a string problem studied by Bringmann et al. (FOCS'17), generalizing change-making (which corresponds to the unary special case).

cs.DS↗
arXiv2021

More Dynamic Data Structures for Geometric Set Cover with Sublinear Update Time

We study geometric set cover problems in dynamic settings, allowing insertions and deletions of points and objects. We present the first dynamic data structure that can maintain an $O(1)$-approximation in sublinear update time for set cover for axis-aligned squares in 2D. More precisely, we obtain randomized update time $O(n^{2/3+δ})$ for an arbitrarily small constant $δ>0$. Previously, a dynamic geometric set cover data structure with sublinear update time was known only for unit squares by Agarwal, Chang, Suri, Xiao, and Xue [SoCG 2020]. If only an approximate size of the solution is needed, then we can also obtain sublinear amortized update time for disks in 2D and halfspaces in 3D. As a byproduct, our techniques for dynamic set cover also yield an optimal randomized $O(n\log n)$-time algorithm for static set cover for 2D disks and 3D halfspaces, improving our earlier $O(n\log n(\log\log n)^{O(1)})$ result [SoCG 2020].

cs.CG↗
arXiv2020

Faster Approximation Algorithms for Geometric Set Cover

We improve the running times of $O(1)$-approximation algorithms for the set cover problem in geometric settings, specifically, covering points by disks in the plane, or covering points by halfspaces in three dimensions. In the unweighted case, Agarwal and Pan [SoCG 2014] gave a randomized $O(n\log^4 n)$-time, $O(1)$-approximation algorithm, by using variants of the multiplicative weight update (MWU) method combined with geometric data structures. We simplify the data structure requirement in one of their methods and obtain a deterministic $O(n\log^3 n\log\log n)$-time algorithm. With further new ideas, we obtain a still faster randomized $O(n\log n(\log\log n)^{O(1)})$-time algorithm. For the weighted problem, we also give a randomized $O(n\log^4n\log\log n)$-time, $O(1)$-approximation algorithm, by simple modifications to the MWU method and the quasi-uniform sampling technique.

cs.CG↗
arXiv2020

Further Results on Colored Range Searching

We present a number of new results about range searching for colored (or "categorical") data: 1. For a set of $n$ colored points in three dimensions, we describe randomized data structures with $O(n\mathop{\rm polylog}n)$ space that can report the distinct colors in any query orthogonal range (axis-aligned box) in $O(k\mathop{\rm polyloglog} n)$ expected time, where $k$ is the number of distinct colors in the range, assuming that coordinates are in $\{1,\ldots,n\}$. Previous data structures require $O(\frac{\log n}{\log\log n} + k)$ query time. Our result also implies improvements in higher constant dimensions. 2. Our data structures can be adapted to halfspace ranges in three dimensions (or circular ranges in two dimensions), achieving $O(k\log n)$ expected query time. Previous data structures require $O(k\log^2n)$ query time. 3. For a set of $n$ colored points in two dimensions, we describe a data structure with $O(n\mathop{\rm polylog}n)$ space that can answer colored "type-2" range counting queries: report the number of occurrences of every distinct color in a query orthogonal range. The query time is $O(\frac{\log n}{\log\log n} + k\log\log n)$, where $k$ is the number of distinct colors in the range. Naively performing $k$ uncolored range counting queries would require $O(k\frac{\log n}{\log\log n})$ time. Our data structures are designed using a variety of techniques, including colored variants of randomized incremental construction (which may be of independent interest), colored variants of shallow cuttings, and bit-packing tricks.

cs.DS↗
arXiv2017

SOT for MOT

In this paper we present a robust tracker to solve the multiple object tracking (MOT) problem, under the framework of tracking-by-detection. As the first contribution, we innovatively combine single object tracking (SOT) algorithms with multiple object tracking algorithms, and our results show that SOT is a general way to strongly reduce the number of false negatives, regardless of the quality of detection. Another contribution is that we show with a deep learning based appearance model, it is easy to associate detections of the same object efficiently and also with high accuracy. This appearance model plays an important role in our MOT algorithm to correctly associate detections into long trajectories, and also in our SOT algorithm to discover new detections mistakenly missed by the detector. The deep neural network based model ensures the robustness of our tracking algorithm, which can perform data association in a wide variety of scenes. We ran comprehensive experiments on a large-scale and challenging dataset, the MOT16 benchmark, and results showed that our tracker achieved state-of-the-art performance based on both public and private detections.

cs.CV↗
arXiv2017

The Energy Complexity of Broadcast

Energy is often the most constrained resource in networks of battery-powered devices, and as devices become smaller, they spend a larger fraction of their energy on communication (transceiver usage) not computation. As an imperfect proxy for true energy usage, we define energy complexity to be the number of time slots a device transmits/listens; idle time and computation are free. In this paper we investigate the energy complexity of fundamental communication primitives such as broadcast in multi-hop radio networks. We consider models with collision detection (CD) and without (No-CD), as well as both randomized and deterministic algorithms. Some take-away messages from this work include: 1. The energy complexity of broadcast in a multi-hop network is intimately connected to the time complexity of leader election in a single-hop (clique) network. Many existing lower bounds on time complexity immediately transfer to energy complexity. For example, in the CD and No-CD models, we need $Ω(\log n)$ and $Ω(\log^2 n)$ energy, respectively. 2. The energy lower bounds above can almost be achieved, given sufficient ($Ω(n)$) time. In the CD and No-CD models we can solve broadcast using $O(\frac{\log n\log\log n}{\log\log\log n})$ energy and $O(\log^3 n)$ energy, respectively. 3. The complexity measures of Energy and Time are in conflict, and it is an open problem whether both can be minimized simultaneously. We give a tradeoff showing it is possible to be nearly optimal in both measures simultaneously. For any constant $ε>0$, broadcast can be solved in $O(D^{1+ε}\log^{O(1/ε)} n)$ time with $O(\log^{O(1/ε)} n)$ energy, where $D$ is the diameter of the network.

cs.DC↗