Algorithmica最新文献

In a seminal paper in 2013, Witt showed that the (1+1) Evolutionary Algorithm with standard bit mutation needs time ((1+o(1))n ln n/p_1) to find the optimum of any linear function, as long as the probability (p_1) to flip exactly one bit is (Theta (1)). In this paper we investigate how this result generalizes if standard bit mutation is replaced by an arbitrary unbiased mutation operator. This situation is notably different, since the stochastic domination argument used for the lower bound by Witt no longer holds. In particular, starting closer to the optimum is not necessarily an advantage, and OneMax is no longer the easiest function for arbitrary starting positions. Nevertheless, we show that Witt’s result carries over if (p_1) is not too small, with different constraints for upper and lower bounds, and if the number of flipped bits has bounded expectation (chi ). Notably, this includes some of the heavy-tail mutation operators used in fast genetic algorithms, but not all of them. We also give examples showing that algorithms with unbounded (chi ) have qualitatively different trajectories close to the optimum.

Interval scheduling is a basic algorithmic problem and a classical task in combinatorial optimization. We develop techniques for partitioning and grouping jobs based on their starting/ending times, enabling us to view an instance of interval scheduling on many jobs as a union of multiple interval scheduling instances, each containing only a few jobs. Instantiating these techniques in a dynamic setting produces several new results. For ((1+varepsilon ))-approximation of job scheduling of n jobs on a single machine, we develop a fully dynamic algorithm with (O(nicefrac {log {n}}{varepsilon })) update and (O(log {n})) query worst-case time. Our techniques are also applicable in a setting where jobs have weights. We design a fully dynamic deterministic algorithm whose worst-case update and query times are (text {poly} (log n,frac{1}{varepsilon })). This is the first algorithm that maintains a ((1+varepsilon ))-approximation of the maximum independent set of a collection of weighted intervals in (text {poly} (log n,frac{1}{varepsilon })) time updates/queries. This is an exponential improvement in (1/varepsilon ) over the running time of an algorithm of Henzinger, Neumann, and Wiese  [SoCG, 2020]. Our approach also removes all dependence on the values of the jobs’ starting/ending times and weights.

We show that, for planar point sets, the number of non-crossing Hamiltonian paths is polynomially bounded in the number of non-crossing paths, and the number of non-crossing Hamiltonian cycles (polygonalizations) is polynomially bounded in the number of surrounding cycles. As a consequence, we can list the non-crossing Hamiltonian paths or the polygonalizations, in time polynomial in the output size, by filtering the output of simple backtracking algorithms for non-crossing paths or surrounding cycles respectively. We do not assume that the points are in general position. To prove these results we relate the numbers of non-crossing structures to two easily-computed parameters of the point set: the minimum number of points whose removal results in a collinear set, and the number of points interior to the convex hull. These relations also lead to polynomial-time approximation algorithms for the numbers of structures of all four types, accurate to within a constant factor of the logarithm of these numbers.

Let X be an n-element point set in the k-dimensional unit cube ([0,1]^k) where (k ge 2). According to an old result of Bollobás and Meir (Oper Res Lett 11:19–21, 1992) , there exists a cycle (tour) (x_1, x_2, ldots , x_n) through the n points, such that (left( sum _{i=1}^n |x_i - x_{i+1}|^k right) ^{1/k} le c_k), where (|x-y|) is the Euclidean distance between x and y, and (c_k) is an absolute constant that depends only on k, where (x_{n+1} equiv x_1). From the other direction, for every (k ge 2) and (n ge 2), there exist n points in ([0,1]^k), such that their shortest tour satisfies (left( sum _{i=1}^n |x_i - x_{i+1}|^k right) ^{1/k} = 2^{1/k} cdot sqrt{k}). For the plane, the best constant is (c_2=2) and this is the only exact value known. Bollobás and Meir showed that one can take (c_k = 9 left( frac{2}{3} right) ^{1/k} cdot sqrt{k}) for every (k ge 3) and conjectured that the best constant is (c_k = 2^{1/k} cdot sqrt{k}), for every (k ge 2). Here we significantly improve the upper bound and show that one can take (c_k = 3 sqrt{5} left( frac{2}{3} right) ^{1/k} cdot sqrt{k}) or (c_k = 2.91 sqrt{k} (1+o_k(1))). Our bounds are constructive. We also show that (c_3 ge 2^{7/6}), which disproves the conjecture for (k=3). Connections to matching problems, power assignment problems, related problems, including algorithms, are discussed in this context. A slightly revised version of the Bollobás–Meir conjecture is proposed.

