Average Case Time Complexity Research Articles

Faster classical boson sampling

Since its introduction boson sampling has been the subject of intense study in the world of quantum computing. In the context of Fock-state boson sampling, the task is to sample independently from the set of all n × n submatrices built from possibly repeated rows of a larger m × n complex matrix according to a probability distribution related to the permanents of the submatrices. Experimental systems exploiting quantum photonic effects can in principle perform the task at great speed. For classical computing, Aaronson and Arkhipov (2011) showed that exact boson sampling problem cannot be solved in polynomial time unless the polynomial hierarchy collapses to the third level. Indeed for a number of years the fastest known exact classical algorithm ran in O(m+n−1nn2n) time per sample, emphasising the potential speed advantage of quantum computation. The advantage was reduced by Clifford and Clifford (2018), who gave a significantly faster classical solution taking O(n2n+poly(m,n)) time and linear space, matching the complexity of computing the permanent of a single matrix when m is polynomial in n. We continue by presenting an algorithm for Fock boson sampling whose average-case time complexity is much faster when m is proportional to n. In particular, when m = n our algorithm runs in approximately O(n · 1.69 n ) time on average. This result further increases the problem size needed to establish quantum computational advantage via the Fock scheme of boson sampling.

Correction to: Minimum average case time complexity for sorting algorithms

Correction to: Minimum average case time complexity for sorting algorithms

Minimum average case time complexity for sorting algorithms

Minimum average case time complexity for sorting algorithms

Optimizing Time Complexity of Searching Operation: A Noble Algorithm

By the passage of time , there are many searching algorithm and data structure evolved to make basic operations more efficient with respect to time and space complexity like storing, searching, deleting the data and they play very important role in real-world applications. Based on mechanism of searching, Searching algorithm can be classified into three types of algorithm: linear, binary, hashing, but excluding these, there are many searching techniques proposed by many researchers. The aim of all these proposed searching technique is to optimize the time complexity of searching operation generally compared to Binary Search, which have average and worst case time complexity of log(n), where n is number of elements. This paper proposes a noble searching algorithm that works for sorted array data structure and performs better in most of the cases than that of binary search. The proposed searching Technique will either find index of target element or find a small space within array space by using statistical operation, and then binary search will be applied to that small space, thus it will reduce the overall time complexity. This paper briefly discusses, proposed algorithm and it’s time complexity and comparing the efficiency of the algorithm with some of the well-known other algorithms, using graphs and tables and its practical applications. We will analyze the behavior of algorithm in different parameters like:-size of input data, Nature of elements in list, Different Case Scenario (worst, best, and avg. case) etc.

Memory and communication efficient algorithm for decentralized counting of nodes in networks.

Node counting on a graph is subject to some fundamental theoretical limitations, yet a solution to such problems is necessary in many applications of graph theory to real-world systems, such as collective robotics and distributed sensor networks. Thus several stochastic and naïve deterministic algorithms for distributed graph size estimation or calculation have been provided. Here we present a deterministic and distributed algorithm that allows every node of a connected graph to determine the graph size in finite time, if an upper bound on the graph size is provided. The algorithm consists in the iterative aggregation of information in local hubs which then broadcast it throughout the whole graph. The proposed node-counting algorithm is on average more efficient in terms of node memory and communication cost than its previous deterministic counterpart for node counting, and appears comparable or more efficient in terms of average-case time complexity. As well as node counting, the algorithm is more broadly applicable to problems such as summation over graphs, quorum sensing, and spontaneous hierarchy creation.

The Average-Case Time Complexity of Certifying the Restricted Isometry Property

