arXiv subjects

Guochuan Zhang

Publications and source records attributed to Guochuan Zhang.

At least 19 recordsLinked to original sources

arXiv2026

Dense Subset Sum in Multi-Dimension

We study the additive structure of dense subset sum in multi-dimension, and use the structure to develop efficient algorithms for the dense subset sum problem. More precisely, given a set $A$ of $n$ vectors in the $d$-dimensional hyperrectangle $[N_1]\times [N_2]\times\cdots\times [N_d]$, we study the structure of $\mathcal{S}(A)$, which is the set of all subset sums of $A$. We focus on the dense regime of the problem where $n \gg \sqrtΦ$ and $Φ= N_1 \times \cdots \times N_d$. We show that for any constant $d\geq 1$, if $n \gg \sqrtΦ$, then $\mathcal{S}(A)$ contains a long generalized progression in multi-dimension. If we further have that no non-trivial lattice can contain the majority of $A$, then $\mathcal{S}(A)$ contains all the integer points in the zonotope $\{x_1\vec{a}_1 + \cdots + x_n\vec{a}_n: o(1)\leq x_j \leq 1-o(1), x_j \in \mathbb{R}\}$. Compared to the previous results for $d \geq 2$, our result significantly reduces the density threshold and enlarges the region inside which all the integer points belong to $\mathcal{S}(A)$. Also, it matches the bound for the 1-dimensional case. Using our combinatorics result, we also develop an $\tilde{O}(n)$-time algorithm for the dense subset sum problem in multi-dimension.

cs.DS↗

arXiv2026

Near-Tight Approximation Algorithms for Bottleneck Multiple Knapsack Problems

In the bottleneck multiple knapsack problem, we are given a set of items and a set of knapsacks, where each item has a profit and a weight, and each knapsack has a capacity. Our goal is to assign items to knapsacks so as to maximize the minimum profit received by any knapsack subject to the capacity constraint. When all knapsacks have identical capacity, we give a $(\frac{2}{3} - \varepsilon)$-approximation algorithm for any constant $\varepsilon > 0$. This result almost matches the $(\frac{2}{3} + \varepsilon)$ inapproximability bound for the bottleneck multiple subset sum problem (Caprara et al., 2000). When the knapsacks can have arbitrary capacities, we propose a $(\frac{1}{2} - \varepsilon)$-approximation algorithm for any constant $\varepsilon > 0$. We also prove a hardness bound of $(\frac{1}{2} + \varepsilon)$ for any constant $\varepsilon > 0$.

cs.DS↗

arXiv2026

An Improved Pseudopolynomial Time Algorithm for Subset Sum

