Worst-case Time Complexity Research Articles

Delaunay Triangulations of Closed Euclidean d-Orbifolds

We give a definition of the Delaunay triangulation of a point set in a closed Euclidean d-manifold, i.e. a compact quotient space of the Euclidean space for a discrete group of isometries (a so-called Bieberbach group or crystallographic group). We describe a geometric criterion to check whether a partition of the manifold actually forms a triangulation (which subsumes that it is a simplicial complex). We provide an incremental algorithm to compute the Delaunay triangulation of the manifold defined by a given set of input points, if it exists. Otherwise, the algorithm returns the Delaunay triangulation of a finite-sheeted covering space of the manifold. The algorithm has optimal randomized worst-case time and space complexity. It extends to closed Euclidean orbifolds. An implementation for the special case of the 3D flat torus has been released in Cgal 3.5. To the best of our knowledge, this is the first general result on this topic.

Parallel Algorithms for Generating Harmonised State Identifiers and Characterising Sets

Many automated finite state machine (FSM) based test generation algorithms require that a characterising set or a set of harmonised state identifiers is first produced. The only previously published algorithms for partial FSMs were brute-force algorithms with exponential worst case time complexity. This paper presents polynomial time algorithms and also massively parallel implementations of both the polynomial time algorithms and the brute-force algorithms. In the experiments the parallel algorithms scaled better than the sequential algorithms and took much less time. Interestingly, while the parallel version of the polynomial time algorithm was fastest for most sizes of FSMs, the parallel version of the brute-force algorithm scaled better due to lower memory requirements.

Planning Robot Navigation among Movable Obstacles (NAMO) through a Recursive Approach

This paper addresses the NP-complete problem of Navigation Among Movable Obstacles (NAMO) in which a robot is required to find a collision-free path toward a goal through manipulating and transferring some movable objects on its way. The robot's main goal is to optimize a performance criterion such as runtime, length of transit or transfer paths, number of manipulated obstacles, total number of displacements of all objects, etc. We have designed a recursive algorithm capable of solving various NAMO problems, ranging from linear monotone to nonlinear non-monotone, and with convex or concave polygonal obstacles. Through the adopted approach, the original problem is decomposed into recursively-solved subproblems, in each of which only one movable object is manipulated. In each call of the algorithm, first a Visibility Graph determines a path from the robot's current configuration to an intermediate goal configuration, and then a tentative final configuration for the last object intercepting the path is calculated using the Penetration Depth concept. It is assumed that the objects can be pulled or pushed, but not rotated, in a continuous space, and under such assumptions the method is complete and locally optimal for convex objects, with a worst-case time complexity of O(n43m) in which m is the number of movable objects and n is the number of all vertices on them. Several computational experiments showed that compared to the existing methods in the literature, the proposed recursive method achieved equal or smaller number of transferred obstacles or the total number of displacements of all objects in majority of the test problems.

Distributed Maximal Clique Computation and Management

Maximal cliques are elementary substructures in a graph and instrumental in graph analysis such as the structural analysis of many complex networks, graph clustering and community detection, network hierarchy detection, emerging pattern mining, vertex importance measures, etc. However, the number of maximal cliques is also notoriously large even for many small real world graphs. This size problem gives rise to challenges in both computing and managing the set of maximal cliques. Many algorithms for computing maximal cliques have been proposed in the literature; however, most of them are sequential algorithms that cannot scale due to the high complexity of the problem, while existing parallel algorithms for computing maximal cliques are mostly immature and especially suffer from skewed workload. As for managing the set of maximal cliques, which is essential due to its large size, there is barely any efficient method for querying or updating the set of maximal cliques. In this paper, we first propose a distributed algorithm built on a share-nothing architecture for computing the set of maximal cliques. We effectively address the problem of skewed workload distribution due to high-degree vertices, which also leads to drastically reduced worst-case time complexity for computing maximal cliques in common real-world graphs. Then, we propose a set of fundamental query operations and efficient algorithms to process the queries, to aid more efficient and effective analysis of the set of maximal cliques. Finally, we also devise algorithms to support efficient update maintenance of the set of maximal cliques when the underlying graph is updated. We verify the efficiency of our algorithms for computing, querying, and updating the set of maximal cliques with a range of real-world graphs from different application domains.

Construction of Directed Minimum Cost Spanning Tree using Weight Graph