In compressed sensing, the restricted isometry property (RIP) on $M \times N$ sensing matrices (where $M ) guarantees efficient reconstruction of sparse vectors. A matrix has the $(s,\delta)$ - $\mathsf {RIP}$ property if behaves as a $\delta $ -approximate isometry on $s$ -sparse vectors. It is well known that an $M\times N$ matrix with i.i.d. $\mathcal {N}(0,1/M)$ entries is $(s,\delta)$ - $\mathsf {RIP}$ with high probability as long as $s\lesssim \delta ^{2}~M/\log N$ . On the other hand, most prior works aiming to deterministically construct $(s,\delta)$ - $\mathsf {RIP}$ matrices have failed when $s \gg \sqrt {M}$ . An alternative way to find an RIP matrix could be to draw a random gaussian matrix and certify that it is indeed RIP. However, there is evidence that this certification task is computationally hard when $s \gg \sqrt {M}$ , both in the worst case and the average case. In this paper, we investigate the exact average-case time complexity of certifying the RIP property for $M\times N$ matrices with i.i.d. $\mathcal {N}(0,1/M)$ entries, in the “possible but hard” regime $\sqrt {M} \ll s\lesssim M/\log N$ . Based on analysis of the low-degree likelihood ratio, we give rigorous evidence that subexponential runtime $N^{\tilde \Omega (s^{2}/M)}$ is required, demonstrating a smooth tradeoff between the maximum tolerated sparsity and the required computational power. This lower bound is essentially tight, matching the runtime of an existing algorithm due to Koiran and Zouzias. Our hardness result allows $\delta $ to take any constant value in (0, 1), which captures the relevant regime for compressed sensing. This improves upon the existing average-case hardness result of Wang et al. , which is limited to $\delta = o(1)$ .

Voronoi Diagram and Delaunay Triangulation with Independent and Dependent Geometric Uncertainties

We address the problems of constructing the Voronoi diagram (VD) and Delaunay triangulation (DT) of points in the plane with mutually dependent location uncertainties, testing their stability, and computing their components. Point coordinate uncertainties are modeled with the Linear Parametric Geometric Uncertainty Model (LPGUM), a deterministic, expressive and computationally efficient first order linear approximation of geometric uncertainty that supports parametric dependencies between point locations. We define an uncertain three-point circle and its properties and present in-circle-test algorithms for the dependent and the independent cases whose respective time complexity is [Formula: see text] and [Formula: see text], where [Formula: see text] is the number of parameters that describe the points location uncertainty and [Formula: see text] is the complexity of quartic [Formula: see text]-variable optimization. We define the uncertain VD and DT of [Formula: see text] LPGUM points and show that an unstable VD may have an exponential number of topologically different instances. We describe algorithms for testing VD and DT stability whose time complexity is [Formula: see text] and [Formula: see text] for the dependent and independent cases when the nominal (exact) VD is given. We present algorithms to compute the vertices, edges, and faces of uncertain VD and DT for the independent case whose complexity is [Formula: see text] time and [Formula: see text] space. Finally, we describe algorithms for answering exact and uncertain point location queries in a stable uncertain VD and for dynamically updating it in [Formula: see text] and [Formula: see text] average case time complexity for the independent and dependent cases.

D-PBWT: dynamic positional Burrows-Wheeler transform.

Durbin's positional Burrows-Wheeler transform (PBWT) is a scalable data structure for haplotype matching. It has been successfully applied to identical by descent (IBD) segment identification and genotype imputation. Once the PBWT of a haplotype panel is constructed, it supports efficient retrieval of all shared long segments among all individuals (long matches) and efficient query between an external haplotype and the panel. However, the standard PBWT is an array-based static data structure and does not support dynamic updates of the panel. Here, we generalize the static PBWT to a dynamic data structure, d-PBWT, where the reverse prefix sorting at each position is stored with linked lists. We also developed efficient algorithms for insertion and deletion of individual haplotypes. In addition, we verified that d-PBWT can support all algorithms of PBWT. In doing so, we systematically investigated variations of set maximal match and long match query algorithms: while they all have average case time complexity independent of database size, they have different worst case complexities and dependencies on additional data structures. The benchmarking code is available at genome.ucf.edu/d-PBWT. Supplementary data are available at Bioinformatics online.

