Comparison-based Algorithm Research Articles

Fragile complexity of adaptive algorithms

The fragile complexity of a comparison-based algorithm is f(n) if each input element participates in O(f(n)) comparisons. In this paper, we explore the fragile complexity of algorithms adaptive to various restrictions on the input, i.e., algorithms with a fragile complexity parameterized by a quantity other than the input size n. We show that searching for the predecessor in a sorted array has fragile complexity Θ(log⁡k), where k is the rank of the query element, both in a randomized and a deterministic setting. For predecessor searches, we also show how to optimally reduce the amortized fragile complexity of the elements in the array. We also prove the following results: Selecting the kth smallest element has expected fragile complexity O(log⁡log⁡k) for the element selected. Deterministically finding the minimum element has fragile complexity Θ(log⁡(Inv)) and Θ(log⁡(Runs)), where Inv is the number of inversions in a sequence and Runs is the number of increasing runs in a sequence. Deterministically finding the median has fragile complexity O(log⁡(Runs)+log⁡log⁡n) and Θ(log⁡(Inv)). Deterministic sorting has fragile complexity Θ(log⁡(Inv)) but it has fragile complexity Θ(log⁡n) regardless of the number of runs.

Fast and Longest Rollercoasters

For kge 3, a k-rollercoaster is a sequence of numbers whose every maximal contiguous subsequence, that is increasing or decreasing, has length at least k; 3-rollercoasters are called simply rollercoasters. Given a sequence of distinct real numbers, we are interested in computing its maximum-length (not necessarily contiguous) subsequence that is a k-rollercoaster. Biedl et al. (in: ICALP, volume 107 of LIPIcs. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, pp 18:1–18:15, 2018) have shown that each sequence of n distinct real numbers contains a rollercoaster of length at least lceil n/2rceil for n>7, and that a longest rollercoaster contained in such a sequence can be computed in O(nlog n)-time (or faster, in O(n log log n) time, when the input sequence is a permutation of {1,ldots ,n}). They have also shown that every sequence of ngeqslant (k-1)^2+1 distinct real numbers contains a k-rollercoaster of length at least frac{n}{2(k-1)}-frac{3k}{2}, and gave an O(nklog n)-time (respectively, O(n klog log n)-time) algorithm computing a longest k-rollercoaster in a sequence of length n (respectively, a permutation of {1,ldots ,n}). In this paper, we give an O(nk^2)-time algorithm computing the length of a longest k-rollercoaster contained in a sequence of n distinct real numbers; hence, for constant k, our algorithm computes the length of a longest k-rollercoaster in optimal linear time. The algorithm can be easily adapted to output the respective k-rollercoaster. In particular, this improves the results of Biedl et al. (2018), by showing that a longest rollercoaster can be computed in optimal linear time. We also present an algorithm computing the length of a longest k-rollercoaster in O(n log ^2 n)-time, that is, subquadratic even for large values of kle n. Again, the rollercoaster can be easily retrieved. Finally, we show an Omega (n log k) lower bound for the number of comparisons in any comparison-based algorithm computing the length of a longest k-rollercoaster.

Comparison-Based Algorithms for One-Dimensional Stochastic Convex Optimization

Stochastic optimization finds a wide range of applications in operations research and management science. However, existing stochastic optimization techniques usually require the information of random samples (e.g., demands in the newsvendor problem) or the objective values at the sampled points (e.g., the lost sales cost), which might not be available in practice. In this paper, we consider a new setup for stochastic optimization, in which the decision maker has access to only comparative information between a random sample and two chosen decision points in each iteration. We propose a comparison-based algorithm (CBA) to solve such problems in one dimension with convex objective functions. Particularly, the CBA properly chooses the two points in each iteration and constructs an unbiased gradient estimate for the original problem. We show that the CBA achieves the same convergence rate as the optimal stochastic gradient methods (with the samples observed). We also consider extensions of our approach to multidimensional quadratic problems as well as problems with nonconvex objective functions. Numerical experiments show that the CBA performs well in test problems.

Array sort: an adaptive sorting algorithm on multi‐thread

Sorting is the most fundamental operation in database system. There are many classical sorting algorithms and among them the most commonly-used sorting algorithm in modern database system is merge sort. Merge sort is an efficient, general-purpose, comparison-based sorting algorithm. As merge sort is based on a divide and conquer model, it has found wide use in parallel computing algorithms. In this study, the authors present an adaptive sorting algorithm based on merge sort which is called array sort. Array sort not only takes advantages of merge sort, but also simplify the merge step by using a tag array. The proposed implementation consists of three phases: tag array creation phase, tag array split phase and list merge phase. Instead of just evaluating array sort in a single thread environment, the authors also run their experiments on multi-thread to test how array sort performs.

