Algorithmica最新文献

We study a common delivery problem encountered in nowadays online food-ordering platforms: Customers order dishes online, and the restaurant delivers the food after receiving the order. Specifically, we study a problem where k vehicles of capacity c are serving a set of requests ordering food from one restaurant. After a request arrives, it can be served by a vehicle moving from the restaurant to its delivery location. We are interested in serving all requests while minimizing the maximum flow-time, i.e., the maximum time length a customer waits to receive his/her food after submitting the order. The problem also has a close connection with the broadcast scheduling problem with maximum flow time objective. We show that the problem is hard in both offline and online settings even when (k = 1) and (c = infty ): There is a hardness of approximation of (Omega (n)) for the offline problem, and a lower bound of (Omega (n)) on the competitive ratio of any online algorithm, where n is number of points in the metric. We circumvent the strong negative results in two directions. Our main result is an O(1)-competitive online algorithm for the uncapaciated (i.e, (c = infty )) food delivery problem on tree metrics; we also have a negative result showing that the condition (c = infty ) is needed. Then we consider the speed-augmentation model, in which our online algorithm is allowed to use (alpha )-speed vehicles, where (alpha ge 1) is called the speeding factor. We develop an exponential time ((1+epsilon ))-speeding (O(1/epsilon ))-competitive algorithm for any (epsilon > 0). A polynomial time algorithm can be obtained with a speeding factor of (alpha _{textsf{TSP}}+ epsilon ) or (alpha _{textsf{CVRP}}+ epsilon ), depending on whether the problem is uncapacitated. Here (alpha _{textsf{TSP}}) and (alpha _{textsf{CVRP}}) are the best approximation factors for the traveling salesman (TSP) and capacitated vehicle routing (CVRP) problems respectively. We complement the results with some negative ones.

We study the problem of counting all cycles or self- avoiding walks (SAWs) on triangulated planar graphs. We present a subexponential (2^{O(sqrt{n})}) time algorithm for this counting problem. Among the technical ingredients used in this algorithm are the planar separator theorem and a delicate analysis using pairs of Motzkin paths and Motzkin numbers. We can then adapt this algorithm to uniformly sample SAWs, in subexponential time. Our work is motivated by the problem of gerrymandered districting maps.