Most Valuable Player Algorithm for Solving Minimum Vertex Cover Problem

Minimum Vertex Cover Problem (MVCP) is a combinatorial optimization problem that is utilized to formulate multiple real-life applications. Owing to this fact, abundant research has been undertaken to discover valuable MVCP solutions. Most Valuable Player Algorithm (MVPA) is a recently developed metaheuristic algorithm that inspires its idea from team-based sports. In this paper, the MVPA_MVCP algorithm is introduced as an adaptation of the MVPA for the MVCP. The MVPA_MVCP algorithm is implemented using Java programming language and tested on a Microsoft Azure virtual machine. The performance of the MVPA_MVCP algorithm is evaluated analytically in terms of run time complexity. Its average-case run time complexity is ceased to Θ(I(|V|+|E|)), where I is the size of the initial population, |V| is the number of vertices and |E| is the number of edges of the tested graph. The MVPA_MVCP algorithm is evaluated experimentally in terms of the quality of gained solutions and the run time. The experimental results over 15 instances of DIMACS benchmark revealed that the MVPA_MVCP algorithm could, in the best case, get the best known optimal solution for seven data instances. Also, the experimental findings exposed that there is a direct relation between the number of edges of the graph under test and the run time.

Brownian Motus and Clustered Binary Insertion Sort methods: An efficient progress over traditional methods

Sorting is the basic operation in every application of computer science. The paper proposes two novel sorting algorithms based on the concept of traditional Insertion Sort (IS). Firstly, Brownian Motus Insertion Sort (BMIS) based on IS is proposed. It is followed by Clustered Binary Insertion Sort (CBIS) based on the principles of Binary Insertion Sort (BIS). BIS is a binary search enhancement of IS which is a quite famous variant of it. Average case time complexity of BMIS isO(n0.54); and that of CBIS isO(nlogn). The scenario which results into the worst case of IS is with the complexity ofO(n2); and BIS withO(nlogn) is the best case scenario for BMIS and CBIS with complexity ofO(n). The probability of getting a worst case scenario for BMIS and CBIS is approximately zero. Comparison of proposed algorithms with IS and BIS has been performed at25%,50%,75% and100% level of randomness in the initial dataset. These results lead to prove our claim of devising efficient enhancements of IS. The results further reveal that performance of BMIS and CBIS will increase with a decrease in randomness level of the dataset in comparison to its counterparts. The number of comparisons required by BMIS and CBIS will approach toO(n) with randomness level approach to zero. So, for nearly sorted datasets, our proposed BMIS and CBIS are the best choice. Both BMIS and CBIS are in-place, stable and online sorting algorithm.

Probabilistic quality estimations for combinatorial optimization problems

Abstract The computational complexity of an algorithm is traditionally measured for the worst and the average case. The worst-case estimation guarantees a certain worst-case behavior of a given algorithm, although it might be rough, since in “most instances” the algorithm may have a significantly better performance. The probabilistic average-case analysis claims to derive an average performance of an algorithm, say, for an “average instance” of the problem in question. That instance may be far away from the average of the problem instances arising in a given real-life application, and so the average case analysis would also provide a non-realistic estimation. We suggest that, in general, a wider use of probabilistic models for a more accurate estimation of the algorithm efficiency could be possible. For instance, the quality of the solutions delivered by an approximation algorithm may also be estimated in the “average” probabilistic case. Such an approach would deal with the estimation of the quality of the solutions delivered by the algorithm for the most common (for a given application) problem instances. As we illustrate, the probabilistic modeling can also be used to derive an accurate time complexity performance measure, distinct from the traditional probabilistic average-case time complexity measure. Such an approach could, in particular, be useful when the traditional average-case estimation is still rough or is not possible at all.