Comparison-Based Buffer Management in QoS Switches

The following online problem arises in network devices, e.g., switches, with quality of service (QoS) guarantees. In each time step, an arbitrary number of packets arrive at a single buffer and only one packet can be transmitted. The differentiated service concept is implemented by attributing each packet with a non-negative value corresponding to its service level. The goal is to maximize the total value of transmitted packets. We consider two models of this problem, the FIFO and the bounded-delay model. In the FIFO model, the buffer can store a limited number of packets and the sequence of transmitted packets has to be a subsequence of the arriving packets. In this model, a buffer management algorithm can reject arriving packets and preempt buffered packets. In the bounded-delay model, the buffer has unbounded capacity, but each packet has a deadline and packets can only be transmitted before their deadlines. Here, a buffer management algorithm determines the packet to be sent in each time step. We study comparison-based buffer management algorithms, i.e., algorithms that make their decisions based solely on the relative order between packet values with no regard to the actual values. This kind of algorithm proves to be robust in the realm of QoS switches. Kesselman et al. (SIAM J Comput 33(3):563–583, 2004) present two deterministic comparison-based online algorithms, one for each model, which are 2-competitive. For a long time, it has been an open problem, whether a comparison-based online algorithm exists, in either model, with a competitive ratio below 2. In the FIFO model, we present a lower bound of $$1+1/\sqrt{2} \approx 1.707$$ on the competitive ratio of any deterministic comparison-based algorithm and give an algorithm that matches this lower bound in the case of monotonic sequences, i.e., packets arrive in a non-decreasing order according to their values. In the bounded-delay model, we show that no deterministic comparison-based algorithm exists with a competitive ratio below 2. In the special s-uniform case, where the difference between the arrival time and deadline of any packet equals s, we present a randomized comparison-based algorithm that is 5 / 3-competitive.

Improved Precise Fault Diagnosis Algorithm for Hypercube-Like Systems Based on the Comparison Diagnosis Model

Multiprocessor systems are being increasingly adopted and the system reliability is an important perspective for multiprocessor systems. The fault diagnosis has become crucial for achieving high reliability in multiprocessor systems. The precise fault diagnosis diagnoses all processors correctly. In the comparison-based model, it allows a processor to perform diagnosis by contrasting the responses from a pair of neighboring processors through sending the identical assignment. On the basis of comparison-based model, Sengupta and Dahbura (“On self-diagnosable multiprocessor systems: diagnosis by the comparison approach,” IEEE Transaction on Computers, vol. 41, no. 11, pp. 1386–1396, 1992) put forward the MM* model, any processor c diagnoses two processors c1 and c2 if c has direct communication links to them. Sengupta and Dahbura also designed an O(N5)-time precise fault diagnosis algorithm to diagnose faulty processors for general topologies by using the MM* model, where N is the cardinality of processor set in multiprocessor systems. Lately, Ye and Hsieh (“A scalable comparison-based diagnosis algorithm for hypercube-like net-works,” IEEE Transaction on Reliability, vol. 62, no. 4, pp. 789–799, 2013) devised an precise fault diagnosis algorithm to diagnose all faulty processors for hypercube-like networks by using the MM* model with O(N(log2N)2) time complexity. On the basis of Hamiltonian cycle properties, we improve the aforementioned results by presenting an O(N)-time precise fault diagnosis algorithm to diagnose all faulty processors for hypercube-like networks by using the MM* model.

An in-place heapsort algorithm requiring nlogn+nlog*n−0.546871n comparisons

In this paper, we present an interesting modification to the heap structure which yields a better comparison-based in-place heapsort algorithm. The number of comparisons is shown to be bounded by nlogn+nlog*n−0.546871n which is 0.853129n+nlog*n away from the optimal theoretical bound of nlogn−1.44n.

Deterministic Graphical Games Revisited

Starting from Zermelo’s classical formal treatment of chess, we trace through history the analysis of two-player win/lose/draw games with perfect information and potentially infinite play. Such chess-like games have appeared in many different research communities, and methods for solving them, such as retrograde analysis, have been rediscovered independently. We then revisit Washburn’s deterministic graphical games (DGGs), a natural generalization of chess-like games to arbitrary zero-sum payoffs. We study the complexity of solving DGGs and obtain an almost-linear time comparison-based algorithm for finding optimal strategies in such games. The existence of a linear time comparison-based algorithm remains an open problem.