Consider a directed weight graph G = (V, E) with n vertices and m edges. A directed minimum cost spanning tree of a weighted graph is a tree of the graph which contains all the vertices of the graph and the sum of weights of all its edges are minimum among all such possible trees of the directed graph. In this paper, I have proposed a new technique and its equivalent algorithm to construct the directed minimum cost spanning tree of a weight graph. This new algorithm is based on the weight matrix of a weighted graph. The input of the proposed algorithm is the weight matrix M, which consist n2 elements of directed weight graph G. The output of the algorithm is Directed Minimum Cost Spanning Tree. The best case time complexity will be in order of O(m), where m = n-1. The worst case time complexity will be in order of O(m2), where m = n-1.Keywords: Directed Graph, Directed Minimum Cost Spanning Tree, Spanning Tree

Construction of Directed Minimum Cost Spanning Tree using Weight Graph

Consider a directed weight graph G = (V, E) with n vertices and m edges. A directed minimum cost spanning tree of a weighted graph is a tree of the graph which contains all the vertices of the graph and the sum of weights of all its edges are minimum among all such possible trees of the directed graph. In this paper, I have proposed a new technique and its equivalent algorithm to construct the directed minimum cost spanning tree of a weight graph. This new algorithm is based on the weight matrix of a weighted graph. The input of the proposed algorithm is the weight matrix M, which consist n2 elements of directed weight graph G. The output of the algorithm is Directed Minimum Cost Spanning Tree. The best case time complexity will be in order of O(m), where m = n-1. The worst case time complexity will be in order of O(m2), where m = n-1.Keywords: Directed Graph, Directed Minimum Cost Spanning Tree, Spanning Tree

Construction of Directed Minimum Cost Spanning Tree using Weight Graph

Consider a directed weight graph G = (V, E) with n vertices and m edges. A directed minimum cost spanning tree of a weighted graph is a tree of the graph which contains all the vertices of the graph and the sum of weights of all its edges are minimum among all such possible trees of the directed graph. In this paper, I have proposed a new technique and its equivalent algorithm to construct the directed minimum cost spanning tree of a weight graph. This new algorithm is based on the weight matrix of a weighted graph. The input of the proposed algorithm is the weight matrix M, which consist n2 elements of directed weight graph G. The output of the algorithm is Directed Minimum Cost Spanning Tree. The best case time complexity will be in order of O(m), where m = n-1. The worst case time complexity will be in order of O(m2), where m = n-1.

Efficient discovery of periodic-frequent patterns in very large databases

Periodic-frequent patterns (or itemsets) are an important class of regularities that exist in a transactional database. Finding these patterns involves discovering all frequent patterns that satisfy the user-specified maximum periodicity constraint. This constraint controls the maximum inter-arrival time of a pattern in a database. The time complexity to measure periodicity of a pattern is O(n), where n represents the number of timestamps at which the corresponding pattern has appeared in a database. As n usually represents a high value in voluminous databases, determining the periodicity of every candidate pattern in the itemset lattice makes the periodic-frequent pattern mining a computationally expensive process. This paper introduces a novel approach to address this problem. Our approach determines the periodic interestingness of a pattern by adopting greedy search. The basic idea of our approach is to discover all periodic-frequent patterns by eliminating aperiodic patterns based on suboptimal solutions. The best and worst case time complexities of our approach to determine the periodic interestingness of a frequent pattern are O(1) and O(n), respectively. We introduce two pruning techniques and propose a pattern-growth algorithm to find these patterns efficiently. Experimental results show that our algorithm is runtime efficient and highly scalable as well.

Search, propagation, and learning in sequencing and scheduling problems

Sequencing and scheduling involve the organization in time of operations subject to capacity and resource constraints. We propose in this dissertation several improvements to the constraint satisfaction and combinatorial optimization methods for solving these problems. These contributions concern three different aspects: how to choose the next node to explore (search)? how much, and how efficiently, one can reduce the search space (propagation)? and what can be learnt from previous failures (learning)? Our contributions start with an empirical study of search heuristics for the well known car-sequencing problem. This evaluation characterizes the key aspects of a good heuristic and shows that the search strategy is as important as the propagation aspect in this problem. Second, we carefully investigate the propagation aspect in a class of sequencing problems. In particular, we propose an algorithm for filtering a type of sequence constraints which worst case time complexity is lower than the best known upper bound, and indeed optimal. Third, we investigate the impact of clause learning for solving the car-sequencing problem. In particular, we propose reduced explanations for the new filtering. The experimental evaluation shows compelling evidence supporting the importance of clause learning for solving efficiently this problem. Next, we revisit the general approach of lazy generation for the Boolean variables encoding the domains. Our proposition avoids a classical redundancy issue without computational overhead. Finally, we investigate conflict analysis algorithms for solving disjunctive scheduling problems. In particular, we introduce a novel learning procedure tailored to this family of problems. The new conflict analysis differs from conventional methods by learning clauses whose size are not function of the scheduling horizon. Our comprehensive experimental study with traditional academic benchmarks demonstrates the impact of the novel learning scheme that we propose. In particular, we find new lower bounds for a well known scheduling benchmark

