跳到正文
研踪PaperTrail

YOUR RESEARCH, IN SIGHT

让下一篇重要论文，不再错过。

覆盖计算机全学科，以 AI 为快捷入口。关注方向、作者和关键词，把发现变成持续的研究积累。

部分采集异常
正在读取账号与研究记录…

全站更新概况

+1072新增论文
+845其中 AI 相关
+94已有论文修订
+100新增 AI 导读

arXiv 最近完成扫描：2026-11-09 19:37 · 全站最近入库：2026-11-09 13:22各信源进度 →

统计口径与数据新鲜度

统计 2026-11-08 20:23 — 2026-11-09 20:23（北京时间） · 点击数字查看对应简报；AI 相关包含在新增论文内。

最近完成检查：2026-11-09 19:37最近发现新增版本：2026-11-09 13:22库内论文最新更新时间：2026-11-07 02:59

每分钟刷新已保存的数据。空检查不代表采集异常；新收录可能包含历史论文。AI 导读按新增版本计数。

18,172 已收录论文15,506 AI 相关4,527 有修订112 HF 社区发现

浏览论文库

研究日报 / 周报 →按信源浏览 →

时间范围跟随排序：版本更新、本站收录或首次发表。最新收录可能包含历史论文。部分信源异常，查看状态 →

找到 486 篇论文 · 按版本更新时间排序上轮扫描起点 2026-11-09 19:35（北京时间）
新论文 · v1arXiv:2611.02481

Generalized Flows over Time: Complexity, Structure and Algorithm

Siyuan Chen, Shengminjie Chen, Suixiang Gao, Zheyu Jiang, Dun Ma, Wenguo Yang

原文摘要

Generalized flows over time constitute a general network flow model that incorporates both transit times and flow losses or gains. We study their complexity, structure, and approximation. We prove that the generalized maximum flow over time problem remains NP-hard under standard binary encoding, even on lossy two-terminal series-parallel networks. The maximum temporally repeated restriction is APX-hard with general gains and NP-hard on lossy networks. We then consider the minimum source supply needed to satisfy a fixed sink demand within a given horizon, and prove that an optimal solution always exists without intermediate storage. On lossy networks, such a solution can additionally use only simple source--sink paths. These structural properties yield a fully polynomial-time approximation scheme via time condensation, with analogous schemes for generalized maximum flows over time and quickest flows with a source-supply budget.

cs.DS

查看论文
arXiv ↗PDF ↗
版本更新 · v4arXiv:2609.25816

Exponential Quantum Advantage in Testing Fourier Dimensionality

Kenny Chen

原文摘要

A boolean function $f$ has Fourier dimension $k$ if its strings with nonzero Fourier coefficients span a subspace of dimension $k$. We first consider the property testing task of determining whether a function has Fourier dimension at most $k$, or is $ε$-far from being so. We show that there is an $O(k/\sqrtε)$-query quantum property tester for this problem, which we show to be almost optimal. Combined with Gopalan \etal's classical lower bound of $Ω(2^{k/2})$, this demonstrates an exponential quantum advantage for this task. We complement this result with a $\tilde{O}(2^{k/2}/ε)$ classical tester, giving a quadratic improvement over the previous best tester, and essentially settling the classical query complexity. We then introduce and study the tolerant version of this problem. That is, determining whether a function is $αε$-close to having Fourier dimension at most $k$, or is $ε$-far from being so. Perhaps surprisingly, we show that this tolerant version of the problem is essentially just as hard as the standard version of the problem. That is, we show this problem has a $\tilde{O}(k/ε)$ quantum tester, and a $\tilde{O}(2^{k/2}/ε)$ classical tester.

quant-ph · cs.CC · cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.02374

Submodularity Is Barely Testable

Diptaksho Palit, Yuichi Yoshida

原文摘要

In 2010, Seshadhri and Vondrák asked: is submodularity testable? For functions $f : \{ 0, 1 \}^n \to \mathbb{R}$, they gave a tester that makes $2^{O(\sqrt{n} \log n)}$ queries. We show that every tester, even an adaptive one with two-sided error, must make $2^{Ω(\sqrt{n})}$ queries, thereby concluding: submodularity is barely testable.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.02344

Efficient Proper Agnostic Learning of Halfspaces

Anindya De, Elchanan Mossel, Shivam Nadimpalli, Joe Neeman

原文摘要

We give a proper membership-query algorithm for agnostically learning halfspaces under the uniform distribution on $\{\pm1\}^n$. Given query access to an arbitrary function $f:\{\pm1\}^n \to \{\pm1\}$, our algorithm runs in time $\mathrm{poly}(n)+2^{\mathrm{poly}(1/\varepsilon)}$ and outputs a halfspace with error at most $\mathrm{OPT}+\varepsilon$, where $\mathrm{OPT}$ is the error of the best-fitting halfspace for $f$. Previously, even with membership queries, the best known running time was $n^{\mathrm{poly}(1/\varepsilon)}$, achieved by the sample-based algorithm of Kalai, Klivans, Mansour, and Servedio (FOCS 2005). Our algorithm is the first agnostic halfspace learner under the uniform distribution on $\{\pm1\}^n$ whose running time is polynomial in $n$ with an exponent independent of $\varepsilon$. Combining our algorithm with a boosting argument yields a proper agnostic learner using only random examples. It achieves the same $\mathrm{OPT}+\varepsilon$ guarantee, with running time matching that of Kalai et al.\ up to an additive term depending only on $\varepsilon$. To our knowledge, this is the first sample-based proper agnostic learner in the Boolean setting with running time $2^{o(n)}$ for every fixed $\varepsilon>0$.

cs.DS · cs.CC · stat.ML