Bidirectional Conditional Insertion Sort algorithm; An efficient progress on the classical insertion sort

In this paper, we proposed a new efficient sorting algorithm based on insertion sort concept. The proposed algorithm is called Bidirectional Conditional Insertion Sort (BCIS). It is in-place sorting algorithm and it has remarkably efficient average case time complexity when compared with classical insertion sort (IS). By comparing our new proposed algorithm with the Quicksort algorithm, BCIS indicated faster average case time for relatively small size arrays up to 1500 elements. Furthermore, BCIS was observed to be faster than Quicksort within high rate of duplicated elements even for large size array.

Maximum size of the pareto cost sets for multi-constrained optimal routing

Routing under multiple independent constrains in point-to-point networks has been studied for over 10 years. Its NP-hardness keeps pushing researchers to study approximate algorithms and heuristics, and many results have been published in these years. To the best of our knowledge, the nature of its average case has been explored only for the self-adaptive multiple constraints routing algorithm (SAMCRA), which is an algorithm about multiple constraints routing. In this paper, we simplify SAMCRA into a format that is convenient for our average case analysis. This variant algorithm gives optimal solutions also for very large dimensional networks such as with more than 1000 nodes. Although it runs in exponential time in the worst case, we prove that its average case time complexity is bounded by a polynomial function of the number of nodes in the network. Lastly, we give empirical results that align with our theoretical work.

Matrix Sort - A Parallelizable Sorting Algorithm

Sorting algorithms are the class of algorithms that result in the ordered arrangement of a list of given elements. The arrangement can be in ascending or descending order based on the requirement given. Time complexity, space complexity and optimality are used to assess the algorithms. In this paper, a new sorting algorithm called Matrix sort is introduced. This algorithm aims to sort the elements of a matrix without disturbing the matrix structure. It has a time complexity of O(n p nlog p n) and hence takes lesser time than existing O(n 2 ) algorithms. A pseudocode for the algorithm is provided and the best, average and worst case time complexities are derived.

Stream Kriging: Incremental and recursive ordinary Kriging over spatiotemporal data streams

Ordinary Kriging is widely used for geospatial interpolation and estimation. Due to the O(n3) time complexity of solving the system of linear equations, ordinary Kriging for a large set of source points is computationally intensive. Conducting real-time Kriging interpolation over continuously varying spatiotemporal data streams can therefore be especially challenging. This paper develops and tests two new strategies for improving the performance of an ordinary Kriging interpolator adapted to a stream-processing environment. These strategies rely on the expectation that, over time, source data points will frequently refer to the same spatial locations (for example, where static sensor nodes are generating repeated observations of a dynamic field). First, an incremental strategy improves efficiency in cases where a relatively small proportion of previously processed spatial locations are absent from the source points at any given iteration. Second, a recursive strategy improves efficiency in cases where there is substantial set overlap between the sets of spatial locations of source points at the current and previous iterations. These two strategies are evaluated in terms of their computational efficiency in comparison to ordinary Kriging algorithm. The results show that these two strategies can reduce the time taken to perform the interpolation by up to 90%, and approach average-case time complexity of O(n2) when most but not all source points refer to the same locations over time. By combining the approaches developed in this paper with existing heuristic ordinary Kriging algorithms, the conclusions indicate how further efficiency gains could potentially be accrued. The work ultimately contributes to the development of online ordinary Kriging interpolation algorithms, capable of real-time spatial interpolation with large streaming data sets.

Four Sliding Windows Pattern Matching Algorithm (FSW)

This paper presents an efficient pattern matching algorithm (FSW). FSW improves the searching process for a pattern in a text. It scans the text with the help of four sliding windows. The windows are equal to the length of the pattern, allowing multiple alignments in the searching process. The text is divided into two parts; each part is scanned from both sides simultaneously using two sliding windows. The four windows slide in parallel in both parts of the text. The comparisons done between the text and the pattern are done from both of the pattern sides in parallel. The conducted experiments show that FSW achieves the best overall results in the number of attempts and the number of character comparisons compared to the pattern matching algorithms: Two Sliding Windows (TSW), Enhanced Two Sliding Windows algorithm (ETSW) and Berry-Ravindran algorithm (BR). The best time case is calculated and found to be while the average case time complexity is .