New algorithms for pattern matching with wildcards and length constraints

The pattern matching with wildcards and length constraints problem is an interesting problem in the literature whose computational complexity is still open. There are polynomial time exact algorithms for its special cases. There are heuristic algorithms, and online algorithms that do not guarantee an optimal solution to the original problem. We consider two special cases of the problem for which we develop offline solutions. We give an algorithm for one case with provably better worst case time complexity compared to existing algorithms. We present the first exact algorithm for the second case. This algorithm uses integer linear programming (ILP) and it takes polynomial time under certain conditions.

A priority heuristic for the guillotine rectangular packing problem

A new priority heuristic is presented for the guillotine rectangular packing problem. This heuristic first selects one available item for a given position by a priority strategy. Then it divides the remaining space into two rectangular bins and packs them recursively, and its worst-case time complexity is T(n)=O(n2). The proposed algorithm is a general, simple and efficient method, and can solve different packing problems. Computational results on a wide range of benchmark problems have shown that the proposed algorithm outperforms existing heuristics in the literature, on average.

New upper bounds for tight and fast approximation of Fisher’s exact test in dependency rule mining

In the dependency rule mining, the goal is to discover the most significant statistical dependencies among all possible collapsed 2×2 contingency tables. Fisher’s exact test is a robust method to estimate the significance and it enables efficient pruning of the search space. The problem is that evaluating the required p-value can be very laborious and the worst case time complexity is O(n), where n is the data size. The traditional solution is to approximate the significance with the χ2-measure, which can be estimated in a constant time. However, the χ2-measure can produce unreliable results (discover spurious dependencies but miss the most significant dependencies). Furthermore, it does not support efficient pruning of the search space. As a solution, a family of tight upper bounds for Fisher’s p is introduced. The new upper bounds are fast to calculate and approximate Fisher’s p-value accurately. In addition, the new approximations are not sensitive to the data size, distribution, or smallest expected counts like the χ2-based approximation. In practice, the execution time depends on the desired accuracy level. According to experimental evaluation, the simplest upper bounds are already sufficiently accurate for dependency rule mining purposes and they can be estimated in 0.004–0.1% of the time needed for exact calculation. For other purposes (testing very weak dependencies), one may need more accurate approximations, but even they can be calculated in less than 1% of the exact calculation time.

Maximum margin semi-supervised learning with irrelevant data

Semi-supervised learning (SSL) is a typical learning paradigms training a model from both labeled and unlabeled data. The traditional SSL models usually assume unlabeled data are relevant to the labeled data, i.e., following the same distributions of the targeted labeled data. In this paper, we address a different, yet formidable scenario in semi-supervised classification, where the unlabeled data may contain irrelevant data to the labeled data. To tackle this problem, we develop a maximum margin model, named tri-class support vector machine (3C-SVM), to utilize the available training data, while seeking a hyperplane for separating the targeted data well. Our 3C-SVM exhibits several characteristics and advantages. First, it does not need any prior knowledge and explicit assumption on the data relatedness. On the contrary, it can relieve the effect of irrelevant unlabeled data based on the logistic principle and maximum entropy principle. That is, 3C-SVM approaches an ideal classifier. This classifier relies heavily on labeled data and is confident on the relevant data lying far away from the decision hyperplane, while maximally ignoring the irrelevant data, which are hardly distinguished. Second, theoretical analysis is provided to prove that in what condition, the irrelevant data can help to seek the hyperplane. Third, 3C-SVM is a generalized model that unifies several popular maximum margin models, including standard SVMs, Semi-supervised SVMs (S3VMs), and SVMs learned from the universum (U-SVMs) as its special cases. More importantly, we deploy a concave–convex produce to solve the proposed 3C-SVM, transforming the original mixed integer programming, to a semi-definite programming relaxation, and finally to a sequence of quadratic programming subproblems, which yields the same worst case time complexity as that of S3VMs. Finally, we demonstrate the effectiveness and efficiency of our proposed 3C-SVM through systematical experimental comparisons.

