Parameterized Suffix Arrays for Binary Strings

Transcription

1 Parameterized Suffix Arrays for Binary Strings Satoshi Deguchi, Fumihito Higashijima, Hideo Bannai, Shunsuke Inenaga and Masayuki Takeda Kyushu University, Japan

2 Contents Background Parameterized matching [Baker 93] Linear time algorithms for constructing parameterized suffix arrays parameterized LCP arrays for inary strings Computational Experiments Summary and Open Prolems

3 Background sort program y student A void sort(int *a, int n) { int p, q, t; sort program y student B void sort(int *p, int n) { int x, y, t; } for (p = 0; p < n; p++) { for (q = n-1; q > p; q--) { if (a[q] < a[q-1]) { t = a[q]; a[q] = a[q-1]; a[q-1] = t; } } } } for (x = 0; x < n; x++) { for (y = n-1; y > x; y--) { if (p[y] < p[y-1]) { t = p[y]; p[y] = p[y-1]; p[y-1] = t; } } }

4 Parameterized pattern matching Parameterized string [Baker 93] A string over the parameter alphaet Π and constant alphaet Σ (Π Σ = φ) Parameterized match we will only consider the case Σ = φ in this talk. Two parameterized strings x,y parameterized match if there exists a ijection f on Π Σ where f(c) = c for c Σ, and f(x) = f(x 1 x n )=f(x 1 ) f(x n )=y if (a[q] < a[q-1]) { t = a[q]; a[q] = a[q-1]; a[q-1] = t; } q y a p if (p[y] < p[y-1]) { t = p[y]; p[y] = p[y-1]; p[y-1] = t; }

5 Parameterized pattern matching [Baker 93] Parameterized matching prolem Given parameterized strings p and t, find all positions i where p and t i t i+ p -1 parameterized match t : xxyzxyyxzyx p : xyzx x x y z x y y x z y x xyzx xzyx (y z,z y) yxzy (x y,y x) yzxy (x y,y z,z x) zxyz (x z,y x,z y) zyxz (x z,z x)

