Minimal Suffix and Rotation of a Substring in Optimal Time∗
Total Page:16
File Type:pdf, Size:1020Kb
Load more
Recommended publications
-
Trans-Dichotomous Algorithms for Minimum Spanning Trees and Shortest Paths
JOURNAL or COMPUTER AND SYSTEM SCIENCES 48, 533-551 (1994) Trans-dichotomous Algorithms for Minimum Spanning Trees and Shortest Paths MICHAEL L. FREDMAN* University of California at San Diego, La Jolla, California 92093, and Rutgers University, New Brunswick, New Jersey 08903 AND DAN E. WILLARDt SUNY at Albany, Albany, New York 12203 Received February 5, 1991; revised October 20, 1992 Two algorithms are presented: a linear time algorithm for the minimum spanning tree problem and an O(m + n log n/log log n) implementation of Dijkstra's shortest-path algorithm for a graph with n vertices and m edges. The second algorithm surpasses information theoretic limitations applicable to comparison-based algorithms. Both algorithms utilize new data structures that extend the fusion tree method. © 1994 Academic Press, Inc. 1. INTRODUCTION We extend the fusion tree method [7J to develop a linear-time algorithm for the minimum spanning tree problem and an O(m + n log n/log log n) implementation of Dijkstra's shortest-path algorithm for a graph with n vertices and m edges. The implementation of Dijkstra's algorithm surpasses information theoretic limitations applicable to comparison-based algorithms. Our extension of the fusion tree method involves the development of a new data structure, the atomic heap. The atomic heap accommodates heap (priority queue) operations in constant amortized time under suitable polylog restrictions on the heap size. Our linear-time minimum spanning tree algorithm results from a direct application of the atomic heap. To obtain the shortest-path algorithm, we first use the atomic heat as a building block to construct a new data structure, the AF-heap, which has no explicit size restric- tion and surpasses information theoretic limitations applicable to comparison-based algorithms. -
Tries and String Matching
Tries and String Matching Where We've Been ● Fundamental Data Structures ● Red/black trees, B-trees, RMQ, etc. ● Isometries ● Red/black trees ≡ 2-3-4 trees, binomial heaps ≡ binary numbers, etc. ● Amortized Analysis ● Aggregate, banker's, and potential methods. Where We're Going ● String Data Structures ● Data structures for storing and manipulating text. ● Randomized Data Structures ● Using randomness as a building block. ● Integer Data Structures ● Breaking the Ω(n log n) sorting barrier. ● Dynamic Connectivity ● Maintaining connectivity in an changing world. String Data Structures Text Processing ● String processing shows up everywhere: ● Computational biology: Manipulating DNA sequences. ● NLP: Storing and organizing huge text databases. ● Computer security: Building antivirus databases. ● Many problems have polynomial-time solutions. ● Goal: Design theoretically and practically efficient algorithms that outperform brute-force approaches. Outline for Today ● Tries ● A fundamental building block in string processing algorithms. ● Aho-Corasick String Matching ● A fast and elegant algorithm for searching large texts for known substrings. Tries Ordered Dictionaries ● Suppose we want to store a set of elements supporting the following operations: ● Insertion of new elements. ● Deletion of old elements. ● Membership queries. ● Successor queries. ● Predecessor queries. ● Min/max queries. ● Can use a standard red/black tree or splay tree to get (worst-case or expected) O(log n) implementations of each. A Catch ● Suppose we want to store a set of strings. ● Comparing two strings of lengths r and s takes time O(min{r, s}). ● Operations on a balanced BST or splay tree now take time O(M log n), where M is the length of the longest string in the tree. -
Lecture 1 — 24 January 2017 1 Overview 2 Administrivia 3 The
CS 224: Advanced Algorithms Spring 2017 Lecture 1 | 24 January 2017 Prof. Jelani Nelson Scribe: Jerry Ma 1 Overview We introduce the word RAM model of computation, which features fixed-size storage blocks (\words") similar to modern integer data types. We also introduce the predecessor problem and demonstrate solutions to the problem that are faster than optimal comparison-based methods. 2 Administrivia • Personnel: Jelani Nelson (instructor) and Tom Morgan (TF) • Course site: people.seas.harvard.edu/~cs224 • Course staff email: [email protected] • Prerequisites: CS 124/125 and probability. • Coursework: lecture scribing, problem sets, and a final project. Students will also assist in grading problem sets. No coding. • Topics will include those from CS 124/125 at a deeper level of exposition, as well as entirely new topics. 3 The Predecessor Problem In the predecessor, we wish to maintain a ordered set S = fX1;X2; :::; Xng subject to the prede- cessor query: pred(z) = maxfx 2 Sjx < zg Usually, we do this by representing S in a data structure. In the static predecessor problem, S does not change between pred queries. In the dynamic predecessor problem, S may change through the operations: insert(z): S S [ fzg del(z): S S n fzg For the static predecessor problem, a good solution is to store S as a sorted array. pred can then be implemented via binary search. This requires Θ(n) space, Θ(log n) runtime for pred, and Θ(n log n) preprocessing time. 1 For the dynamic predecessor problem, we can maintain S in a balanced binary search tree, or BBST (e.g. -
Algorithm for Character Recognition Based on the Trie Structure
University of Montana ScholarWorks at University of Montana Graduate Student Theses, Dissertations, & Professional Papers Graduate School 1987 Algorithm for character recognition based on the trie structure Mohammad N. Paryavi The University of Montana Follow this and additional works at: https://scholarworks.umt.edu/etd Let us know how access to this document benefits ou.y Recommended Citation Paryavi, Mohammad N., "Algorithm for character recognition based on the trie structure" (1987). Graduate Student Theses, Dissertations, & Professional Papers. 5091. https://scholarworks.umt.edu/etd/5091 This Thesis is brought to you for free and open access by the Graduate School at ScholarWorks at University of Montana. It has been accepted for inclusion in Graduate Student Theses, Dissertations, & Professional Papers by an authorized administrator of ScholarWorks at University of Montana. For more information, please contact [email protected]. COPYRIGHT ACT OF 1 9 7 6 Th is is an unpublished manuscript in which copyright sub s i s t s , Any further r e p r in t in g of its contents must be approved BY THE AUTHOR, Ma n sfield L ibrary U n iv e r s it y of Montana Date : 1 987__ AN ALGORITHM FOR CHARACTER RECOGNITION BASED ON THE TRIE STRUCTURE By Mohammad N. Paryavi B. A., University of Washington, 1983 Presented in partial fulfillment of the requirements for the degree of Master of Science University of Montana 1987 Approved by lairman, Board of Examiners iean, Graduate School UMI Number: EP40555 All rights reserved INFORMATION TO ALL USERS The quality of this reproduction is dependent upon the quality of the copy submitted. -
Efficient Top-K Algorithms for Approximate Substring Matching
Efficient Top-k Algorithms for Approximate Substring Matching Younghoon Kim Kyuseok Shim Seoul National University Seoul National University Seoul, Korea Seoul, Korea [email protected] [email protected] ABSTRACT to deal with vast amounts of data, retrieving similar strings There is a wide range of applications that require to query becomes a more challenging problem today. a large database of texts to search for similar strings or To handle approximate substring matching, various string substrings. Traditional approximate substring matching re- (dis)similarity measures, such as edit distance, hamming dis- quests a user to specify a similarity threshold. Without top- tance, Jaccard coefficient, cosine similarity and Jaro-Winkler k approximate substring matching, users have to try repeat- distance have been considered [2, 10, 11, 19]. Among them, edly different maximum distance threshold values when the the edit distance is one of the most widely accepted distance proper threshold is unknown in advance. measures for database applications where domain specific In our paper, we first propose the efficient algorithms knowledge is not really available [10, 12, 20, 27]. for finding the top-k approximate substring matches with Based on the edit distance, the approximate string match- a given query string in a set of data strings. To reduce the ing problem is to find every string from a string database number of expensive distance computations, the proposed whose edit distance to the query string is not larger than a algorithms utilize our novel filtering techniques which take given maximum distance threshold. There are diverse appli- advantages of q-grams and inverted q-gram indexes avail- cations requiring approximate string matching. -
Substring Alignment Using Suffix Trees
Substring Alignment using Suffix Trees Martin Kay Stanford University Abstract. Alignment of the sentences of an original text and a translation is considerably better understood than alignment of smaller units such as words and phrases. This paper makes some preliminary proposals for solving the problem of aligning substrings that should be treated as basic translation unites even though they may not begin and end at word boundaries. The pro- posals make crucial use of suffix trees as a way of identifying repeated sub- strings of the texts that occur significantly often. It is fitting that one should take advantage of the few occasions on which one is invited to address an important and prestigious professional meeting like this to depart from the standard practice of reporting results and instead to seek adherents to a new enterprise, even if it is one the details of which one can only partially discern. In this case, I intend to take that opportunity to propose a new direction for a line of work that I first became involved in in the early 1990’s [3]. It had to do with the automatic alignment of the sen- tences of a text with those in its translation into another language. The problem is non- trivial because translators frequently translate one sentence with two, or two with one. Sometimes the departure from the expected one-to-one alignment is even greater. We undertook this work not so much because we thought it was of great importance but be- cause it seemed to us rather audacious to attempt to establish these alignments on the basis of no a priori assumptions about the languages involved or about correspondences between pairs of words. -
Advanced Data Structures 1 Introduction 2 Setting the Stage 3
3 Van Emde Boas Trees Advanced Data Structures Anubhav Baweja May 19, 2020 1 Introduction Design of data structures is important for storing and retrieving information efficiently. All data structures have a set of operations that they support in some time bounds. For instance, balanced binary search trees such as AVL trees support find, insert, delete, and other operations in O(log n) time where n is the number of elements in the tree. In this report we will talk about 2 data structures that support the same operations but in different time complexities. This problem is called the fixed-universe predecessor problem and the two data structures we will be looking at are Van Emde Boas trees and Fusion trees. 2 Setting the stage For this problem, we will make the fixed-universe assumption. That is, the only elements that we care about are w-bit integers. Additionally, we will be working in the word RAM model: so we can assume that w ≥ O(log n) where n is the size of the problem, and we can do operations such as addition, subtraction etc. on w-bit words in O(1) time. These are fair assumptions to make, since these are restrictions and advantages that real computers offer. So now given the data structure T , we want to support the following operations: 1. insert(T, a): insert integer a into T . If it already exists, do not duplicate. 2. delete(T, a): delete integer a from T , if it exists. 3. predecessor(T, a): return the largest b in T such that b ≤ a, if one exists. -
Arxiv:1809.02792V2 [Cs.DS] 4 Jul 2019 Symbol Sequences
Fully-Functional Suffix Trees and Optimal Text Searching in BWT-runs Bounded Space ∗ Travis Gagie1;2, Gonzalo Navarro2;3, and Nicola Prezza4 1 EIT, Diego Portales University, Chile 2 Center for Biotechnology and Bioengineering (CeBiB), Chile 3 Department of Computer Science, University of Chile, Chile 4 Department of Computer Science, University of Pisa, Italy Abstract. Indexing highly repetitive texts | such as genomic databases, software repositories and versioned text collections | has become an important problem since the turn of the millennium. A relevant compressibility measure for repetitive texts is r, the number of runs in their Burrows-Wheeler Transforms (BWTs). One of the earliest indexes for repetitive collections, the Run-Length FM-index, used O(r) space and was able to efficiently count the number of occurrences of a pattern of length m in the text (in loglogarithmic time per pattern symbol, with current techniques). However, it was unable to locate the positions of those occurrences efficiently within a space bounded in terms of r. Since then, a number of other indexes with space bounded by other measures of repetitiveness | the number of phrases in the Lempel-Ziv parse, the size of the smallest grammar generating (only) the text, the size of the smallest automaton recognizing the text factors | have been proposed for efficiently locating, but not directly counting, the occurrences of a pattern. In this paper we close this long-standing problem, showing how to extend the Run-Length FM-index so that it can locate the occ occurrences efficiently within O(r) space (in loglogarithmic time each), and reaching optimal time, O(m + occ), within O(r log logw(σ + n=r)) space, for a text of length n over an alphabet of size σ on a RAM machine with words of w = Ω(log n) bits. -
A Heuristic Algorithm for the N-LCS Problem1
Journal of the Applied Mathematics, Statistics and Informatics (JAMSI), 4 (2008), No. 1 A Heuristic Algorithm for the N-LCS Problem1 MOURAD ELLOUMI AND AHMED MOKADDEM ______________________________________________________________________ Abstract Let f={w1, w2,…,wN}beasetofN strings, a string s is an N-Common Subsequence (N-CS) of f,ifandonlyif, s is a subsequence of each of the N strings of f. Hence, the N-Longest Common Subsequence (N-LCS) problem is defined as follows: Given a set of N strings f={w1, w2,…,wN}findanN-CS of f of maximum length. When N>2, the N-LCS problem becomes NP-hard [Maier 78] and even hard to be approximated [Jiang and Li 95]. In this paper, we present A heuristic algorithm, adopting a regions approach, for the N-LCS problem, where N12. Our algorithm is O(N*L*log(L)) in computing time, where L is the maximum length of a string. During each recursive call to our algorithm : We look for the longest common substrings that appear in the different strings. If we have more than one longest common substring, we do a filtering. Additional Key Words and Phrases: strings, common subsequences, divide-and-conquer strategy, algorithms, complexities. Mathematics Subjekt Classification 2000: 68T20, 68Q25 _______________________________________________________________________ INTRODUCTION Let s = s1s2 ... sm and w = w1w2 ... wn be two strings, we say that a string s is a subsequence of a string w if and only if there is a mapping F : {l, 2, ... , m} → {1, 2, ... , n}suchthatF(i)=k if and only if si= wk and F is a monotone strictly increasing function, i.e., F(i) = u, F(j) = v and i<j imply that u<v [Hirschberg 75]. -
Dynamic Integer Sets with Optimal Rank, Select, and Predecessor
Dynamic Integer Sets with Optimal Rank, Select, and Predecessor Search ∗ Mihai Pˇatra¸scu† Mikkel Thorup‡ University of Copenhagen Abstract We present a data structure representing a dynamic set S of w-bit integers on a w-bit word RAM. With S = n and w log n and space O(n), we support the following standard operations in O(log n/ log| |w) time: ≥ insert(x) sets S = S x . • ∪{ } delete(x) sets S = S x . • \{ } predecessor(x) returns max y S y < x . • { ∈ | } successor(x) returns min y S y x . • { ∈ | ≥ } rank(x) returns # y S y < x . • { ∈ | } select(i) returns y S with rank(y)= i, if any. • ∈ Our O(log n/ log w) bound is optimal for dynamic rank and select, matching a lower bound of Fredman and Saks [STOC’89]. When the word length is large, our time bound is also optimal for dynamic predecessor, matching a static lower bound of Beame and Fich [STOC’99] whenever log n/ log w = O(log w/ log log w). Technically, the most interesting aspect of our data structure is that it supports all operations in constant time for sets of size n = wO(1). This resolves a main open problem of Ajtai, Komlos, and Fredman [FOCS’83]. Ajtai et al. presented such a data structure in Yao’s abstract cell-probe model with w-bit cells/words, but pointed out that the functions used could not be implemented. As a partial solution to the problem, Fredman and Willard [STOC’90] introduced a fusion node that could handle queries in constant time, but used polynomial time on the updates. -
MIT 6.851 Advanced Data Structures Prof
MIT 6.851 Advanced Data Structures Prof. Erik Demaine Spring '12 Scribe Notes Collection TA: Tom Morgan, Justin Zhang Editing: Justin Zhang Contents 1 1. Temporal data structure 1 4 Scribers: Oscar Moll (2012), Aston Motes (2007), Kevin Wang (2007) 1.1 Overview . 4 1.2 Model and definitions . 4 1.3 Partial persistence . 6 1.4 Full persistence . 9 1.5 Confluent Persistence . 12 1.6 Functional persistence . 13 2 2. Temporal data structure 2 14 Scribers: Erek Speed (2012), Victor Jakubiuk (2012), Aston Motes (2007), Kevin Wang (2007) 2.1 Overview . 14 2.2 Retroactivity . 14 3 3. Geometric data structure 1 24 Scribers: Brian Hamrick (2012), Ben Lerner (2012), Keshav Puranmalka (2012) 3.1 Overview . 24 3.2 Planar Point Location . 24 3.3 Orthogonal range searching . 27 3.4 Fractional Cascading . 33 4 4. Geometric data structure 2 35 2 Scribers: Brandon Tran (2012), Nathan Pinsker (2012), Ishaan Chugh (2012), David Stein (2010), Jacob Steinhardt (2010) 4.1 Overview- Geometry II . 35 4.2 3D Orthogonal Range Search in O(lg n) Query Time . 35 4.3 Kinetic Data Structures . 38 5 5. Dynamic optimality 1 42 Scribers: Brian Basham (2012), Travis Hance (2012), Jayson Lynch (2012) 5.1 Overview . 42 5.2 Binary Search Trees . 42 5.3 Splay Trees . 45 5.4 Geometric View . 46 6 6. Dynamic optimality 2 50 Scribers: Aakanksha Sarda (2012), David Field (2012), Leonardo Urbina (2012), Prasant Gopal (2010), Hui Tang (2007), Mike Ebersol (2005) 6.1 Overview . 50 6.2 Independent Rectangle Bounds . 50 6.3 Lower Bounds . -
Open Data Structures (In C++)
Open Data Structures (in C++) Edition 0.1Gβ Pat Morin Contents Acknowledgments ix Why This Book? xi Preface to the C++ Edition xiii 1 Introduction1 1.1 The Need for Efficiency.....................2 1.2 Interfaces.............................4 1.2.1 The Queue, Stack, and Deque Interfaces.......5 1.2.2 The List Interface: Linear Sequences.........6 1.2.3 The USet Interface: Unordered Sets..........8 1.2.4 The SSet Interface: Sorted Sets............8 1.3 Mathematical Background...................9 1.3.1 Exponentials and Logarithms............. 10 1.3.2 Factorials......................... 11 1.3.3 Asymptotic Notation.................. 12 1.3.4 Randomization and Probability............ 15 1.4 The Model of Computation................... 18 1.5 Correctness, Time Complexity, and Space Complexity... 19 1.6 Code Samples.......................... 22 1.7 List of Data Structures..................... 22 1.8 Discussion and Exercises.................... 25 2 Array-Based Lists 29 2.1 ArrayStack: Fast Stack Operations Using an Array..... 31 2.1.1 The Basics........................ 31 Contents 2.1.2 Growing and Shrinking................. 34 2.1.3 Summary......................... 36 2.2 FastArrayStack: An Optimized ArrayStack......... 36 2.3 ArrayQueue: An Array-Based Queue............. 37 2.3.1 Summary......................... 41 2.4 ArrayDeque: Fast Deque Operations Using an Array.... 41 2.4.1 Summary......................... 43 2.5 DualArrayDeque: Building a Deque from Two Stacks.... 44 2.5.1 Balancing......................... 47 2.5.2 Summary......................... 49 2.6 RootishArrayStack: A Space-Efficient Array Stack..... 50 2.6.1 Analysis of Growing and Shrinking.......... 54 2.6.2 Space Usage....................... 55 2.6.3 Summary......................... 56 2.6.4 Computing Square Roots...............