Standard Sturmian words and automata minimization algorithms

The study of some close connections between the combinatorial properties of words and the performance of the automata minimization process constitutes the main focus of this paper. These relationships have been, in fact, the basis of the study of the tightness and the extremal cases of Hopcroft's algorithm, that is, up to now, the most efficient minimization method for deterministic finite state automata. Recently, increasing attention has been paid to another minimization method that, unlike the approach proposed by Hopcroft, is not based on refinement of the set of states of the automaton, but on automata operations such as determinization and reverse, and is also applicable to non-deterministic finite automata. However, even for deterministic automata, it was proved that the method incurs, almost surely, in an explosion of the number of the states. Very recently, some polynomial variants of Brzozowski's method have been introduced. In this paper, by using some combinatorial properties of words, we analyze the performance of one of such algorithms when applied to a particular infinite family of automata, called standard word automata, constructed by using standard sturmian words. In particular, Θ(nlog⁡n) is the worst case time complexity when the algorithm is applied to the infinite family of word automata associated to Fibonacci words representing also the worst case of Hopcroft's minimization algorithm.

An algorithm for sorting pancake by restricted reversals

In this paper, we propose an algorithm for sorting n pancakes. The previous studies were focused on finding upper bound or lower bound regarding a limited n-pancake. This study, however, suggests the algorithms for n-pancake with $$n\ge 5$$n?5. The only constraint is that $$n\ge 5$$n?5, which eliminates the very strong constraints [$$n\equiv 0$$n?0 (mod 16), $$n\equiv 0$$n?0 (mod 14), $$n\equiv 3$$n?3 (mod 4), etc.] that were used in previous studies. In addition, the sorting cost of the proposed algorithm is almost a half, from other existing studies, despite the fact that it reduces the degree from $$n-1$$n-1 to $$\frac{n}{2}+1$$n2+1. We define the term `restricted reversal', and based on that terminology, we also propose simple sorting and improved sorting algorithms for the pancake sorting. Further, we examine the worst case time complexity and average time to complete a sort using the suggested algorithms. We also propose sorting costs for the evaluation of similar sorting algorithms such as pancake, burnt pancake, and signed permutation algorithms, and compare the sorting costs and constraints that were found in existing studies. In addition, we propose a burnt pancake sorting algorithm that employs the proposed restricted reversals.

A learning approach to the bandwidth multicolouring problem

In this article, a generalisation of the vertex colouring problem known as bandwidth multicolouring problem (BMCP), in which a set of colours is assigned to each vertex such that the difference between the colours, assigned to each vertex and its neighbours, is by no means less than a predefined threshold, is considered. It is shown that the proposed method can be applied to solve the bandwidth colouring problem (BCP) as well. BMCP is known to be NP-hard in graph theory, and so a large number of approximation solutions, as well as exact algorithms, have been proposed to solve it. In this article, two learning automata-based approximation algorithms are proposed for estimating a near-optimal solution to the BMCP. We show, for the first proposed algorithm, that by choosing a proper learning rate, the algorithm finds the optimal solution with a probability close enough to unity. Moreover, we compute the worst-case time complexity of the first algorithm for finding a 1/(1–ϵ) optimal solution to the given problem. The main advantage of this method is that a trade-off between the running time of algorithm and the colour set size (colouring optimality) can be made, by a proper choice of the learning rate also. Finally, it is shown that the running time of the proposed algorithm is independent of the graph size, and so it is a scalable algorithm for large graphs. The second proposed algorithm is compared with some well-known colouring algorithms and the results show the efficiency of the proposed algorithm in terms of the colour set size and running time of algorithm.

COSPEDTree: COuplet Supertree by Equivalence Partitioning of Taxa Set and DAG Formation

From a set of phylogenetic trees with overlapping taxa set, a supertree exhibits evolutionary relationships among all input taxa. The key is to resolve the contradictory relationships with respect to input trees, between individual taxa subsets. Formulation of this NP hard problem employs either local search heuristics to reduce tree search space, or resolves the conflicts with respect to fixed or varying size subtree level decompositions. Different approximation techniques produce supertrees with considerable performance variations. Moreover, the majority of the algorithms involve high computational complexity, thus not suitable for use on large biological data sets. Current study presents COSPEDTree, a novel method for supertree construction. The technique resolves source tree conflicts by analyzing couplet (taxa pair) relationships for each source trees. Subsequently, individual taxa pairs are resolved with a single relation. To prioritize the consensus relations among individual taxa pairs for resolving them, greedy scoring is employed to assign higher score values for the consensus relations among a taxa pair. Selected set of relations resolving individual taxa pairs is subsequently used to construct a directed acyclic graph (DAG). Vertices of DAG represents a taxa subset inferred from the same speciation event. Thus, COSPEDTree can generate non-binary supertrees as well. Depth first traversal on this DAG yields final supertree. According to the performance metrics on branch dissimilarities (such as FP, FN and RF), COSPEDTree produces mostly conservative, well resolved supertrees. Specifically, RF metrics are mostly lower compared to the reference approaches, and FP values are lower apart from only strictly conservative (or veto) approaches. COSPEDTree has worst case time and space complexities of cubic and quadratic order, respectively, better or comparable to the reference approaches. Such high performance and low computational costs enable COSPEDTree to be applied on large scale biological data sets.

ApproxMap - a method for mapping blank nodes in RDF datasets

Abstract Background Versioning has proven to be essential in areas like software development or data and knowledge management. For systems or applications making use of documents formatted according to the Resource Description Framework (RDF) standard, it is difficult to calculate the difference between two versions, owing to the presence of blank nodes, also known as bnodes in RDF graphs. These are anonymous nodes that can assume different identifiers between versions. In this case, the challenge lies in finding a mapping between the sets of blank nodes in the two versions while minimizing the operations needed to convert one version into another. Methods Within this context, we propose an algorithm, named ApproxMap, for mapping bnodes based on extended concepts of rough set theory, which provides a way to measure the proximity of bnodes and map them with closer approximations. Our heuristic method considers various strategies for reducing both the number of comparisons between blank nodes and the delta between the compared versions. The proposed algorithm has a worst-case time complexity of O(n 2). Results ApproxMap showed satisfactory performance in our groups of experiments, as the algorithm that obtained solutions closest to the optimal values. This algorithm succeeded in finding the optimal delta size in 59% of the tests involving optimal values. ApproxMap achieved a delta size smaller than or equal to those of existing algorithms in at least 95% of the tested cases. Conclusions The results show that the proposed algorithm can be successfully applied to versioning RDF documents, such as that produced by software processes with iterative and incremental development. We recommend applying ApproxMap in various situations, particularly those involving similar versions and directly connected bnodes.

Extended to multi-tilde–bar regular expressions and efficient finite automata constructions

Several algorithms have been designed to convert a regular expression into an equivalent finite automaton. One of the most popular constructions, due to Glushkov and to McNaughton and Yamada, is based on the computation of the Null, First, Last and Follow sets (called Glushkov functions) associated with a linearized version of the expression. Recently Mignot considered a family of extended expressions called Extended to multi-tilde–bar Regular Expressions (EmtbREs) and he showed that, under some restrictions, Glushkov functions can be defined for an EmtbRE. In this paper we present an algorithm which efficiently computes the Glushkov functions of an unrestricted EmtbRE. Our approach is based on a recursive definition of the language associated with an EmtbRE which enlightens the fact that the worst case time complexity of the conversion of an EmtbRE into an automaton is related to the worst case time complexity of the computation of the Null function. Finally we show how to extend the ZPC-structure to EmtbREs, which allows us to apply to this family of extended expressions the efficient constructions based on this structure (in particular the construction of the c-continuation automaton, the position automaton, the follow automaton and the equation automaton).

The capacity-C torch problem

The torch problem (also known as the bridge problem or the flashlight problem) is about getting a number of people across a bridge as quickly as possible under certain constraints. Although a very simply stated problem, the solution is surprisingly non-trivial. The case in which there are just four people and the capacity of the bridge is two is a well-known puzzle, widely publicised on the Internet. We consider the general problem where the number of people, their individual crossing times and the capacity of the bridge are all input parameters. We present two methods to determine the shortest total crossing time: the first expresses the problem as an integer-programming problem that can be solved by a standard linear-programming package, and the second expresses the problem as a shortest-path problem in an acyclic directed graph, i.e. as a dynamic-programming problem. The complexity of the linear-programming solution is difficult to predict; its main purpose is to act as an independent test of the correctness of the results returned by the second solution method. The dynamic-programming solution has best- and worst-case time complexity proportional to the square of the number of people. An empirical comparison of the efficiency of both methods is also presented.