We consider standard T-interval dynamic networks, under the synchronous timing model and the broadcast CONGEST model. In a T-interval dynamic network, the set of nodes is always fixed and there are no node failures. The edges in the network are always undirected, but the set of edges in the topology may change arbitrarily from round to round, as determined by some adversary and subject to the following constraint: For every T consecutive rounds, the topologies in those rounds must contain a common connected spanning subgraph. Let (H_r) to be the maximum (in terms of number of edges) such subgraph for round r through (r+T-1). We define the backbone diameter d of a T-interval dynamic network to be the maximum diameter of all such (H_r)’s, for (rge 1). We use n to denote the number of nodes in the network. Within such a context, we consider a range of fundamental distributed computing problems including Count/Max/Median/Sum/LeaderElect/Consensus/ConfirmedFlood. Existing algorithms for these problems all have time complexity of (Omega (n)) rounds, even for (T=infty ) and even when d is as small as O(1). This paper presents a novel approach/framework, based on the idea of massively parallel aggregation. Following this approach, we develop a novel deterministic Count algorithm with (O(d^3 log ^2 n)) complexity, for T-interval dynamic networks with (T ge ccdot d^2 log ^2n). Here c is a (sufficiently large) constant independent of d, n, and T. To our knowledge, our algorithm is the very first such algorithm whose complexity does not contain a (Theta (n)) term. This paper further develops novel algorithms for solving Max/Median/Sum/LeaderElect/Consensus/ConfirmedFlood, while incurring (O(d^3 text{ polylog }(n))) complexity. Again, for all these problems, our algorithms are the first ones whose time complexity does not contain a (Theta (n)) term.

Stagnation detection has been proposed as a mechanism for randomized search heuristics to escape from local optima by automatically increasing the size of the neighborhood to find the so-called gap size, i. e., the distance to the next improvement. Its usefulness has mostly been considered in simple multimodal landscapes with few local optima that could be crossed one after another. In multimodal landscapes with a more complex location of optima of similar gap size, stagnation detection suffers from the fact that the neighborhood size is frequently reset to  1 without using gap sizes that were promising in the past. In this paper, we investigate a new mechanism called radius memory which can be added to stagnation detection to control the search radius more carefully by giving preference to values that were successful in the past. We implement this idea in an algorithm called SD-RLS(^{text {m}}) and show compared to previous variants of stagnation detection that it yields speed-ups for linear functions under uniform constraints and the minimum spanning tree problem. Moreover, its running time does not significantly deteriorate on unimodal functions and a generalization of the Jump benchmark. Finally, we present experimental results carried out to study SD-RLS(^{text {m}}) and compare it with other algorithms.