An Efficient Algorithm for the Detection of Eden

In this paper, a polynomial time algorithm is presented for solving the Eden problem for graph cellular automata. The algorithm is based on our neighborhood elimination operation which removes local neighborhood configurations which cannot be used in a pre-image of a given configuration. This paper presents a detailed derivation of our algorithm from first principles, and a detailed complexity and accuracy analysis is also given. In the case of time complexity, it is shown that the average case time complexity of the algorithm is \Theta(n^2), and the best and worst cases are \Omega(n) and O(n^3) respectively. This represents a vast improvement in the upper bound over current methods, without compromising average case performance.

Efficient storage and retrieval in agent protocol libraries using subsumption hierarchies

To be truly adaptive in dynamic environments, agents must be able to interact in ways that were not conceived at design time. One way to achieve this is to use executable protocol specifications, in which participants can share a protocol specification at runtime, and interact using the specified rules. In such a model, it is necessary that an agent can quickly and correctly locate a protocol that achieves its goals. Building on previous work, we present a method for characterising, storing, structuring, and searching protocol libraries. Libraries are represented using subsumption hierarchies, in which the vertices represent characterisations of protocols, and edges record a relation between two characterisations if one characterisation subsumes the other. This structure can be used to prevent searching of irrelevant parts of the library. An experimental analysis demonstrates that searching the library has an average-case time complexity of On, which is the same as a standard linear search, however, the measured time is significantly lower. Despite this, the cost of structuring the library has an average-case time complexity On^2, so the ratio of searches to insertions must be high to gain a benefit.

Implementation of Recursive Brute Force for Solving Motif Finding Problem on Multi-Core

Motif is an over-represented pattern in biological sequence. Motif discovery is a major challenge in bioinformatics. Pattern mismatches phenomena makes motif mining very difficult. Brute Force approaches take exponential time with motif length to solve this problem. In this paper, the authors discuss a Recursive-Brute Force algorithm. Its average case time complexity is exponential with the allowed mutations instead of the motif length. Modern Multi-Core architecture revolution encourages us to parallelize our algorithm. We implement the algorithm using two different approaches. A multi-threaded version (OMP-RBF) is implemented using OpenMP. OMP-RBF suffers from a serious performance degradation due to the heap contention problem. The authors have investigated different solutions to solve the heap contention problem. The second implementation is based on MPI that is called MPI-RBF. The efficient handling of the data locality boost the scalability of the MPI-RBF. The authors prove that MPI approach outperforms OpenMP in such computationally-intensive, memory-intensive, and communication-less problem.

A Distributed Reclustering Hierarchy Routing Protocol Using Social Welfare in Wireless Sensor Networks

In recent years, there has been a rapid proliferation of research concerning Wireless Sensor Networks (WSNs), due to the wide range of potential applications that they can be used for. Lifetime is one of the most important considerations for WSNs due to their inherent energy constraints, and various protocols have been proposed to overcome these difficulties. This study proposes a novel distributed reclustering routing protocol: Predictive and Adaptive Routing Protocol using Energy Welfare (PARPEW). PARPEW incorporates the concept of energy welfare (EW) to achieve both energy efficiency and energy balance simultaneously. PARPEW is equipped with a cluster head (CH) shift mechanism that utilizes predictive energy after transmission for the computation of EW. The average case time complexity of the shift mechanism belongs to [Formula: see text], where [Formula: see text] is the average number of sensors in a cluster in the WSN. Experimental results demonstrate that the new protocol is capable of significantly prolonging the lifetime of WSNs under various scenarios.