A Self-Stabilizing O(k)-Time k-Clustering Algorithm

A silent self-stabilizing asynchronous distributed algorithm is given for constructing a k-dominating set, and hence a k-clustering, of a connected network of processes with unique IDs and no designated leader. The algorithm is comparison-based, takes O(k) time and uses O(k log n) space per process, where n is the size of the network. It is known that finding a minimum k-dominating set is 𝒩𝒫-hard. A lower bound is given, showing that any comparison-based algorithm for the k-clustering problem that produces clusters of average size more than 2 in the worst case takes Ω(diam) time, where diam is the diameter of the network.

A Zero-Space algorithm for Negative Cost Cycle Detection in networks

This paper is concerned with the problem of checking whether a network with positive and negative costs on its arcs contains a negative cost cycle. The Negative Cost Cycle Detection (NCCD) problem is one of the more fundamental problems in network design and finds applications in a number of domains ranging from Network Optimization and Operations Research to Constraint Programming and System Verification. As per the literature, approaches to this problem have been either Relaxation-based or Contraction-based. We introduce a fundamentally new approach for negative cost cycle detection; our approach, which we term as the Stressing Algorithm, is based on exploiting the connections between the NCCD problem and the problem of checking whether a system of difference constraints is feasible. The Stressing Algorithm is an incremental, comparison-based procedure which is as efficient as the fastest known comparison-based algorithm for this problem. In particular, on a network with n vertices and m edges, the Stressing Algorithm takes O ( m ⋅ n ) time to detect the presence of a negative cost cycle or to report that none exists. A very important feature of the Stressing Algorithm is that it uses zero extra space; this is in marked contrast to all known algorithms that require Ω ( n ) extra space. It is well known that the NCCD problem is closely related to the Single Source Shortest Paths (SSSP) problem, i.e., the problem of determining the shortest path distances of all the vertices in a network, from a specified source; indeed most algorithms in the literature for the NCCD problem are modifications of approaches to the SSSP problem. At this juncture, it is not clear whether the Stressing Algorithm could be extended to solve the SSSP problem, even if O ( n ) extra space is available.

On the sorting-complexity of suffix tree construction

The suffix tree of a string is the fundamental data structure of combinatorial pattern matching. We present a recursive technique for building suffix trees that yields optimal algorithms in different computational models. Sorting is an inherent bottleneck in building suffix trees and our algorithms match the sorting lower bound. Specifically, we present the following results. (1) Weiner [1973], who introduced the data structure, gave an optimal 0 ( n )-time algorithm for building the suffix tree of an n -character string drawn from a constant-size alphabet. In the comparison model, there is a trivial Ο( n log n )-time lower bound based on sorting, and Weiner's algorithm matches this bound. For integer alphabets, the fastest known algorithm is the O ( n log n )time comparison-based algorithm, but no super-linear lower bound is known. Closing this gap is the main open question in stringology. We settle this open problem by giving a linear time reduction to sorting for building suffix trees. Since sorting is a lower-bound for building suffix trees, this algorithm is time-optimal in every alphabet mode. In particular, for an alphabet consisting of integers in a polynomial range we get the first known linear-time algorithm. (2) All previously known algorithms for building suffix trees exhibit a marked absence of locality of reference, and thus they tend to elicit many page faults (I/Os) when indexing very long strings. They are therefore unsuitable for building suffix trees in secondary storage devices, where I/Os dominate the overall computational cost. We give a linear-I/O reduction to sorting for suffix tree construction. Since sorting is a trivial I/O-lower bound for building suffix trees, our algorithm is I/O-optimal.

Pipelined Diagnosis of Wafer-Scale Linear Arrays

We present a comparison-based algorithm for identifying faulty and fault-free elements in a wafer-scale linear array of processors (or other logic elements). Only nearest neighbor communication is assumed to be possible between the processors in the array. Because the algorithm is simple and requires no storage of test vectors or test outcomes, it is ideally suited for implementation on the wafer to provide the capability for built-in production (or post production) testing. We show that, surprisingly, this method achieves high accuracy of diagnosis over a wide range of yields even though the diagnosis may be based on a high proportion of results produced by faulty processors. We also propose an improvement to the above algorithm which uses a processor diagnosed as fault-free by the basic algorithm as the starting point in improving the accuracy with which faulty processors are identified. Quantitative and qualitative reasoning validate the efficiency of these schemes.