We initiate the investigation of the parameterized complexity of Diameter and Connectivity in the streaming paradigm. On the positive end, we show that knowing a vertex cover of size k allows for algorithms in the Adjacency List (AL) streaming model whose number of passes is constant and memory is (mathcal {O}(log n)) for any fixed k. Underlying these algorithms is a method to execute a breadth-first search in (mathcal {O}(k)) passes and (mathcal {O}(k log n)) bits of memory. On the negative end, we show that many other parameters lead to lower bounds in the AL model, where (Omega (n/p)) bits of memory is needed for any p-pass algorithm even for constant parameter values. In particular, this holds for graphs with a known modulator (deletion set) of constant size to a graph that has no induced subgraph isomorphic to a fixed graph H, for most H. For some cases, we can also show one-pass, (Omega (n log n)) bits of memory lower bounds. We also prove a much stronger (Omega (n^2/p)) lower bound for Diameter on bipartite graphs. Finally, using the insights we developed into streaming parameterized graph exploration algorithms, we show a new streaming kernelization algorithm for computing a vertex cover of size k. This yields a kernel of 2k vertices (with (mathcal {O}(k^2)) edges) produced as a stream in (text {poly}(k)) passes and only (mathcal {O}(k log n)) bits of memory.

The two-watchman route problem is that of computing a pair of closed tours in an environment so that the two tours together see the whole environment and some length measure on the two tours is minimized. Two standard measures are: the minmax measure, where we want the tours where the longest of them has smallest length, and the minsum measure, where we want the tours for which the sum of their lengths is the smallest. It is known that computing a minmax two-watchman route is NP-hard for simple rectilinear polygons and thus also for simple polygons. Also, any c-approximation algorithm for the minmax two-watchman route is automatically a 2c-approximation algorithm for the minsum two-watchman route. We exhibit two constant factor approximation algorithms for computing minmax two-watchman routes in simple polygons with approximation factors 5.969 and 11.939, having running times (O(n^8)) and (O(n^4)) respectively, where n is the number of vertices of the polygon. We also use the same techniques to obtain a 6.922-approximation for the fixed two-watchman route problem running in (O(n^2)) time, i.e., when two starting points of the two tours are given as input.

As proposed by Karppa and Kaski (in: Proceedings 30th ACM-SIAM Symposium on Discrete Algorithms (SODA), 2019) a novel “broken" or "opportunistic" matrix multiplication algorithm, based on a variant of Strassen’s algorithm, and used this to develop new algorithms for Boolean matrix multiplication, among other tasks. Their algorithm can compute Boolean matrix multiplication in (O(n^{2.778})) time. While asymptotically faster matrix multiplication algorithms exist, most such algorithms are infeasible for practical problems. We describe an alternative way to use the broken multiplication algorithm to approximately compute matrix multiplication, either for real-valued or Boolean matrices. In brief, instead of running multiple iterations of the broken algorithm on the original input matrix, we form a new larger matrix by sampling and run a single iteration of the broken algorithm on it. Asymptotically, our algorithm has runtime (O(n^{2.763})), a slight improvement over the Karppa–Kaski algorithm. Since the goal is to obtain new practical matrix-multiplication algorithms, we also estimate the concrete runtime for our algorithm for some large-scale sample problems. It appears that for these parameters, further optimizations are still needed to make our algorithm competitive.

A variant of the online knapsack problem is considered in the setting of predictions. In Unit Profit Knapsack, the items have unit profit, i.e., the goal is to pack as many items as possible. For Online Unit Profit Knapsack, the competitive ratio is unbounded. In contrast, it is easy to find an optimal solution offline: Pack as many of the smallest items as possible into the knapsack. The prediction available to the online algorithm is the average size of those smallest items that fit in the knapsack. For the prediction error in this hard online problem, we use the ratio (r=frac{a}{hat{a}}) where a is the actual value for this average size and (hat{a}) is the prediction. We give an algorithm which is (frac{e-1}{e})-competitive, if (r=1), and this is best possible among online algorithms knowing a and nothing else. More generally, the algorithm has a competitive ratio of (frac{e-1}{e}r), if (r le 1), and (frac{e-r}{e}r), if (1 le r < e). Any algorithm with a better competitive ratio for some (r<1) will have a worse competitive ratio for some (r>1). To obtain a positive competitive ratio for all r, we adjust the algorithm, resulting in a competitive ratio of (frac{1}{2r}) for (rge 1) and (frac{r}{2}) for (rle 1). We show that improving the result for any (r< 1) leads to a worse result for some (r>1).