Turtlegons

The Pattern Matching problem with Swaps consists in finding all occurrences of a pattern P in a text T, when disjoint local swaps in the pattern are allowed. In the Approximate Pattern Matching problem with Swaps one seeks, for every text location with a swapped match of P, the number of swaps necessary to obtain a match at the location. In this paper we devise two general algorithms for both Standard and Approximate Pattern Matching with Swaps, named CROSS-SAMPLING and BACKWARD-CROSS-SAMPLING, with a [Formula: see text] and [Formula: see text] worst-case time complexity, respectively. Then we provide efficient implementations of them, based on bit-parallelism, which achieve [Formula: see text] and [Formula: see text] worst-case time complexity, with patterns whose length is comparable to the word-size of the target machine. From an extensive comparison with some of the most effective algorithms for the swap matching problem, it turns out that our algorithms are very flexible and achieve very good results inpractice.

In this paper, we study the problem of designing in-place algorithms for finding the maximum clique in the intersection graphs of axis-parallel rectangles and disks in 2D. We first propose O(n 2logn) time in-place algorithms for finding the maximum clique of the intersection graphs of a set of axis-parallel rectangles of arbitrary sizes. For the rectangle intersection graph of fixed height rectangles, the time complexity can be slightly improved to O(nlogn + nK), where K is the size of the maximum clique. For disk graphs, we consider two variations of the maximum clique problem, namely geometric clique and graphical clique. The time complexity of our algorithm for finding the largest geometric clique is O(n 2logn), and it works for disks of arbitrary radii. For graphical clique, our proposed algorithm works for unit disks (i.e., of same radii) and the worst case time complexity is O(n 2 + mK 4); m is the number of edges in the unit disk intersection graph, and K is the size of the largest clique in that graph. It uses O(n 4) time in-place computation of maximum matching in a bipartite graph, which is of independent interest. All these algorithms need O(1) work space in addition to the input array \(\cal R\).KeywordsBipartite GraphUnit DiskBottom BoundaryMaximum CliqueIntersection GraphThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

We present the first polynomial time algorithm that finds the shortest route in a simple polygon such that all points of the polygon are visible from the route. This route is called the shortest watchman route, and we do not assume any restrictions on the route or on the simple polygon. Our algorithm runs in worst case O(n 6 ) time, but it is adaptive, making it run faster on polygons with a simple structure.

Improved shortest path algorithms for nearly acyclic graphs

Given a sequence T = t0t1 . . . tn-1 of size n = |T|, with symbols from a fixed alphabet Σ, (|Σ| ≤ n), the suffix array provides a listing of all the suffixes of T in a lexicographic order. Given T, the suffix sorting problem is to construct its suffix array. The direct suffix sorting problem is to construct the suffix array of T directly without using the suffix tree data structure. While algorithims for linear time, linear space direct suffix sorting have been proposed, the actual constant in the linear space is still a major concern, given that the applications of suffix trees and suffix arrays (such as in whole-genome analysis) often involve huge data sets. In this work, we reduce the gap between current results and the minimal space requirement. We introduce an algorithm for the direct suffix sorting problem with worst case time complexity in O(n), requiring only (1 2 3 n log n - n log | ∑ |+O(1)) bits in memory space. This implies 5 2 3 n+O(1) bytes for total space requirment, (including space for both the output suffix array and the input sequence T) assuming n ≤ 2 32 ,| ∑ |≤256 , and 4 bytes per integer. The basis of our algorithm is an extension of Shannon-Fano-Elias codes used in source coding and information theory. This is the first time information-theoretic methods have been used as the basis for solving the suffix sorting problem.

The problem of shrinking the connected components of binary images to small residues is addressed. A new parallel algorithm is presented with the lowest known worst case time complexity as measured by iteration counts, i.e. [(nc + nr)/2] iterations where the foreground of the image is contained within a rectangular region of size nc X nr pixels. The new algorithm uses a parallel application of operators with small support. It reduces all connected components in any 2D binary image to certain small 1, 2 or 3 point residues. It is potentially useful as a fundamental step in connected component labeling algorithms implemented as fine grain realizations in 2D mesh computing architectures.© (1997) COPYRIGHT SPIE--The International Society for Optical Engineering. Downloading of the abstract is permitted for personal use only.