查看论文
arXiv ↗PDF ↗
版本更新 · v2arXiv:2608.19172

Cell-Probe Lower Bounds and Complexity-Preserving Reductions for Suffix Array Queries

Dominik Kempa, Tomasz Kociumaka

原文摘要

For a text $T$ of length $n$ over an alphabet of size $σ$, its suffix array lists the starting positions of the suffixes of $T$ in lexicographic order, and its inverse suffix array gives the lexicographic rank of the suffix starting at each position. Since the introduction of the FM-index and the compressed suffix array in 2000, both queries have been supported in $O((\log_σn)^ε)$ time using $O(n\logσ)$ bits, for any constant $ε>0$. Yet no nontrivial time-space lower bound for suffix-array queries in compact space was known. We give the first such lower bound: in the cell-probe model with $Θ(\log n)$-bit words, every deterministic $S$-bit data structure with $S\ge n$ answering suffix-array queries on binary strings of length at most $n$ has worst-case query time $Ω(\log\log n/\log((S/n)\log\log n))$. Hence, structures with $O(n(\log\log n)^{O(1)})$ bits need $Ω(\log\log n/\log\log\log n)$ query time, while constant query time requires $Ω(n\log^εn)$ bits for some constant $ε>0$, matching known upper bounds. In particular, no such $O(n)$-bit structure supports constant-time queries, answering the 25-year-old question of Grossi and Vitter. We also give exact complexity-preserving equivalences between suffix-array access and simpler prefix queries on short strings. For every $2\leqσ\leq n$, suffix-array queries are equivalent to prefix-select queries, and inverse-suffix-array queries are equivalent to prefix-special-rank queries. The reductions in both directions preserve all four standard measures up to constant factors: space, query time, preprocessing time, and preprocessing space. Unlike previous reductions, they incur no additive $O(\log\log n)$ query-time term. Thus, the corresponding prefix-query problems capture suffix-array and inverse-suffix-array access without asymptotic loss in any of the four measures.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.02287

Faster graphic matroid parity: Breaking the $nm$ time complexity barrier

Tatsuya Terao

原文摘要

In the graphic matroid parity problem, we are given an undirected multigraph $G=(V,E)$ with $n$ vertices, together with a partition of $E$ into $m$ pairs of distinct edges, and the goal is to find a maximum-cardinality collection of pairs whose union is a forest. This problem generalizes both graph matching and graphic matroid intersection. Graph matching admits the celebrated $\tilde{O}(\sqrt{n}m)$-time algorithm of Micali--Vazirani~[FOCS'80], and graphic matroid intersection admits $o(nm)$-time algorithms due to Gabow--Stallmann~[ICALP'85] and Gabow--Xu~[FOCS'89]. In contrast, for graphic matroid parity, Gabow--Stallmann~[FOCS'84 \& Combinatorica'86] gave an $O(n^2 m)$-time algorithm, and its $\tilde{O}(nm)$-time implementation by Gabow--Stallmann~[ICALP'85] had long remained the best known bound, except in very dense regimes where $m=ω(n^3)$, in which case the algebraic $\tilde{O}(n^4)$-time algorithm of Cheung--Lau--Leung~[SODA'11 \& TALG'14] is faster. We present a randomized $\tilde{O}(n^{3/2} \sqrt{m} + \sqrt{n} m)$-time algorithm for graphic matroid parity. This is the first algorithm to break the $O(nm)$-time complexity barrier for this problem outside the very dense regime. Moreover, it improves over the previous bounds except in very sparse regimes where $m=\tilde{O}(n)$ and in very dense regimes where $m = \tildeΩ(n^{3.5})$. In particular, when $m=Θ(n^2)$, our algorithm runs in $\tilde{O}(n^{2.5})$ time, which nearly matches the $\tilde{O}(n^{2.5})$-time bounds of Micali--Vazirani for graph matching and of Gabow--Xu for graphic matroid intersection in this regime.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.02281

Near-Quadratic Error-Free Graph Matching above Otter's Threshold via Approximate Local Tree Correlation Testing

Jiale Cheng, Ziao Wang, Lei Ying

原文摘要

This paper presents a near-quadratic-time algorithm that correctly matches almost all nodes of two correlated Erdős-Rényi graphs without any incorrect matches. Each graph has average degree $λ$ and its edges are subsampled from a common parent Erdős-Rényi graph with $n$ nodes, with subsampling probability $s$. The nodes of one graph are then relabeled by an unknown permutation. The algorithm is built on a test for correlated versus independent Galton-Watson trees with approximated likelihood ratios. For every constant $s>\sqrt{C_{\mathrm{Otter}}}$, where $C_{\mathrm{Otter}}\approx0.338$ is Otter's tree-counting constant, and every $λ=ω(1)$ with $λ=(\log n)^{O(1)}$, the algorithm outputs a partial matching of size $n-o(n)$ that contains no incorrect matches with high probability. If, in addition, $λs\ge(1+ε)\log n$ for a constant $ε>0$, a seeded completion step recovers the permutation exactly. In both cases, the time complexity of the algorithm is $n^{2+o(1)}$ with high probability, whereas previous polynomial-time algorithms with the same guarantees either have a time-complexity bound whose exponent goes to $\infty$ as $s$ approaches $\sqrt{C_{\mathrm{Otter}}}$ from above, or apply only when $s$ is close to $1$.

cs.DS · math.ST · stat.ML

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.02154

Faster Algorithms for Disjoint Paths in DAGs and Two Disjoint Shortest Paths

Yang Cao, Haoran Qi, Hanzhi Wang

原文摘要