In the Token Sliding problem we are given a graph G and two independent sets (I_s) and (I_t) in G of size (k ge 1). The goal is to decide whether there exists a sequence (langle I_1, I_2, ldots , I_ell rangle ) of independent sets such that for all (j in {1,ldots , ell - 1}) the set (I_j) is an independent set of size k, (I_1 = I_s), (I_ell = I_t) and (I_j triangle I_{j + 1} = {u, v} in E(G)). Intuitively, we view each independent set as a collection of tokens placed on the vertices of the graph. Then, the problem asks whether there exists a sequence of independent sets that transforms (I_s) into (I_t) where at each step we are allowed to slide one token from a vertex to a neighboring vertex. In this paper, we focus on the parameterized complexity of Token Sliding parameterized by k. As shown by Bartier et al. (Algorithmica 83(9):2914–2951, 2021. https://doi.org/10.1007/s00453-021-00848-1), the problem is W[1]-hard on graphs of girth four or less, and the authors posed the question of whether there exists a constant (p ge 5) such that the problem becomes fixed-parameter tractable on graphs of girth at least p. We answer their question positively and prove that the problem is indeed fixed-parameter tractable on graphs of girth five or more, which establishes a full classification of the tractability of Token Sliding parameterized by the number of tokens based on the girth of the input graph.

A map is a partition of the sphere into interior-disjoint regions homeomorphic to closed disks. Some regions are labeled as nations, while the remaining ones are labeled as holes. A map in which at most k nations touch at the same point is a k-map, while it is hole-free if it contains no holes. A graph is a map graph if there is a bijection between its vertices and the nations of a map, such that two nations touch if and only the corresponding vertices are connected by an edge. We present a fixed-parameter tractable algorithm for recognizing map graphs parameterized by treewidth. Its time complexity is linear in the size of the graph. It reports a certificate in the form of a so-called witness, if the input is a yes-instance. Our algorithmic framework is general enough to test, for any k, if the input graph admits a k-map or a hole-free k-map.

Distributed certification, whether it be proof-labeling schemes, locally checkable proofs, etc., deals with the issue of certifying the legality of a distributed system with respect to a given boolean predicate. A certificate is assigned to each process in the system by a non-trustable oracle, and the processes are in charge of verifying these certificates, so that two properties are satisfied: completeness, i.e., for every legal instance, there is a certificate assignment leading all processes to accept, and soundness, i.e., for every illegal instance, and for every certificate assignment, at least one process rejects. The verification of the certificates must be fast, and the certificates themselves must be small. A large quantity of results have been produced in this framework, each aiming at designing a distributed certification mechanism for specific boolean predicates. This paper presents a “meta-theorem”, applying to many boolean predicates at once. Specifically, we prove that, for every boolean predicate on graphs definable in the monadic second-order (MSO) logic of graphs, there exists a distributed certification mechanism using certificates on (O(log ^2n)) bits in n-node graphs of bounded treewidth, with a verification protocol involving a single round of communication between neighbors.

In this paper, we study the following robust optimization problem. Given a set family representing feasibility and candidate objective functions, we choose a feasible set, and then an adversary chooses one objective function, knowing our choice. The goal is to find a randomized strategy (i.e., a probability distribution over the feasible sets) that maximizes the expected objective value in the worst case. This problem is fundamental in wide areas such as artificial intelligence, machine learning, game theory, and optimization. To solve the problem, we provide a general framework based on the dual linear programming problem. In the framework, we utilize the ellipsoid algorithm with the approximate separation algorithm. We prove that there exists an (alpha )-approximation algorithm for our robust optimization problem if there exists an (alpha )-approximation algorithm for finding a (deterministic) feasible set that maximizes a nonnegative linear combination of the candidate objective functions. Using our result, we provide approximation algorithms for the max–min fair randomized allocation problem and the maximum cardinality robustness problem with a knapsack constraint.

In this paper, we consider a general notion of convolution. Let (D) be a finite domain and let (D^n) be the set of n-length vectors (tuples) of (D). Let (f :Dtimes Drightarrow D) be a function and let (oplus _f) be a coordinate-wise application of f. The (f)-Convolution of two functions (g,h :D^n rightarrow {-M,ldots ,M}) is

for every (textbf{v}in D^n). This problem generalizes many fundamental convolutions such as Subset Convolution, XOR Product, Covering Product or Packing Product, etc. For arbitrary function f and domain (D) we can compute (f)-Convolution via brute-force enumeration in (widetilde{{mathcal {O}}}(|D|^{2n} cdot textrm{polylog}(M))) time. Our main result is an improvement over this naive algorithm. We show that (f)-Convolution can be computed exactly in (widetilde{{mathcal {O}}}( (c cdot |D|^2)^{n} cdot textrm{polylog}(M))) for constant (c {:}{=}3/4) when (D) has even cardinality. Our main observation is that a cyclic partition of a function (f :Dtimes Drightarrow D) can be used to speed up the computation of (f)-Convolution, and we show that an appropriate cyclic partition exists for every f. Furthermore, we demonstrate that a single entry of the (f)-Convolution can be computed more efficiently. In this variant, we are given two functions (g,h :D^n rightarrow {-M,ldots ,M}) alongside with a vector (textbf{v}in D^n) and the task of the (f)-Query problem is to compute integer ((g mathbin {circledast _{f}}h)(textbf{v})). This is a generalization of the well-known Orthogonal Vectors problem. We show that (f)-Query can be computed in (widetilde{{mathcal {O}}}(|D|^{frac{omega }{2} n} cdot textrm{polylog}(M))) time, where (omega in [2,2.372)) is the exponent of currently fastest matrix multiplication algorithm.

In the binary networked public goods (BNPG for short) game, every player needs to decide if she participates in a public project whose utility is shared equally by the community. We study the problem of deciding if there exists a pure strategy Nash equilibrium (PSNE) in such games. The problem is already known to be (textsf{NP})-complete. This casts doubt on predictive power of PSNE in BNPG games. We provide fine-grained analysis of this problem under the lens of parameterized complexity theory. We consider various natural graph parameters and show (mathsf {W[1]})-hardness, XP, and (textsf{FPT}) results. Hence, our work significantly improves our understanding of BNPG games where PSNE serves as a reliable solution concept. We finally prove that some graph classes, for example path, cycle, bi-clique, and complete graph, always have a PSNE if the utility function of the players are same.

A well-known approach in the design of efficient algorithms, called matrix sparsification, approximates a matrix A with a sparse matrix (A'). Achlioptas and McSherry (J ACM 54(2):9-es, 2007) initiated a long line of work on spectral-norm sparsification, which aims to guarantee that (Vert A'-AVert le epsilon Vert AVert ) for error parameter (epsilon >0). Various forms of matrix approximation motivate considering this problem with a guarantee according to the Schatten p-norm for general p, which includes the spectral norm as the special case (p=infty ). We investigate the relation between fixed but different (pne q), that is, whether sparsification in the Schatten p-norm implies (existentially and/or algorithmically) sparsification in the Schatten (qtext {-norm}) with similar sparsity. An affirmative answer could be tremendously useful, as it will identify which value of p to focus on. Our main finding is a surprising contrast between this question and the analogous case of (ell _p)-norm sparsification for vectors: For vectors, the answer is affirmative for (p<q) and negative for (p>q), but for matrices we answer negatively for almost all sufficiently distinct (pne q). In addition, our explicit constructions may be of independent interest.

A class of optimal three-weight ([q^k-1,k+1,q^{k-1}(q-1)-1]) cyclic codes over ({mathrm{I!F}}_q), with (kge 2), achieving the Griesmer bound, was presented by Heng and Yue (IEEE Trans Inf Theory 62(8):4501–4513, 2016. https://doi.org/10.1109/TIT.2016.2550029). In this paper we study some of the subfield codes of this class of optimal cyclic codes when (k=2). The weight distributions of the subfield codes are settled. It turns out that some of these codes are optimal and others have the best known parameters. The duals of the subfield codes are also investigated and found to be almost optimal with respect to the sphere-packing bound. In addition, the covering structure for the studied subfield codes is determined. Some of these codes are found to have the important property that any nonzero codeword is minimal, which is a desirable property that is useful in the design of a secret sharing scheme based on a linear code. Moreover, a specific example of a secret sharing scheme based on one of these subfield codes is given. Finally, a class of optimal two-weight linear codes over ({mathrm{I!F}}_q), achieving the Griesmer bound, whose duals are almost optimal with respect to the sphere-packing bound is presented. Through a different approach, this class of optimal two-weight linear codes was reported very recently by Heng (IEEE Trans Inf Theory 69(2):978–994, 2023. https://doi.org/10.1109/TIT.2022.3203380). Furthermore, it is shown that these optimal codes can be used to construct strongly regular graphs.