We consider dynamic evaluation of algebraic functions (matrix multiplication, determinant, convolution, Fourier transform, etc.) in the model of Reif and Tate; i.e., if f(x1, ..., xn) = (y1, ..., ym) is an algebraic problem, we consider serving on-line requests of the form change input xi to value v or what is the value of output yi?. We present techniques for showing lower bounds on the worst case time complexity per operation for such problems. The first gives lower bounds in a wide range of rather powerful models (for instance history dependent algebraic computation trees over any infinite subset of a field, the integer RAM, and the generalized real RAM model of Ben-Amram and Galil). Using this technique, we show optimal Ω(n) bounds for dynamic matrix-vector product, dynamic matrix multiplication and dynamic discriminant and an Ω(√n) lower bound for dynamic polynomial multiplication (convolution), providing a good match with Reif and Tate's O(√n log n) upper bound. We also show linear lower bounds for dynamic determinant, matrix adjoint and matrix inverse and an Ω(√n) lower bound for the elementary symmetric functions. The second technique is the communication complexity technique of Miltersen, Nisan, Safra, and Wigderson which we apply to the setting of dynamic algebraic problems, obtaining similar lower bounds in the word RAM model. The third technique gives lower bounds in the weaker straight line program model. Using this technique, we show an Ω((log n)2/log log n) lower bound for dynamic discrete Fourier transform. Technical ingredients of our techniques are the incompressibility technique of Ben-Amram and Galil and the lower bound for depth-two superconcentrators of Radhakrishnan and Ta-Shma. The incompressibility technique is extended to arithmetic computation in arbitrary fields. Due to the space constraints imposed by these proceedings, in this version of the paper we only present the third technique, proving the lower bound for dynamic discrete Fourier transform and refer to the full version of the paper which is currently available as a BRICS technical report, for the rest of the proofs.

This paper describes a compile-time garbage collection (ct-gc) method in the setting of a first-order functional language with data structures. The aim is to obtain information on positions in a program where certain heap cells will become obsolete during execution. Therefore we develop an abstract interpretation for the detection of inheritance information which allows us to detect whether the heap cells of an argument will be propagated to the result of a function call. The abstract interpretation itself is independent of the evaluation strategy of the underlying language. However, since the actual deallocations take place after termination of functions, the information obtained by the abstract interpretation can only be applied in an eager context, which may be detected using strictness analysis in a lazy language. In order to increase efficiency we show how the number of recomputations can be decreased by using only parts of the abstract domains. The worst case time complexity is essentially quadratic in the size of the program. We illustrate the method developed in this paper with several examples and we demonstrate how to use the results in an eager implementation. Correctness of the analysis is considered, using a modified denotational semantics as reference point. Experimental results demonstrate the practicability of our method. A main goal of our work is to keep both the run-time and the compile-time overhead as small as possible.KeywordsFunction DefinitionGarbage CollectionAbstract InterpretationFunctional ProgramAbstract DomainThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In steady-state evolutionary algorithms, the parent population is updated each time once a new offspring solution is generated. Due to the updation of the parent population, the non-dominated sorting needs to be applied again and again. The repetition of non-dominated sorting makes steady-state algorithms computationally expensive. But the recent study has identified that the insertion of an offspring solution in the known non-domination level structure of solutions does not change the entire structure. So there is no need to apply the complete non-dominated sorting algorithm again and again. In this regard an efficient non-domination level update approach known as ENLU approach was proposed. In steady-state evolutionary algorithm, the same pair of solutions can be compared multiple times in different generations of the algorithm. In this paper, we have performed the same ENLU approach in a different way so that the same pair of solutions is compared only once if they are in the current population. The worst case time complexity of ENLU approach is O(MN2). So for G generations of the steady-state evolutionary algorithm, the worst case time complexity is GO(MN2). In this paper, we have utilized the same ENLU approach which performs the same number of comparisons all the times. The worst case time complexity of our approach is G(O(MN log N) + O(N2)). However, in terms of space complexity the proposed approach requires O(N2) space as compared to O(N) of the ENLU approach. So we have achieved the speedup at the cost of extra space. At the end, we have explored the possibility of parallelism to make the ENLU approach faster.

We give an efficiently executable specification of the global constraint of lexicographic order in the Constraint Handling Rules (CHR) language. In contrast to previous approaches, the implementation is short and concise without giving up on the best known worst case time complexity. It is incremental and concurrent by nature of CHR. It is provably correct and confluent. It is independent of the underlying constraint system, and therefore not restricted to finite domains. We have found a direct recursive decomposition of the problem. We also show completeness of constraint propagation, i.e. that all possible logical consequences of the constraint are generated by the implementation. Finally, we report about some practical implementation experiments.

Abstract. In this paper we refer to the Temporal Precedence Problem on Pure Pointer Machines . This problem asks for the design of a data structure, maintaining a set of stored elements and supporting the following two operations: insert and precedes . The operation insert (a) introduces a new element a in the structure, while the operation precedes (a,b) returns true iff element a was inserted before element b temporally. In [11] a solution was provided to the problem with worst-case time complexity O (log log n ) per operation and O(n log log n) space, where n is the number of elements inserted. It was also demonstrated that the precedes operation has a lower bound of Ω (log log n ) for the Pure Pointer Machine model of computation. In this paper we present two simple solutions with linear space and worst-case constant insertion time. In addition, we describe two algorithms that can handle the precedes (a,b) operation in O (log log d ) time, where d is the temporal distance between the elements a and b .