For $k$ vertex-disjoint paths with prescribed endpoints in a directed acyclic graph (DAG), the $O(mn^{k-1})$-time pebbling algorithm of Fortune, Hopcroft, and Wyllie [TCS 1980] has remained the fastest for every $k\geq3$ for over four decades, even when the paths must be shortest. We break this bound for every $k\geq3$ with randomized algorithms running in expected $O_k(m+n^{k-3+ω+\varepsilon})$ time for every $\varepsilon>0$, where $ω<2.372$ is the matrix multiplication exponent; this is $O_k(m+n^{k-0.62})$. For two disjoint shortest paths, we find the paths as fast as we detect them: in expected linear time on DAGs and on undirected graphs with polynomially bounded integer weights, and in expected $O(\min\{mn,n^{ω+\varepsilon}\})$ time on directed graphs whose cycles have positive weight, which on dense graphs is $o(mn)$ even for detection. All algorithms evaluate a polynomial whose monomials are the solutions: a new first-collision circuit speeds up the evaluation in DAGs, and a correlated extraction step at cuts crossed once by every path finds a solution at the cost of a constant number of evaluations.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.02105

Faster Semi-Streaming and Dynamic Approximate Maximum Weight Matchings in General Graphs: A Unified Framework

Jiale Chen

原文摘要

We study the $(1-\varepsilon)$-approximate maximum weight matching problem in general graphs with $n$ vertices and integer edge weights in $[1,W]$. For $W=n^{O(1)}$, we obtain faster algorithms in the semi-streaming and dynamic settings: (1) Semi-streaming: Deterministic $O(\varepsilon^{-2})$-pass and $O(\varepsilon^{-2}\log(1/\varepsilon))$-pass algorithms for unweighted and weighted matching. (2) Incremental: A deterministic algorithm for weighted matching processing $m$ edge insertions in total time $O((m\varepsilon^{-3}+n\varepsilon^{-6})\log^3 n)$. (3) Decremental: A randomized algorithm for weighted matching processing all edge deletions from an $m$-edge graph in total time $O((m\varepsilon^{-8}+n\varepsilon^{-47})\log^{O(1)}n)$ with high probability. (4) Fully dynamic: A deterministic reduction from weighted matching in general graphs to unweighted matching in bipartite graphs incurring $O(\varepsilon^{-4}\log^{O(1)}(1/\varepsilon))$ multiplicative update-time overhead, independent of $n$. Underlying these results is a unified framework that reduces the problem to repeatedly solving two simpler matching subproblems: a $(1-\varepsilon)$-approximate maximum weight matching on a sparse subgraph with $O(n/\varepsilon)$ edges, and a constant approximation on the remaining edges. The framework builds on dual entropy regularization, a smoothing technique underlying efficient solvers for packing linear programs. To handle the exponentially many odd-set constraints, we adapt the smoothing technique to regularize only the vertex duals and develop a new cut partition that preserves odd-set feasibility during optimization.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.02057

Paying for Fractional Error: Tight Constant-Round Approximation of Covering Problems with Short Broadcasts

Saeed Amiri, Sebastian Siebertz, Wojciech Wawrzyniak

原文摘要

We present a general framework for deterministic constant-round approximation of covering problems in sparse networks in the broadcast CONGEST model, where every vertex broadcasts the same $O(\log n)$-bit message to all its neighbors. The framework combines two independent tools. The first is a solver that computes a $(1+δ)$-approximate solution of any local covering linear program with bounded positive integer costs on every class that excludes a fixed minor. The second is a rounding principle: a rounding rule that saves a fixed fraction of its own output, for every feasible input, pays for a solver error fixed in advance, so that an approximate fractional solution yields an exact coefficient. For ordinary domination, we achieve a $2a+1$ approximation against the fractional optimum $γ_f(G)$ for every fixed rational $a\ge1$, whenever every minor has a ratio of edges to vertices of at most $a$. On planar graphs this is seven, matching the lower bound of Hilke, Lenzen, and Suomela. The coefficients are also optimal at bounded treewidth and pathwidth, for $K_t$-minor-free graphs with $3\le t\le9$, on triangle-free planar graphs (five), and on planar graphs of large girth, where it approaches the optimal three. On every fixed surface the exact bound is $7γ(G)$, and we show that a bound of $7γ_f(G)$ is impossible on some fixed surfaces even sequentially. For total domination, on graphs without isolated vertices and under the same minor-density assumption, the exact coefficient is $2a$ against the fractional optimum, including the optimal six on planar graphs. Red-blue domination, and hence set cover and hitting set on planar incidence graphs, has the optimal limiting coefficient four. Our method also gives randomized constant-round and deterministic $O(\log^* n)$-round $(1+\varepsilon)$-approximation schemes, with the randomized cost guarantee holding in expectation.

cs.DS · cs.DC

查看论文
arXiv ↗PDF ↗
版本更新 · v2arXiv:2609.06925

Frequency Moments Beyond Equality: Streaming Cosine Density Moments

Qin Zhang

原文摘要

For a stream of nonzero vectors $x_1,\ldots,x_n\in\mathbb{R}^d$, let $u_i=x_i/\|x_i\|_2$. We define the cosine density of the $i$-th stream element by $D_i:=\sum_{j\in[n]}\langle u_i,u_j\rangle$ and study the density moments $M_p:=\sum_{i\in[n]}D_i^p$ in both the signed- and nonnegative-cosine regimes. These quantities are similarity-aware analogues of classical frequency moments: replacing cosine similarity by equality (that is, $D_i = \sum_{j\in[n]} \mathbf{1}\{u_j = u_i\}$) gives $M_p=F_{p+1}$ and, in particular, $M_{-1}=F_0$, the number of distinct elements. We give one-pass streaming algorithms and lower bounds whose dependence on $d$ is tight up to logarithmic factors for $p=-1$, $p=1$, and even $p \ge 2$ (the latter under signed cosine), and whose exponents differ by less than $1/2$ for odd $p \ge 3$ under nonnegative cosine. Our results thus extend several fundamental statistics from the classical data stream literature to cosine similarity, a widely used measure for comparing vector embeddings in modern AI systems. The main challenge in proving a space lower bound for nonnegative cosine is to eliminate unwanted contributions without relying on pairs of opposite vectors. We address this through a construction that we call \emph{equal-sum moment isolation}: two insertion-only prefixes have the same cardinality and vector sum, and a finite-difference comparison cancels the baseline shared by all their vectors while isolating the desired higher-order signal. This proof framework may be useful for other insertion-only streaming lower bounds, where direct cancellation is not possible.