6 Parameterized pattern matching [Baker 93] pv(s)[i] = 0 if s[i] s[j] for any 1 j < i i k if k = max { j s[i] = s[j] 1 j < i } pv( aaaaaaaa) = Proposition [Baker `93] Two parameterized strings s,t parameterized match pv(s) = pv(t) t:xxyzxyyxzyx p:xyzx pv(yzxy) = 0003 pv(xyzx) = 0003

7 Parameterized suffix tree (p-suffix tree) [Baker 93] parameterized string t O( t ) time * construction 1. aa a a pv() of each suffix p-suffix tree O( p + #occ) time * matching * Assuming constant size alphaet

8 Standard suffix trees and arrays Linear time [Weiner 73] aa Linear time [Ko&Aluru 03, Karkkainen&Sanders 03, Kim et al. 03] suffix tree suffix array SA[] LCP array LCP[] Suffix arrays are reported to e superior in terms of speed/memory usage, for many applications a a a a a a a Linear time (simple traversal) Linear time [Kasai et al. 01]

9 P-suffix trees and arrays 0 Linear time [Baker '93] p-suffix tree 0 1 aa Linear time for inary strings [this work] P-suffix array PSA[] P-LCP array PLCP[] Linear time (simple traversal) Linear time for inary strings [this work]

10 This work We consider the p-suffix array and p-lcp array show linear time algorithms for direct construction of p-suffix array and its p-lcp array for inary strings

11 Difficulties of pv A pv of a suffix is not necessarily a suffix of a pv aaaaaaaa pv(aaaaaaaa) = suffix NOT suffix aaaaaaa pv( aaaaaaa) =

12 Difficulties of pv Lexicographic order etween suffixes of two strings is not necessarily preserved, even when they share a common prefix pv( aaaaaaa) = > pv(aaaaaaaa) = suffix suffix pv( aaaaaaa) = > pv( aaaaaaa) = Linear time algorithms for direct construction of standard suffix arrays won't work on the pv array.

13 Direct construction of p-suffix array for inary strings Oservation Monotonically decrease?

14 fw array fw(s)[i] = if s[i] s[j] for any i < j s i k if k = min { j s[i] = s[j] i < j s } aaaaaaaa fw(aaaaaaaa) = suffix suffix aaaaaaa fw( aaaaaaa) = A fw of a suffix is always a suffix of a fw!

15 Direct construction of p-suffix array Lemma for inary strings For any inary string s, the p-suffix array of s is equivalent to the standard suffix array of fw(s) Theorem The p-suffix array for inary string of length n can e constructed directly in O(n) time. (With the reverse order on integers)

16 Linear time LCP array construction Standard suffix arrays: [Kasai et al. 2001] i SA[i] s[sa[i]:n] LCP s [i] aa a aaaa aaa aa aaa aa 1 lcp[5] 2 1 lcp[8] 2 1 Depends on preservation of lexicographic order of suffixes with common prefix won't work for parameterized strings

17 Lexicographic order is not preserved even when PLCP > 0. 3 < 4 12 > 8 Standard LCP algorithm won't work. PLCP : i PSA[i] s[psa[i]:n] pv(s[psa[i]:n]) PLCP s [i] 1 12 a a aaaaa aa aaaaaaa aaaaaa aaaaaaaa a aaa aaaaaaa aaaa aaaaa

18 Linear time parameterized LCP array construction for Binary Strings The LCP array of fw can e used to compute the PLCP array of pv Lemma For any inary string s, PLCP s [i] = min{ LCP fw(s) [i] +fw(s)[psa[i]+l], s PSA[i 1]+1 } LCP of fw + first disagreeing fw element Length of PSA[i-1] th suffix

19 PLCP s [i] = min{lcp fw(s) [i] +fw(s)[psa[i]+l], s PSA[i 1]+1} i PSA[i] 2 5 s[psa[i]:n] PLCP s [i] fw(s[psa[i]:n]) LCP s [i] 1 12 a -1-1 a0 a0 0 a2 a1 a1 a1 5 0 a2 a1 3 LCP of fw + first disagreeing fw element 2 11 a aaaaa aa LCP of 5fw=1 first 2 disagreeing aaaaaaa fw element= aaaaaa aaaaaaaa a aaa aaaaaaa aaaa aaaaa

20 PLCP s [i] = min{lcp fw(s) [i] +fw(s)[psa[i]+l], s PSA[i 1] +1} Length of PSA[i-1]=10 i PSA[i] s[psa[i]:n] th suffix = 3 PLCPs[i] fw(s[psa[i]:n]) LCP s [i] a a a0 a0 a1 0 1 a3 Length of PSA[i-1] th suffix 3 5 aaaaa aa aaaaaaa LCP of 6fw=1 first 4 disagreeing aaaaaafw element= aaaaaaaa a = aaa aaaaaaa aaaa aaaaa

21 i PSA[i] s[psa[i]:n] PLCP s [i] fw(s[psa[i]:n]) LCP s [i] 1 12 a a 1 1 min{ 0+5, 2 } 3 5 aaaaa aa min{ 2+2, 4 } 5 2 aaaaaaa aaaaaa min{ 1 + 3, 9 } 7 1 aaaaaaaa a aaa Theorem 3 aaaaaaa The PLCP array for inary string of length n can e constructed in O(n) time, given its p-suffix array aaaa aaaaa

22 Computational Experiments We compared speed of parameterized pattern matching on random inary strings y: p-suffix array of t matched with pv(p) standard suffix array t, matched with p and p' 2 standard suffix arrays t and t', each matched with p itwise complement In general, for alphaet size k, we can construct k! standard suffix arrays for each permutation of parameterized alphaet construct k! different patterns for each permutation of parameterized alphaet and do standard matching k! times

23 Text length = 100 Running time p-suffix array pattern length

24 Text length = 1000 Running time p-suffix array pattern length

25 Summary Showed linear time algorithm to construct p-suffix arrays and p-lcp arrays directly from inary strings (does not construct p-suffix tree) Showed efficiency of p-suffix arrays through computational experiments Up to 200% faster than using suffix arrays twice

26 Open Prolems Direct construction of p-suffix array for alphaet size > 2. Reverse prolem: Infer the parameterized string whose p-suffix array is a given permutation.