This thesis delves into critical challenges associated with subgraph analysis in large-scale graphs. The proliferation of data in domains such as social networks, Internet applications, and biological networks necessitates a deep understanding of relationships modeled as graphs. The complexity and scale of these graphs pose challenges for efficient extraction of meaningful information. The thesis focuses on three interconnected research problems: subgraph counting in fully-dynamic graph streams, k-clique listing in large general graphs, and maximal clique enumeration in large general graphs. The first research problem addresses subgraph counting in fully-dynamic graph streams, where graphs evolve dynamically with edge insertions and deletions. Traditional ap- proaches sample edges uniformly, overlooking the varying importance of edges. The thesis introduces a novel weighted sampling framework, WSD, for fully-dynamic graph streams, which samples the edges based on their weights that indicate their importance and reflect their properties. It determines the weights of edges in a data-driven fashion, using a novel method based on reinforcement learning. We conduct extensive experi- ments to verify that our technique can produce estimates with smaller errors while often running faster compared with existing algorithms. The second research problem focuses on k-clique listing in large general graphs, a critical task for applications such as community detection and network analysis. The state-of-the-art algorithms all adopt a branch-and-bound (BB) framework with a vertex-oriented branching strategy (called VBBkC), which forms a sub-branch by expanding a partial k-clique with a vertex. These algorithms have the time complexity of O(km(\delta/2)^(k-2)), where m is the number of edges in the graph and \delta is the degeneracy of the graph. In this thesis, we propose a BB framework with a new edge-oriented branching (called EBBkC), which forms a sub-branch by expanding a partial k-clique with two vertices that connect each other (which correspond to an edge). We explore various edge orderings for EBBkC such that it achieves a time complexity of O(m\delta + km(\tau/2)^(k-2), where \tau is an integer related to the maximum truss number of the graph and we have \tau<\delta. The time complexity of EBBkC is better than that of VBBkC algorithms for k>3 since both O(m\delta) and O(km(\tau/2)^(k-2) are bounded by O(km(\delta/2)^(k-2)). Furthermore, we develop specialized algorithms for sub-branches on dense graphs so that we can early-terminate them and apply the specialized algorithms. We conduct extensive experiments on 19 real graphs, and the results show that our newly developed EBBkC based algorithms with the early termination technique consistently and largely outperform the state-of-the- art (VBBkC based) algorithms. The third research problem centers on maximal clique enumeration (MCE) in large general graphs, crucial for tasks like community detection and biological network analysis. Existing algorithms typically adopt the branch-and-bound framework with the vertex-oriented Bron-Kerbosch (BK) branching strategy, which forms the sub-branches by expanding the partial clique with a vertex. The state-of-the-arts have a time complexity no better than O(n\delta 3^(\delta/3)), where n is the number of vertices in the graph and \delta is the degeneracy of the graph. We introduce a novel approach, HBBMC, a hybrid framework combining vertex-oriented and edge-oriented BK branching, where the latter adopts a new branch-and-bound framework which forms the sub-branches by expanding the partial clique with a edge. This hybrid strategy enables more efficient pruning of sub-branches, resulting in a worst-case time complexity of O(m\delta + m\tau 3^(\tau/3)), where \tau is related to the maximum truss number. This theoretical result is better than that of the state-of-the-arts when \delta > \tau + (3/ln3) \rho, a condition satisfied by many real-world graphs, where \rho is the edge density of the graph defined as \rho = m/n. To further enhance efficiency, we introduce an early termination technique applicable to all branch-and-bound frameworks, which leverages the topological information of the graphs within the branches. This technique accelerates the enumeration process without affecting worst-case time complexity. Extensive experiments on real and synthetic graphs demonstrate the superior performance of our approach. The proposed HBBMC algorithm with the early termination technique consistently outperforms existing vertex-oriented algorithms. In summary, this thesis makes significant contributions by introducing novel algo- rithms, frameworks, and methodologies to address subgraph-related problems. The pro- posed approaches show superior performance across various real-world and synthetic datasets, providing efficient solutions for graph analysis in large-scale, dynamic, and complex scenarios.

Standard Sturmian words and automata minimization algorithms

We use the concept of pointed pseudo-triangulations to establish new upper and lower bounds on a well known problem from the area of art galleries: What is the worst case optimal number of vertex π-guards that collectively monitor a simple polygon with n vertices? Our results are as follows: (1) Any simple polygon with n vertices can be monitored by at most \lfloor n/2 \rfloor general vertex π-guards. This bound is tight up to an additive constant of 1. (2) Any simple polygon with n vertices, k of which are convex, can be monitored by at most \lfloor (2n – k)/3 \rfloor edge-aligned vertexπ-guards. This is the first non-trivial upper bound for this problem and it is tight for the worst case families of polygons known so far.

GriT-DBSCAN: A spatial clustering algorithm for very large databases