cs.DS

查看论文
arXiv ↗PDF ↗
版本更新 · v2arXiv:2610.01853

Achieving Optimal Redundancy for Small Dynamic Rank/Select Dictionaries

Gabriel Marques Domingues

原文摘要

In this paper, we study the number of bits required to construct a dynamic dictionary with optimal time for $\texttt{rank}/\texttt{select}$ operations. Using the standard (multiplication) Word-RAM model with $w$-bit words, we construct a data-structure for a dynamic $\texttt{rank}/\texttt{select}$ dictionary for a set $S\subseteq\{0,1,\cdots,u-1\}$ of $n$ elements that, given a parameter $1\leq k\leq \log^*w$, uses $$\operatorname{lg}\binom{u}{n}+\mathcal{O}(n\log^{(k)}w)\text{ bits}$$ taking optimal $\mathcal{O}(k+\log_w n)$ time (worst-case) for all operations. We show optimality for $n=w^{\mathcal{O}(1)}$ and $\log u=Θ(w)$ by extending the lower bound of Li, Liang, Yu, and Zhou [FOCS 2023] to super-polynomial universes: any dynamic dictionary for $n\leq \sqrt{u}$ elements that uses $\operatorname{lg}\binom{u}{n}+\mathcal{O}(n\log^{(k)}n)$ bits requires $Ω(k)$ time for operations. Lastly, we extend the data-structure to a dynamic fully indexable dictionary (that also supports $\texttt{rank}/\texttt{select}$ on the complement of $S$).

cs.DS

查看论文
arXiv ↗PDF ↗
版本更新 · v3arXiv:2610.29624

A Tight Space Lower Bound for Pivot-Based Distance Oracles

Avi Kadria, Liam Roditty

原文摘要

An approximate distance oracle (ADO) is a compact data structure that answers distance queries within a multiplicative \emph{stretch} $k$. The classical oracle of Thorup and Zwick~[STOC'01, JACM'05] has stretch $k=2\ell-1$ and uses $O(\ell n^{1+1/\ell})$ space, for every integer $\ell\ge1$. This trade-off is optimal for dense graphs under the Erdős girth conjecture. However, for sparse graphs ($m=O(n)$), their lower bound yields nothing beyond $Ω(m)$ space. The main result of this paper is a nearly tight lower bound for pivot-based $1$-hop ADOs in sparse graphs. A pivot-based $1$-hop ADO gives every vertex $\tilde{O}(1)$ pivots and returns as an estimate the length of a walk of the form $u\to p_u \to p_v \to v$, where $p_u$ is a pivot of $u$, $p_v$ is a pivot of $v$, and $p_u\to p_v$ is a stored distance. We observe that all the state-of-the-art ADOs with $\tilde{O}(1)$ query time are in fact pivot-based $1$-hop ADOs. We prove that every \emph{pivot-based} $1$-hop ADO with \emph{real} stretch $k$ requires $\widetildeΩ(m^{1+2/(k+1)})$ space, under the Erdős girth conjecture for graphs with constant degree. This matches the best known ADOs with $\tilde{O}(1)$ query time, at every known stretch, up to polylogarithmic factors. We also extend our lower bound to pivot-based ADOs with any constant number $β$ of hops, showing that they require $\widetildeΩ(m^{1+2/(β(k+1))})$ space. In addition, we obtain a tight lower bound for two-hop hopsets and improved lower bounds for general $β$-hop hopsets.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01920

Multiplicative Weights for Mixed Block Constraints and Maximum Multicommodity Flow

Vladimir Kolmogorov

原文摘要