We investigate pseudo-polynomial time algorithms for Subset Sum. Given a multi-set $X$ of $n$ positive integers and a target $t$, Subset Sum asks whether some subset of $X$ sums to $t$. Bringmann proposes an $\tilde{O}(n + t)$-time algorithm [Bringmann SODA'17], and an open question has naturally arisen: can Subset Sum be solved in $O(n + w)$ time? Here $w$ is the maximum integer in $X$. We make a progress towards resolving the open question by proposing an $\tilde{O}(n + \sqrt{wt})$-time algorithm.

cs.DS↗

arXiv2025

Approximation algorithms for integer programming with resource augmentation

The classic algorithm [Papadimitriou, J.ACM '81] for IPs has a running time $n^{O(m)}(m\cdot\max\{Δ,\|\textbf{b}\|_{\infty}\})^{O(m^2)}$, where $m$ is the number of constraints, $n$ is the number of variables, and $Δ$ and $\|\textbf{b}\|_{\infty}$ are, respectively, the largest absolute values among the entries in the constraint matrix and the right-hand side vector of the constraint. The running time is exponential in $m$, and becomes pseudo-polynomial if $m$ is a constant. In recent years, there has been extensive research on FPT (fixed parameter tractable) algorithms for the so-called $n$-fold IPs, which may possess a large number of constraints, but the constraint matrix satisfies a specific block structure. It is remarkable that these FPT algorithms take as parameters $Δ$ and the number of rows and columns of some small submatrices. If $Δ$ is not treated as a parameter, then the running time becomes pseudo-polynomial even if all the other parameters are taken as constants. This paper explores the trade-off between time and accuracy in solving an IP. We show that, for arbitrary small $\varepsilon>0$, there exists an algorithm for IPs with $m$ constraints that runs in ${f(m,\varepsilon)}\cdot\textnormal{poly}(|I|)$ time, and returns a near-feasible solution that violates the constraints by at most $\varepsilonΔ$. Furthermore, for $n$-fold IPs, we establish a similar result -- our algorithm runs in time that depends on the number of rows and columns of small submatrices together with $1/\varepsilon$, and returns a solution that slightly violates the constraints. Meanwhile, both solutions guarantee that their objective values are no worse than the corresponding optimal objective values satisfying the constraints. As applications, our results can be used to obtain additive approximation schemes for multidimensional knapsack as well as scheduling.

math.OC↗

arXiv2025

Weakly Approximating Knapsack in Subquadratic Time

We consider the classic Knapsack problem. Let $t$ and $\mathrm{OPT}$ be the capacity and the optimal value, respectively. If one seeks a solution with total profit at least $\mathrm{OPT}/(1 + \varepsilon)$ and total weight at most $t$, then Knapsack can be solved in $\tilde{O}(n + (\frac{1}{\varepsilon})^2)$ time [Chen, Lian, Mao, and Zhang '24][Mao '24]. This running time is the best possible (up to a logarithmic factor), assuming that $(\min,+)$-convolution cannot be solved in truly subquadratic time [Künnemann, Paturi, and Schneider '17][Cygan, Mucha, Węgrzycki, and Włodarczyk '19]. The same upper and lower bounds hold if one seeks a solution with total profit at least $\mathrm{OPT}$ and total weight at most $(1 + \varepsilon)t$. Therefore, it is natural to ask the following question. If one seeks a solution with total profit at least $\mathrm{OPT}/(1+\varepsilon)$ and total weight at most $(1 + \varepsilon)t$, can Knsapck be solved in $\tilde{O}(n + (\frac{1}{\varepsilon})^{2-δ})$ time for some constant $δ> 0$? We answer this open question affirmatively by proposing an $\tilde{O}(n + (\frac{1}{\varepsilon})^{7/4})$-time algorithm.

cs.DS↗

arXiv2025

Long Arithmetic Progressions in Sumsets and Subset Sums: Constructive Proofs and Efficient Witnesses

Existence of long arithmetic progression in sumsets and subset sums has been studied extensively in the field of additive combinatorics. These additive combinatorics results play a central role in the recent progress of fundamental problems in theoretical computer science including Knapsack and Subset Sum. The non-constructiveness of relevant additive combinatorics results affects their application in algorithms. In particular, several additive combinatorics-based algorithms for Subset Sum work only for the decision version of the problem, but not for the search version. We provide constructive proofs for finite addition theorems [Sárkőzy'89 '94], which are fundamental results in additive combinatorics concerning the existence of long arithmetic progression in sumsets and subset sums. Our constructive proofs yield a near-linear time algorithm that returns an arithmetic progression explicitly, and moreover, for each term in the arithmetic progression, it also returns its representation as the sum of elements in the base set. As an application, we obtain an $\tilde{O}(n)$-time algorithm for the search version of dense subset sum now. Another application of our result is Unbounded Subset Sum, where each input integer can be used an infinite number of times. A classic result on the Frobenius problem [Erdős and Graham '72] implies that for all $t \geq 2a^2_{\max}/n$, the decision version can be solved trivially in linear time. It remains unknown whether the search version can be solved in the same time. Our result implies that for all $t \geq ca^2_{\max}/n$ for some constant $c$, a solution for Unbounded Subset Sum can be obtained in $O(n \log a_{\max})$ time.

cs.DS↗

arXiv2025

A Note on Deterministic FPTAS for Partition

We consider the Partition problem and propose a deterministic FPTAS (Fully Polynomial-Time Approximation Scheme) that runs in $\widetilde{O}(n + 1/\varepsilon)$-time. This is the best possible (up to a polylogarithmic factor) assuming the Strong Exponential Time Hypothesis~[Abboud, Bringmann, Hermelin, and Shabtay'22]. Prior to our work, only a randomized algorithm can achieve a running time of $\widetilde{O}(n + 1/\varepsilon)$~[Chen, Lian, Mao and Zhang '24], while the best deterministic algorithm runs in $\widetilde{O}(n+1/\varepsilon^{5/4})$ time~[Deng, Jin and Mao '23] and [Wu and Chen '22].

cs.DS↗

arXiv2025

Protecting the Connectivity of a Graph Under Non-Uniform Edge Failures

We study the problem of guaranteeing the connectivity of a given graph by protecting or strengthening edges. Herein, a protected edge is assumed to be robust and will not fail, which features a non-uniform failure model. We introduce the $(p,q)$-Steiner-Connectivity Preservation problem where we protect a minimum-cost set of edges such that the underlying graph maintains $p$-edge-connectivity between given terminal pairs against edge failures, assuming at most $q$ unprotected edges can fail. We design polynomial-time exact algorithms for the cases where $p$ and $q$ are small and approximation algorithms for general values of $p$ and $q$. Additionally, we show that when both $p$ and $q$ are part of the input, even deciding whether a given solution is feasible is NP-complete. This hardness also carries over to Flexible Network Design, a research direction that has gained significant attention. In particular, previous work focuses on problem settings where either $p$ or $q$ is constant, for which our new hardness result now provides justification.

cs.DS↗

arXiv2025

A Nearly Quadratic-Time FPTAS for Knapsack

We investigate the classic Knapsack problem and propose a fully polynomial-time approximation scheme (FPTAS) that runs in $\widetilde{O}(n + (1/\varepsilon)^2)$ time. This improves upon the $\widetilde{O}(n + (1/\varepsilon)^{11/5})$-time algorithm by Deng, Jin, and Mao [\textit{Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms, 2023}]. Our algorithm is the best possible (up to a polylogarithmic factor) conditioned on the conjecture that $(\min, +)$-convolution has no truly subquadratic-time algorithm, since this conjecture implies that Knapsack has no $O((n + 1/\varepsilon)^{2-δ})$-time FPTAS for any constant $δ> 0$.

cs.DS↗

arXiv2024

Approximating Partition in Near-Linear Time

We propose an $\widetilde{O}(n + 1/\eps)$-time FPTAS (Fully Polynomial-Time Approximation Scheme) for the classical Partition problem. This is the best possible (up to a polylogarithmic factor) assuming SETH (Strong Exponential Time Hypothesis) [Abboud, Bringmann, Hermelin, and Shabtay'22]. Prior to our work, the best known FPTAS for Partition runs in $\widetilde{O}(n + 1/\eps^{5/4})$ time [Deng, Jin and Mao'23, Wu and Chen'22]. Our result is obtained by solving a more general problem of weakly approximating Subset Sum.

cs.DS↗

arXiv2023

Faster Algorithms for Bounded Knapsack and Bounded Subset Sum Via Fine-Grained Proximity Results

We investigate pseudopolynomial-time algorithms for Bounded Knapsack and Bounded Subset Sum. Recent years have seen a growing interest in settling their fine-grained complexity with respect to various parameters. For Bounded Knapsack, the number of items $n$ and the maximum item weight $w_{\max}$ are two of the most natural parameters that have been studied extensively in the literature. The previous best running time in terms of $n$ and $w_{\max}$ is $O(n + w^3_{\max})$ [Polak, Rohwedder, Wegrzycki '21]. There is a conditional lower bound of $O((n + w_{\max})^{2-o(1)})$ based on $(\min,+)$-convolution hypothesis [Cygan, Mucha, Wegrzycki, Wlodarczyk '17]. We narrow the gap significantly by proposing a $\tilde{O}(n + w^{12/5}_{\max})$-time algorithm. Note that in the regime where $w_{\max} \approx n$, our algorithm runs in $\tilde{O}(n^{12/5})$ time, while all the previous algorithms require $Ω(n^3)$ time in the worst case. For Bounded Subset Sum, we give two algorithms running in $\tilde{O}(nw_{\max})$ and $\tilde{O}(n + w^{3/2}_{\max})$ time, respectively. These results match the currently best running time for 0-1 Subset Sum. Prior to our work, the best running times (in terms of $n$ and $w_{\max}$) for Bounded Subset Sum is $\tilde{O}(n + w^{5/3}_{\max})$ [Polak, Rohwedder, Wegrzycki '21] and $\tilde{O}(n + μ_{\max}^{1/2}w_{\max}^{3/2})$ [implied by Bringmann '19 and Bringmann, Wellnitz '21], where $μ_{\max}$ refers to the maximum multiplicity of item weights.

cs.DS↗

arXiv2023

Best Cost-Sharing Rule Design for Selfish Bin Packing

In selfish bin packing, each item is regarded as a selfish player, who aims to minimize the cost-share by choosing a bin it can fit in. To have a least number of bins used, cost-sharing rules play an important role. The currently best known cost sharing rule has a \emph{price of anarchy} ($PoA$) larger than 1.45, while a general lower bound 4/3 on $PoA$ applies to any cost-sharing rule under which no items have the incentive to move unilaterally to an empty bin. In this paper, we propose a novel and simple rule with a $PoA$ matching the lower bound of $4/3$, thus completely resolving this game. The new rule always admits a Nash equilibrium and its \emph{price of stability} ($PoS$) is one. Furthermore, the well-known bin packing algorithm $BFD$ (Best-Fit Decreasing) is shown to achieve a strong equilibrium, implying that a stable packing with an asymptotic approximation ratio of $11/9$ can be produced in polynomial time. As an extension of the designing framework, we further study a variant of the selfish scheduling game, and design a best coordination mechanism achieving $PoS=1$ and $PoA=4/3$ as well.

cs.GT↗

arXiv2022

Fair Graphical Resource Allocation with Matching-Induced Utilities

Motivated by real-world applications, we study the fair allocation of graphical resources, where the resources are the vertices in a graph. Upon receiving a set of resources, an agent's utility equals the weight of a maximum matching in the induced subgraph. We care about maximin share (MMS) fairness and envy-freeness up to one item (EF1). Regarding MMS fairness, the problem does not admit a finite approximation ratio for heterogeneous agents. For homogeneous agents, we design constant-approximation polynomial-time algorithms, and also note that significant amount of social welfare is sacrificed inevitably in order to ensure (approximate) MMS fairness. We then consider EF1 allocations whose existence is guaranteed. However, the social welfare guarantee of EF1 allocations cannot be better than $1/n$ for the general case, where $n$ is the number of agents.Fortunately, for three special cases, binary-weight, two-agents and homogeneous-agents, we are able to design polynomial-time algorithms that also ensure a constant fractions of the maximum social welfare.

cs.GT↗

arXiv2022

Approximation Algorithms for Interdiction Problem with Packing Constraints

We study a bilevel optimization problem which is a zero-sum Stackelberg game. In this problem, there are two players, a leader and a follower, who pick items from a common set. Both the leader and the follower have their own (multi-dimensional) budgets, respectively. Each item is associated with a profit, which is the same to the leader and the follower, and will consume the leader's (follower's) budget if it is selected by the leader (follower). The leader and the follower will select items in a sequential way: First, the leader selects items within the leader's budget. Then the follower selects items from the remaining items within the follower's budget. The goal of the leader is to minimize the maximum profit that the follower can obtain. Let $s_A$ and $s_B$ be the dimension of the leader's and follower's budget, respectively. A special case of our problem is the bilevel knapsack problem studied by Caprara et al. [SIAM Journal on Optimization, 2014], where $s_A=s_B=1$. We consider the general problem and obtain an $(s_B+ε)$-approximation algorithm when $s_A$ and $s_B$ are both constant. In particular, if $s_B=1$, our algorithm implies a PTAS for the bilevel knapsack problem, which is the first O(1)-approximation algorithm. We also complement our result by showing that there does not exist any $(4/3-ε)$-approximation algorithm even if $s_A=1$ and $s_B=2$. We also consider a variant of our problem with resource augmentation when $s_A$ and $s_B$ are both part of the input. We obtain an O(1)-approximation algorithm with O(1)-resource augmentation, that is, we give an algorithm that returns a solution which exceeds the given leader's budget by O(1) times, and the objective value achieved by the solution is O(1) times the optimal objective value that respects the leader's budget.

cs.DS↗

arXiv2021

FPT Algorithms for a Special Block-structured Integer Program with Applications in Scheduling

We consider integer programs whose constraint matrix has a special block structure: $\min\{f(x):H_{com}x=b, l\le x\le u,x\in\mathbb{Z}^{t_B+nt_A}\}$, where the objective function $f$ is separable convex and the constraint matrix $H_ {com}$ is composed of small submatrices $A_i,B,C,D_i$ such that the first row is $(C,D_1,D_2,\ldots,D_n)$, the first column is $(C,B,B,\ldots,B)^{\top}$, the main diagonal is $(C,A_1,A_2,\ldots,A_n)$, and the rest entries are 0. Furthermore, $\text{rank}(B)$=1. We study fixed parameter tractable (FPT) algorithms by taking as parameters the number of rows and columns of small submatrices, together with the largest absolute value over their entries. We call the IP (almost) combinatorial 4-block n-fold IP. It generalizes the generalized n-fold IP and is a special case of the generalized 4-block n-fold IP. The existence of FPT algorithms for the generalized 4-block n-fold IP is a major open problem, which motivates us to study special cases of the generalized 4-block n-fold IP to find structural insights. We show the $\ell_{\infty}$-norm of Graver basis elements of combinatorial 4-block n-fold IP is $Ω(n)$. There is some FPT-value $λ$ such that for any nonzero element $g\in\{x: H_{com} x= 0\}$, $λg$ can always be decomposed into Graver basis elements in the same orthant whose $\ell_{\infty}$-norm is FPT-bounded (while g might not admit such a decomposition). Then we can bound the $\ell_{\infty}$-norm of Graver basis elements by $O_{FPT}(n)$ and develop $O_{FPT}({n^4\hat{L}^2})$-time algorithms ($O_{FPT}$ hides a multiplicative FPT-term, and $\hat{L}$ denotes the logarithm of the largest number occurring in the input). As applications, combinatorial 4-block n-fold IP can be used to model some classical problems, including scheduling with rejection and bicriteria scheduling.

math.OC↗

arXiv2021

Approximate Ridesharing of Personal Vehicles Problem

The ridesharing problem is that given a set of trips, each trip consists of an individual, a vehicle of the individual and some requirements, select a subset of trips and use the vehicles of selected trips to deliver all individuals to their destinations satisfying the requirements. Requirements of trips are specified by parameters including source, destination, vehicle capacity, preferred paths of a driver, detour distance and number of stops a driver is willing to make, and time constraints. We analyze the relations between the time complexity and parameters for two optimization problems: minimizing the number of selected vehicles and minimizing total travel distance of the vehicles. We consider the following conditions: (1) all trips have the same source or same destination, (2) no detour is allowed, (3) each participant has one preferred path, (4) no limit on the number of stops, and (5) all trips have the same departure and same arrival time. It is known that both minimization problems are NP-hard if one of Conditions (1), (2) and (3) is not satisfied. We prove that both problems are NP-hard and further show that it is NP-hard to approximate both problems within a constant factor if Conditions (4) or (5) is not satisfied. We give $\frac{K+2}{2}$-approximation algorithms for minimizing the number of selected vehicles when condition (4) is not satisfied, where $K$ is the largest capacity of all vehicles.

cs.DS↗

arXiv2020

Block-structured Integer Programming: Can we Parameterize without the Largest Coefficient?

We consider 4-block $n$-fold integer programming, which can be written as $\max\{w\cdot x: H x=b, l\le x\le u, x\in \mathbb{Z}^{N} \}$ where the constraint matrix $H$ is composed of small submatrices $A,B,C,D$ such that the first row of $H$ is $(C,D,D,\cdots,D)$, the first column of $H$ is $(C,B,B,\cdots,B)$, the main diagonal of $H$ is $(C,A,A,\cdots,A)$, and all the other entries are $0$. The special case where $B=C=0$ is known as $n$-fold integer programming. Prior algorithmic results for 4-block $n$-fold integer programming and its special cases usually take $Δ$, the largest absolute value among entries of $H$ as part of the parameters. In this paper, we explore the possibility of getting rid of $Δ$ from parameters, i.e., we are looking for algorithms that runs polynomially in $\logΔ$. We show that, assuming $\text{P}\neq \text{NP}$, this is not possible even if $A=(1,1,Δ)$ and $B=C=0$. However, this becomes possible if $A=(1,1,\cdots,1)$ or $A\in \mathbb{Z}^{1\times 2}$, or more generally if $A\in\mathbb{Z}^{s_A\times t_A} $ where $t_A=s_A+1$ and the rank of matrix $A$ satisfies that $\text{rank}(A)=s_A$. More precisely, 1. If $A=(1,\ldots,1)\in \mathbb{Z}^{1\times t_A} $, then 4-block $n$-fold IP can be solved in $(t_A+t_B)^{O(t_A+t_B)}\cdot poly(n,\logΔ)$ time. 2. If $A\in\mathbb{Z}^{s_A\times t_A} $, $t_A=s_A+1$ and $\text{rank}(A)=s_A$, then 4-block $n$-fold IP can be solved in $(t_A+t_B)^{O(t_A+t_B)}\cdot n^{O(t_A)}\cdot poly(\logΔ)$ time; Specifically, if in addition we have $B=C=0$ (i.e., $n$-fold integer programming), then it can be solved in linear time $n\cdot poly(t_A,\log Δ)$.

math.OC↗

arXiv2019

Multiple Constrained Routing Algorithms in Large-Scaled Software Defined Networks

In this paper, we consider the bandwidth-delay-hop constrained routing problem in large-scaled software defined networks. A number of demands, each of which specifies a source vertex and a sink vertex, are required to route in a given network. We are asked to select a subset of demands, and assign a routing path for each selected demand without violating the hop and delay constraints, while assuring that the bandwidth occupied in each edge is not beyond its capacity. The goal is to maximize the throughput (the total bandwidth) of the selected demands. We develop an efficient heuristic algorithm for the problem, which consists of three main steps, namely, computing feasible paths for each demand, sorting the demands with some priority rules, selecting a path for each demand. The algorithm is tested with networks of actual sizes and topologies, generated by Huawei Technologies Company. The experiments show that the proposed approach outperforms existing algorithms both in throughput and in running time. In the experiments, our algorithm achieves more than 90\% of the total bandwidth of the given demands within 10 seconds. Moreover, a large part of our algorithm can run in parallel which largely speeds up the process when using multi-core processors.

cs.NI↗