We study multiplicative-weights (MWU) algorithms for block-separable feasibility problems containing both packing and covering constraints. Each iteration optimizes a weighted linear objective over one block, either chosen uniformly at random or visited in a fixed cyclic order. We show that the cyclic algorithm returns an $O(\varepsilon)$-approximate solution after $O(kρ\varepsilon^{-2}\log m)$ oracle calls where $k$ is the number of blocks and $ρ$ is the width of the oracle. The same holds for the randomized version with high probability. Previously, such bounds were shown when the coupling constraints have the same sign [Radzik'95; Villavicencio-Grigoriadis'96]. These analyses critically depended on monotonicity arguments that are not available in the mixed case. As an application, we obtain a deterministic $(1-\varepsilon)$-approximation for maximum multicommodity flow (M-MCF) using $O(k\varepsilon^{-2}\log m\log(km/\varepsilon))$ approximate single-commodity min-cost-flow calls. For planar graphs, and more generally for graph families admitting a near-linear-time min-cost-flow algorithm, this gives total running time $\widetilde O(km\varepsilon^{-2})$. Compared with the $O(km^{1+o(1)}\varepsilon^{-1})$ algorithm of [Chen-Graur-Sidford'25], this improves the dependence on $m$ for these graph families at the cost of a worse dependence on $\varepsilon$. Finally, we give an exponentiation-free finite-precision implementation of the cyclic algorithm. It represents each internal weight by a logarithmic-bit mantissa and exponent, while every price supplied to the block oracle is rational and has a polynomially bounded common denominator.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01875

Approximation Algorithms for Maximum-Weight Degree-Bounded Forests

Theophile Thiery, Vera Traub, Nicola Widmer

原文摘要

In the maximum-weight degree-bounded forest problem, we are given a graph with nonnegative edge weights and a degree upper bound on each vertex. The objective is to find a maximum-weight forest satisfying the degree bounds. We show that this problem admits a simple $2$-approximation via the greedy algorithm. This already improves over the best-known guarantees obtained via a reduction to weighted $3$-matroid parity, and sets a baseline to improve upon. Our main result is an $\frac{8}{5}$-approximation algorithm for the maximum-weight degree-bounded forest problem. For the special case of uniform degree bounds, our algorithm achieves an approximation ratio of $\frac{3}{2}$. It computes two sets of edges, each of which we then restrict to a feasible solution in an optimal way, and finally returns the better of the two resulting solutions. To obtain the initial two edge sets, we first relax the degree bounds and leverage an algorithm by Lau and Singh [JACM'15] for degree-bounded spanning trees, and second we relax the forest constraints and employ an algorithm for maximum-weight $b$-matchings.

cs.DS · math.CO

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01874

Efficient Lempel-Ziv Prediction with the Run-Length BWT

Ohad Avnery

原文摘要

Lempel-Ziv Plurality (LZP) is an algorithm of Kosoy that predicts the next symbol of a string by using its Lempel-Ziv factorization, and makes at most $O(z\log n)$ mistakes on every string of length $n$ with $z$ LZ77 phrases. We give efficient online implementations of LZP and of a new variant of it. Our first implementation maintains a run-length encoded Burrows-Wheeler transform (RLBWT) of the reversed history. It implements LZP, uses $O(z\log z\log^2 n)$ bits, and has worst-case update and prediction times $O(\log z+\log\log n)$ and $O(σ(\log z+\log\log n))$, respectively, where $σ$ is the size of the alphabet. This is an exponential improvement over Kosoy's implementation, whose update time is $O(z\log^7 n)$. We then introduce the Lempel-Ziv Majority (LZM) predictor, which has the same mistake bound and update time, and predicts in $O(1)$ time independently of $σ$. These two predictors accept new symbols at any time, without knowing the alphabet in advance. For an alphabet known in advance, a different data structure gives $O(σ(1+\log z/\log\log n))$ time per symbol, which is constant when $σ=O(1)$ and $z=\mathrm{polylog}(n)$.

cs.DS · cs.LG

查看论文
arXiv ↗PDF ↗
版本更新 · v3arXiv:2606.16061

Coresets for Continuous $k$-Center in Hyperbolic Space

Eunku Park

原文摘要

We study coresets for the continuous $k$-center problem in fixed-dimensional hyperbolic space $\mathbb H^D$, where centers may lie anywhere in the space. For an input set $P$ of $n$ points, we construct an unweighted coreset of size $(k/\varepsilon)^{O(kD)}$ in $O(nkD(k/\varepsilon)^{O(kD)})$ time, independent of the enclosing radius. Every exact optimal solution for the coreset is a $(1+\varepsilon)$-approximation for $P$. The same construction also yields a strong coreset after adjusting the accuracy parameter. Our method combines local Euclidean grids at bounded scales with radial shells at larger scales. Hyperbolic balls induce spherical caps on representative spheres, whose multiplicative enlargement can be controlled by additive hyperbolic distance errors. A recursive ball-coverage certificate then selects a radius-independent set of input witnesses. We establish lower bounds of $Ω_D(k\varepsilon^{-D})$ for $k\ge 8D$ and sufficiently small $\varepsilon$, and $2^{Ω(k)}$ for $D\ge2$ when $\varepsilon=Θ(1/k)$, ruling out bounds polynomial jointly in $k$ and $1/\varepsilon$. For $k$ sufficiently separated clusters, we obtain simultaneous additive and multiplicative weak coreset guarantees, with optimal worst-case size $Θ_D(k\varepsilon^{-(D-1)/2})$ when both errors equal $\varepsilon$. In contrast, even under the same separation condition, no radius-independent additive weak coreset bound exists in the Euclidean plane for $k=2$.

cs.CG · cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01774

Monotone Local Search with Sample-Dependent Running Times

Serge Gaspers

原文摘要

Monotone Local Search turns an algorithm that extends a given partial solution into an algorithm that finds a solution from scratch: sample a few elements, hope that they lie in an unknown solution, and complete them. Its known analyses bound every call of the extension algorithm by a worst-case time that depends only on the number of sampled elements, and Esmer et al. (SODA 2024) showed that no algorithm that uses the extension algorithm as a black box with this running time beats the original form by more than a polynomial factor. We let this running time depend on the actual sample. If the extension algorithm decides in time $O^*(2^{g(I,X,k)})$, for a polynomial-time computable $g$, whether a sample $X$ can be completed to a solution with at most $k$ elements, our main theorem gives a randomized algorithm with one-sided error in time $O^*(2^{ψn})$ whenever, for some solution $S$ of size $k$ and some $t$, the exponential moment $\sum_{X\subseteq S,|X|=t}2^{-g(I,X,k)}$ is at least $2^{-ψn}\binom{n}{t}$. A corollary, multivariate Monotone Local Search, generalizes the theorems of Fomin et al. (STOC 2016, J. ACM 2019) and of Gaspers and Lee (ICALP 2017). For Max Leaf Spanning Tree and, equivalently, Connected Dominating Set, the previous best polynomial-space bound is $O^*(1.8619^n)$. Completing a sample is a Steiner tree problem, solved in time exponential in the number of terminals, which varies strongly with the sample. We obtain a randomized polynomial-space algorithm in time $O(1.6991^n)$ and a deterministic one in time $(\sqrt5-\frac12)^n 2^{o(n)}=O(1.7361^n)$. For connectivity problems in which the extension algorithm's running time doubles with every component of the sample, an analysis through a partition function gives randomized polynomial-space algorithms in time $O^*(1.8^n)$ for Connected Feedback Vertex Set and $O(1.6444^n)$ for Connected Vertex Cover.

cs.DS · cs.DM

查看论文
arXiv ↗PDF ↗
版本更新 · v4arXiv:2609.30992

Deterministic Linear-Time Modular Subset Sum

Phuoc Dinh Le, Kha Le

原文摘要

We give a deterministic $O(m)$-time algorithm for exact modular subset sum over every modulus $m$. The input gives distinct residues and their multiplicities. The algorithm reports all reachable residues and answers one target query. It returns a witness when the target is reachable. The algorithm uses $O(m)$ auxiliary words on an arithmetic word-RAM. This improves Potępa's deterministic $O(m\log m\,α(m))$-time bound under the same input convention. The running time matches the cost of returning a length-$m$ Boolean array. We represent reachable residues as runs along cycles of repeated addition. Newly reached residues pay for scans of partial runs. Packed cycle flags make rebuilding take linear total time at the original modulus. A theorem on subset sums of distinct units limits the number of adaptive boundary batches to $O(m^{3/4})$. Radix sorting their $O(m)$ total keys also takes $O(m)$ time.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01599

Fresh-Priority Eviction for Cuckoo Filters: Exploiting Latent Randomness Under XOR Hashing

Min Liu

原文摘要

Cuckoo filters are a widely adopted approximate membership query (AMQ) data structure that supports insertions, lookups, and deletions with low memory overhead. At high load factors, however, insertion performance degrades sharply due to the random-walk eviction process, which may require a large number of element relocations. Recent work on bucketized cuckoo hash tables has shown that \emph{fresh-priority eviction}, which preferentially evicts elements whose alternate bucket location has not yet been used, achieves $O(\ell m)$ total expected evictions for bucket size~$\ell$, an improvement over the standard random walk. In this paper, we show that this technique transfers to \emph{cuckoo filters} despite their use of XOR-based partial-key hashing. The key insight is that a fresh element's fingerprint, although stored in the table, is not examined by the eviction policy, so when the fingerprint length satisfies $k = Ω(\log m)$, the alternate bucket hash remains a near-uniform random variable, a property we call \emph{latent randomness}. We prove that under this condition the corruption graph remains subcritical and the total number of evictions is $O(\ell m \log m)$; we conjecture the tighter $O(\ell m)$ bound holds via the full amortized analysis of Bell and Kuszmaul. We further propose encoding the fresh/kicked state implicitly by the element's position within its bucket, requiring no additional per-element metadata. Experimental results on a filter with $2^{22}$ slots and $8$-bit fingerprints demonstrate $1.2\times$ to $2.4\times$ fewer evictions at load factors between $94\%$ and $99\%$ for bucket size $\ell = 8$, and a $1.73\times$ reduction in cumulative evictions to full capacity.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01584

Smoothed analysis of stability radii for the assignment problem

Michael P. Friedlander

原文摘要

Every linear program can tolerate small changes to its costs and still yield a solution of the original problem. The size of this tolerance measures how robust an optimal decision is to noise or numerical error, and how much regularization the problem can support. Classical sensitivity analysis can determine this tolerance only from an optimal solution. This paper provides a priori lower bounds on two measures of this tolerance -- the optimality gap and the $\infty$-norm stability radius -- for the $n$-by-$n$ linear assignment problem over the Birkhoff polytope. The bounds derive from a smoothed analysis, which adds Gaussian noise with standard deviation of at least $σ$ in every direction to an arbitrary base cost. At every fixed confidence level, uniformly over the base cost, both quantities are at least of order $σ/(n\sqrt{\log n})$. The radius bound is asymptotically sharp. Under isotropic noise, the worst case occurs when every assignment has equal cost, and in this case, a scaled stability radius converges in distribution to a standard exponential variable.

math.OC · cs.DS · math.PR

查看论文
arXiv ↗PDF ↗
版本更新 · v2arXiv:2610.39564

Constant-Factor Approximation for Non-Splitting Coflow Scheduling in Heterogeneous Parallel Networks via Iterative Relaxation

Chi-Yeh Chen

原文摘要

Coflows capture the collective communication requirements of data-parallel applications, and scheduling them well is essential to the performance of modern data centers. We study non-splitting coflow scheduling in a heterogeneous parallel network whose $m$ network cores may be Electronic Packet Switches (EPS), not-all-stop Optical Circuit Switches (OCS), or all-stop OCS, where every flow must be transmitted entirely through a single core. Previous approximation algorithms for this setting have guarantees that grow linearly with the number of cores $m$ or with the maximum flow degree $τ$ of a port, and therefore become weak as data centers deploy more cores. The source of this dependence is the rounding step: rounding each flow to the core holding its largest fractional value can inflate the load of a port by a factor of $m$. We replace this step with an iterative relaxation rounding scheme that handles the input-port and output-port capacity constraints simultaneously. For minimizing the makespan, this yields approximation ratios of $\min\{τ, 3\}$, $2\min\{τ, 3\}$, and $4\min\{τ, 3\}$ for pure EPS, pure not-all-stop OCS, and pure all-stop OCS networks, respectively. For minimizing the total weighted coflow completion time, we obtain approximation ratios of $8\min\{τ, 4\}$, $16\min\{τ, 4\}$, and $32\min\{τ, 4\}$ for the same three architectures. In a hybrid network, the guarantee is governed by the weakest architecture present, so the overall ratios are at most $4\min\{τ,3\}\le 12$ and $32\min\{τ,4\}\le 128$, respectively. Unlike all previous guarantees for non-splitting coflow scheduling in heterogeneous parallel networks, these bounds are absolute constants that do not grow with the number of cores $m$ or with the flow degree $τ$. We also show that the integrality gap of the underlying linear program is at least $2$.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01569

A logarithm-free subexponential algorithm for minimum quartet inconsistency

Chuang-Chieh Lin

原文摘要

We give a deterministic algorithm for complete, unweighted minimum quartet inconsistency (MQI) with time and space $2^{O(k^{1/4})}+n^{O(1)}$, where $n$ is the number of taxa and~$k$ is the allowed number of quartet disagreements. This removes the logarithmic factor from the exponent of the MQI bound announced in 2009. The algorithm combines low-error anchoring, chromatic coding, and dynamic programming that accounts for disagreements with all input quartets, with a refined count of colorings and merging states. We also record a generic ETH-based lower bound. The optimality of the fourth-root exponent remains open.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01553

A Deterministic O(log m)-Competitive Algorithm for Online Minimum Cost Bipartite Matching with Delays

Tung-Wei Kuo

原文摘要

In the online Minimum cost Bipartite Perfect Matching with Delays (MBPMD) problem, $m$ requests and $m$ servers arrive over time in a metric space. An online algorithm has to match each request to a server and can postpone a matching decision by paying the delay cost. The objective is to minimize the total distance and delay cost. Azar, Chiplunkar, and Kaplan gave a randomized $O(\log n)$-competitive algorithm for metric spaces with $n$ points that are known in advance. For deterministic algorithms, however, the best known competitive ratio in general metric spaces was $O(m^{0.59})$, due to Azar and Jacob-Fanani. On the line, Kuo proposed the Virtual Robust Matching (VRM) algorithm and showed that it is $O(\sqrt{m}\log^2 m)$-competitive. We prove that VRM is $O(\log m)$-competitive for the MBPMD problem in any metric space. VRM is deterministic and does not need to know the metric space or $m$ in advance. It is the first deterministic polylogarithmic-competitive algorithm for the MBPMD problem in general metric spaces. Unlike the previous analysis of VRM, our analysis does not rely on a geometric decomposition of the metric space. Instead, it charges the waiting time of requests over time to the edges of a fixed optimal matching. We also extend VRM to the non-bipartite version and prove that the resulting deterministic algorithm is $O(\log m)$-competitive. This improves the $O(\log^5 m)$ bound of Dufay and Wattenhofer and matches a concurrent result of Ahmadian, Chawla, Kumar, Purohit, and Zhang. The proof that VRM is $O(\log m)$-competitive and its non-bipartite extension were found by GPT-6 Astra (OpenAI) with almost no human input. We used Claude Opus 5.5 (Anthropic) to simplify and present the results. See the AI Usage and Methodology section for details. We take full responsibility for this paper.

cs.DS

查看论文
arXiv ↗PDF ↗
版本更新 · v2arXiv:2609.27797

Faster Minimum k-Cut II: Improved Randomized and Deterministic Algorithms for Weighted Graphs

Trevor Vaughn

原文摘要

The Minimum $k$-Cut problem asks for a minimum-weight set of edges whose removal leaves an undirected weighted graph with at least $k$ connected components. We consider only $k\ge3$. The fastest previous algorithm for weighted graphs ran in $n^{k-2}(m+n)(\log n)^{O(k^2)}$ randomized time~\cite{LV26}; on dense graphs this is $\widetilde O_k(n^k)$, and for $k=3$ it gives an $\widetilde O(nm)$-time algorithm. We improve the dense-graph exponent from $k$ to $k-1$ and obtain the same exponent deterministically. After aggregating parallel edges in $O(m)$ time, our randomized algorithm runs with high probability in \begin{equation*} k^{O(k^2)}n^{k-1}\log^2n \end{equation*} time, while our deterministic algorithm runs in \begin{equation*} k^{O(k^2)}n^{k-1}\log^{O(1)}n \end{equation*} time. In particular, weighted Minimum $3$-Cut can be solved in $O(n^2\log^2 n)$ randomized time and in $\widetilde O(n^2)$ deterministic time. The algorithms have two main components. First, we give a faster algorithm for weighted Minimum $3$-Cut. After handling optima with a very small side and optima with two light sides, the remaining optimum has a unique structured side. Tree packing reduces its completion to a batched collection of $2$-respecting cut problems. Second, we reduce Minimum $k$-Cut to Minimum $3$-Cut by enumerating a bounded family of light-cut candidates and recursively completing either side of each candidate. If the enumeration produces too many cuts, then we can instead produce an optimum $k$-cut directly. We derandomize the $3$-cut algorithm using a deterministic near-minimum-cut skeleton, and derandomize the reduction using a specialized $4$-cut algorithm using the skeleton, the constructive light-cut bounds, and the deterministic spectral sparsifier of \cite{BSS12}.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01399

Deterministic $n^{O(\log n)}$ Graph Isomorphism Algorithm via Inherited Decompositions

MohammadTaghi Hajiaghayi, Mahdi JafariRaviz

原文摘要

We give a deterministic $n^{O(\log n)}$-time algorithm for graph isomorphism. To our knowledge, this is the first proof of such a worst-case bound for general graphs. The algorithm uses the local-certificate and color-refinement steps of Babai's quasipolynomial algorithm, but retains the decomposition of each recursive instance when it solves an auxiliary coloring problem. There are two reasons for retaining this information. First, a local test can make progress without removing many vertices: it can eliminate a layer of permutation symmetry. A logarithmic bound on the total weight of these layers allows tests of constant size. Second, the auxiliary bipartite graphs arising in the symmetry-breaking step can be represented inside the current instance, after retaining a row decomposition when necessary. These recursive calls inherit the progress already made. The analysis gives a recurrence with quadratic logarithmic cost and a fixed power decrease in every fresh recursive call, improving the explicit cubic logarithmic exponent in the analysis of the corrected Luks--Babai algorithm. We present the algorithm through colorings, partitions, and bipartite graphs, and collect the permutation-group ingredients in one appendix. The result extends to string isomorphism and returns one isomorphism and generators for the full automorphism group.

cs.DS

查看论文
arXiv ↗PDF ↗
版本更新 · v5arXiv:2503.09508

Gain-Sharing Optimization in Randomized Primal--Dual Analysis: Structure and Certification

Pan Xu

原文摘要

Randomized primal--dual guarantees for online matching and allocation often depend on a gain-sharing function that determines how algorithmic gains are distributed among dual variables and, in some settings, also affects allocation decisions. We study the best certificate obtainable by optimizing this function within a specified algorithm--analysis template. For an admissible function class F, we formulate the problem as the functional optimization $Γ(F)=\sup_{f\in F} L[f]$, where $L[f]$ is the worst-case expected dual-feasibility factor. We develop two complementary certification methods: auxiliary linear programs with explicit finite-grid error bounds, and a continuous approach based on monotone Volterra comparison and residual-based numerical verification. We apply them to the vertex-weighted Stochastic Balance template for online matching with stochastic rewards under uniform vanishing success probabilities. For the configuration-LP benchmark and specified dual updates, we optimize over the full admissible class $F_0$ of continuous non-decreasing functions from $[0,\infty)$ to $[0,1]$, and prove $Γ(F_0)\in[0.5802,0.5805]$. We also show that the more tractable subclass used for auxiliary-LP certification attains the same optimum.

cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01387

Three-phase time minimization transportation problem with non-idle phases: a polynomial two-witness algorithm

Sailesh Kamalahasan, Raghav Paladugu, Archana Khurana

原文摘要

The three-phase time minimization transportation problem partitions the origin-terminal links into three sets used in consecutive phases and minimizes the sum of the phase shipment times. Optimal solutions may leave a phase idle, as in the main example of the original study. We require every phase to carry a positive integer quantity while leaving the split of the total requirement across phases free. Discarding idle solutions from the original algorithm does not, in general, solve this variant. We prove that the optimum is attained by fixing one witness link in each of two phases and deciding the third phase by a single network flow computation, with the optimal Phase-3 time of each witness pair located by binary search. The resulting exact algorithm is strongly polynomial. It extends to any fixed number of phases, whereas, when the number of phases is part of the input, even non-idle feasibility is strongly NP-complete; feasibility alone is fixed-parameter tractable in the number of phases via known rainbow-matching results. We also characterize the minimum time of each phase. On the main example, non-idleness raises the optimum from 38 to 41. On 3,650 random instances with up to $50\times50$ links the algorithm took at most 50.2 seconds, and non-idleness raised the optimal value in 41% of the 2,250 instances with equal phase sizes; on 90 sampled instances it was faster than a mixed integer programming solver on 80 with a direct formulation and on 65 with a tighter threshold formulation.

math.OC · cs.DS

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01369

Sharper Bounds for Graphical Two-Choice Allocation

Obinna Okechukwu

原文摘要

In graphical two-choice allocation, vertices are bins, and each arriving ball must be placed irrevocably at one endpoint of a uniformly random edge. The objective is to keep the maximum-minus-minimum load gap small at every time. On cycles, endpoint-local monotone rules incur polynomial gaps at long time horizons, whereas global rules can achieve polylogarithmic gaps. We prove a joint exponential-moment inequality for the orthogonal contrasts of a binary partition tree, controlling all contrasts along a root-to-leaf path simultaneously. Applied to the Bansal--Feldheim strategy, it improves the gap on every $κ$-edge-connected $d$-regular graph from $O((d/κ)\log^4 n\log\log n)$ to $O((d/κ)\log^3 n\log\log n)$. We give an explicit strategy on the $n$-cycle with expected gap $O(\log^2 n)$ uniformly over deterministic times and exponential tails at each such time. An Euler-tour projection yields $O(\bar d\log^2(2M))$ for every connected graph with $M$ edges and degree-proportional capacities. For lower bounds, we introduce a stochastic cut workload: the expected largest normalized overload forced by the requests, plus an indivisibility term. For every online integral strategy, the supremum over time of the expected gap is at least one sixth of this benchmark. Regular rings of cliques attain $Ω((d/κ)\log n)$ along an explicit family, improving the prior additive lower bound. With unequal capacities, the workload need not control the gap: one family has constant relative cut slack, bounded workload and gap $Ω(\log\log n)$; another has workload at most $20$ but forces gap $Ω(\log n)$ even for clairvoyant fractional allocations that remain irrevocable.

cs.DS · math.PR

查看论文
arXiv ↗PDF ↗
新论文 · v1arXiv:2611.01368

An $\mathsf{FPRAS}$ for Mixed Volumes

Xiaoyu Chen, Kuikui Liu

原文摘要

We design the first fully polynomial-time randomized approximation scheme ($\mathsf{FPRAS}$) to estimate the mixed volume of $n$ arbitrary compact convex sets in $\mathbb{R}^{n}$ specified by weak membership oracles. This disproves a longstanding conjecture of Gurvits (2009). $\textbf{AI Disclosure}$ The main ideas were generated entirely by GPT 6 Astra. The purpose of this paper is to provide a human-written exposition of the algorithm.

cs.DS · cs.CC · cs.CG · math.CO · math.PR

查看论文
arXiv ↗PDF ↗