Duel and sweep algorithm for order-preserving pattern matching

TL;DR

This paper introduces an efficient duel-and-sweep algorithm for order-preserving pattern matching, improving speed over previous methods and extending to two-dimensional cases with specific time complexities.

Contribution

The paper presents a novel duel-and-sweep algorithm for order-preserving pattern matching with improved time complexity and extends it to two-dimensional pattern matching.

Findings

Algorithm runs in $O(n + m\log m)$ time generally

Faster than KMP-based algorithms in experiments

Extends to two-dimensional order-preserving pattern matching

Abstract

Given a text $T$ and a pattern $P$ over alphabet $\Sigma$, the classic exact matching problem searches for all occurrences of pattern $P$ in text $T$. Unlike exact matching problem, order-preserving pattern matching (OPPM) considers the relative order of elements, rather than their real values. In this paper, we propose an efficient algorithm for OPPM problem using the "duel-and-sweep" paradigm. Our algorithm runs in $O(n + m\log m)$ time in general and $O(n + m)$ time under an assumption that the characters in a string can be sorted in linear time with respect to the string size. We also perform experiments and show that our algorithm is faster that KMP-based algorithm. Last, we introduce the two-dimensional order preserved pattern matching and give a duel and sweep algorithm that runs in $O(n^2)$ time for duel stage and $O(n^2 m)$ time for sweeping time with $O(m^3)$ preprocessing time.

Tables

Table 1. Table 1 : Z-array of a string S = ( 18 , 22 , 12 , 50 , 10 , 17 ) 𝑆 18 22 12 50 10 17 S=(18,22,12,50,10,17) . For instance, Z S ​ [ 3 ] = 3 subscript 𝑍 𝑆 delimited-[] 3 3 Z_{S}[3]=3 because S [ 1 : 3 ] = ( 18 , 22 , 12 ) ≈ ( 12 , 50 , 10 ) = S [ 3 : 5 ] S[1\!:\!3]=(18,22,12)\approx(12,50,10)=S[3\!:\!5] and S [ 1 : 4 ] = ( 18 , 22 , 12 , 50 ) ≉ ( 12 , 50 , 10 , 17 ) = S [ 3 : 6 ] S[1\!:\!4]=(18,22,12,50)\not\approx(12,50,10,17)=S[3\!:\!6] . 𝐿𝑚𝑎𝑥 S subscript 𝐿𝑚𝑎𝑥 𝑆 \mathit{Lmax}_{S} and 𝐿𝑚𝑖𝑛 S subscript 𝐿𝑚𝑖𝑛 𝑆 \mathit{Lmin}_{S} are also shown.

	$1$	$2$	$3$	$4$	$5$	$6$
$S$	$18$	$22$	$12$	$50$	$10$	$17$
$Z_S$	$6$	$1$	$3$	$1$	$2$	$1$
${\mathrm{𝐿𝑚𝑎𝑥}}_S$	$0$	$1$	$0$	$2$	$0$	$3$
${\mathrm{𝐿𝑚𝑖𝑛}}_S$	$0$	$0$	$1$	$0$	$3$	$1$

Table 2. Table 2 : Computation of Z P , 3 subscript Z P 3 \textit{Z}_{{\textit{{P}}},3} . For P in Fig.  3 , the overlap regions for offset ( 3 , 0 ) 3 0 (3,0) are traversed in left-to-right/top-to-bottom order to obtain P 1 subscript 𝑃 1 P_{1} and P 2 subscript 𝑃 2 P_{2} .

	$1$	$2$	$3$	$4$	$5$	$6$	$7$	$8$	$9$	$10$
$P_1$	$36$	$47$	$42$	$44$	$17$	$39$	$22$	$12$	$24$	$29$
$P_2$	$9$	$49$	$8$	$11$	$12$	$23$	$15$	$27$	$42$	$49$
${\text{Z}}_{\text{P},3}$	$2$	$1$	$2$	$2$	$3$	$1$	$2$	$2$	$2$	$1$

Table 3. Table 3 : Witness pairs for offsets ( 3 , 0 ) 3 0 (3,0) , ( 3 , 1 ) 3 1 (3,1) , ( 3 , 2 ) 3 2 (3,2) , ( 3 , 3 ) 3 3 (3,3) , ( 3 , 3 ) 3 3 (3,3) for P in Fig.  3 .

$(a,b)$	$(3,0)$	$(3,1)$	$(3,2)$	$(3,3)$	$(3,4)$
$z_{a,b}$	$2$	$2$	$3$	$2$	$2$
${\mathrm{𝑊𝐼𝑇}}_{\text{P}}[a,b]$	$⟨(1,1),(2,1)⟩$	$⟨(1,2),(2,1)⟩$	$⟨(2,1),(2,2)⟩$	$⟨(1,2),(2,1)⟩$	$⟨(5,5),(5,5)⟩$

Equations

$${Lmax}_S[i]=j\text{mbox}ifS[j]=\underset{k<i}{\max }\{S[k]\mid S[k]\le S[i]\},$$

$${Lmin}_S[i]=j\text{mbox}ifS[j]=\underset{k<i}{\min }\{S[k]\mid S[k]\ge S[i]\}.$$

$$S[{Lmax}_S[i]]=S[i]⟺S[i]=S[{Lmin}_s[i]],$$

$$S[{Lmax}_S[i]]<S[i]⟺S[i]<S[{Lmin}_s[i]].$$

$$S[i_{max}]=S[i+1]=S[i_{min}]\wedge T[i_{max}]=T[i+1]=T[i_{min}],$$

$$S[i_{max}]<S[i+1]<S[i_{min}]\wedge T[i_{max}]<T[i+1]<T[i_{min}].$$

$$Z_S[i]=\underset{1\le j\le |S|-i+1}{\max }\{j\mid S[1:j]\approx S[i:i+j-1]\}\text{mbox}foreach1\le i\le |S|.$$

$$P[k+i_{max}-1]\ne P[k+j_k-1]\vee P[k+j_k-1]\ne P[k+i_{min}-1]$$

$$P[k+i_{max}-1]\ge P[k+j_k-1]\vee P[k+j_k-1]\ge P[k+i_{min}-1]$$

$${\text{Z}}_{\text{P},a}[i]=\underset{1\le j\le |P_1|-i+1}{\max }\{j\mid P_1[1:j]\approx P_2[i:i+j-1]\}\text{mbox}foreach1\le i\le |P_1|,$$

Full text

1 Introduction

The exact string matching problem is one of the most widely studied problems. Given a text and a pattern, the exact matching problem searches for all occurrences positions of pattern in the text. Motivated by low level image processing, the two-dimensional exact matching problem has been extensively studied in recent decades. Given a text $T$ of size $n\times n$ and a pattern $P$ of size $m\times m$ over alphabet $\Sigma$ of size $\sigma=|\Sigma|$, the exact matching problem on two-dimensional strings searches for all occurrence positions of $P$ in $T$. Bird [4] and Baker [3] proposed two-dimensional exact matching using dictionary matching algorithm and Amir and Farach [2] proposed an algorithm that uses suffix trees. These algorithms require total ordering from the alphabet and run in $O(n^{2}\log\sigma)$ time with $O(m^{2}\log\sigma)$ preprocessing time. Amir et al. [1] also proposed alphabet independent approach to the problem that runs in $O(m^{2}\log\sigma)$ preprocessing time and $O(n^{2})$ matching time.

Unlike the exact matching problem, order-preserving pattern matching (OPPM) considers the relative order of elements, rather than their real values. Order-preserving matching has gained much interest in recent years, due to its applicability in problems where the relative order is compared, rather than the exact value, such as share prices in stock markets, weather data or musical notes.

Kubica et al. [15] and Kim et al. [14] proposed a solution based on KMP algorithm. These algorithms address the one-dimensional OPPM problem and have time complexity of $O(n+m\log m)$. Cho et al. [8] brought forward another algorithm based on the Horspool’s algorithm that uses $q$-grams, which was proven to be experimentally fast. Crochemore et al. [10] proposed data structures for OPPM. On the other hand, Chhabra and Tarhio [7], Faro and Külekci [11] proposed filtration methods which practically fast. Moreover, faster filtration algorithms by using SIMD (Single Instruction Multiple Data) instructions were proposed by Cantone et al. [5], Chhabra et al. [6] and Ueki et al. [16]. They showed that SIMD instructions are efficient in speeding up their algorithms.

In this paper, we propose an algorithm that based on dueling technique [17] for OPPM. Our algorithm runs in $O(n+m\log m)$ time which is as fast as KMP based algorithm. Moreover, we perform experiments those compare the performance of our algorithm with the KMP-based algorithm. The experiment results show that our algorithm is faster that KMP-based algorithm. Last, we introduce the two-dimensional order preserved pattern matching and give a duel and sweep algorithm that runs in $O(n^{2})$ time for duel stage and $O(n^{2}m)$ time for sweeping time with $O(m^{3})$ preprocessing time. To the best of our knowledge, our solution is the first to address the two-dimensional order preserving patern matching problem.

The rest of the paper is organized as follows. In Section 2, we give preliminaries on the problem. In Section 3, we describe the algorithm for OPPM problem. In Section 4 we will show some experiment results those compare the performance of our algorithm with the KMP-based algorithm. In Section 5, we extend the algorithm and describe the method for the two-dimensional OPPM problem. In Section 6, we conclude our work and discuss future work.

2 Preliminaries

We use $\Sigma$ to denote an alphabet of integer symbols such that the comparison of any two symbols can be done in constant time. $\Sigma^{*}$ denotes the set of strings over the alphabet $\Sigma$. For a string $S\in\Sigma^{*}$, we will denote $i$-th element of $S$ by $S[i]$ and a substring of $S$ that starts at the location $i$ and ends at the location $j$ as $S[i\!:\!j]$. We say that two strings $S$ and $T$ of equal length $n$ are order-isomorphic, written $S\approx T$, if $S[i]\leq S[j]\Longleftrightarrow T[i]\leq T[j]$ for all $1\leq i,j\leq n$. For instance, $(12,35,5)\approx(25,30,21)\not\approx(11,13,20)$.

In order to check order-isomorphism of two strings, Kubica et al. [15] introduced 111Similar arrays $\textit{Prev}_{S}$ and $\textit{Next}_{S}$ are introduced in [13]. useful arrays $\mathit{Lmax}_{S}$ and $\mathit{Lmin}_{S}$ defined by

[TABLE]

We use the rightmost (largest) $j$ if there exist more than one such $j$. If there is no such $j$ then we define $\mathit{Lmin}_{S}[i]=0$ and $\mathit{Lmax}_{S}[i]=0$, respectively. From the definition, we can easily observe the following properties.

[TABLE]

Lemma 1** ([15]).**

For a string $S$, let $sort(S)$ be the time required to sort the elements of $S$. $\mathit{Lmax}_{S}$ and $\mathit{Lmin}_{S}$ can be computed in $O(sort(S)+|S|)$ time.

Thus, $\mathit{Lmax}_{S}$ and $\mathit{Lmin}_{S}$ can be computed in $O(|S|\log|S|)$ time in general. Moreover, the computation can be done in $O(|S|)$ time under a natural assumption [15] that the characters of $S$ are elements of the set $\{1,\ldots,|S|^{O(1)}\}$. By using $\mathit{Lmax}_{S}$ and $\mathit{Lmin}_{S}$, order-isomorphism of two strings can be decided as follow.

Lemma 2** ([8]).**

For two strings $S$ and $T$ of length $n$, assume that $S[1\!:\!i]\approx T[1\!:\!i]$ for some $i<n$. Let $i_{\mathit{max}}=\mathit{Lmax}_{S}[i+1]$ and $i_{\mathit{min}}=\mathit{Lmin}_{S}[i+1]$. Then $S[1\!:\!i+1]\approx T[1\!:\!i+1]$ if and only if either of the following two conditions holds.

[TABLE]

We omit the corresponding equalities/inequalities if $i_{\mathit{max}}=0$ or $i_{\mathit{min}}=0$.

Hasan et al. [13] proposed a modification to Z-function, which Gusfield [12] defined for ordinal pattern matching, to make it useful from the order-preserving point of view. For a string $S$, the (modified) Z-array of $S$ is defined by

[TABLE]

In other words, $Z_{S}[i]$ is the length of the longest substring of $S$ that starts at position $i$ and is order-isomorphic with some prefix of $S$. An example of Z-array is illustrated in Table 1.

Lemma 3**.**

([13]) For a string $S$, Z-array $Z_{S}$ can be computed in $O(|S|)$ time, assuming that $\mathit{Lmax}_{S}$ and $\mathit{Lmin}_{S}$ are already computed.

Note that in their original work, Hasan et al. [13] assumed that each character in $S$ is distinct. However, we can extend their algorithm by using Lemma 2 to verify order-isomorphism even when $S$ contains duplicate characters.

3 One-dimensional order-preserving matching

In this section, we will propose an algorithm for one-dimensional OPPM using the “duel-and-sweep” paradigm [1]. In the dueling stage, all possible pairs of candidates “duel” with each other. The surviving candidates are further pruned during the sweeping stage, leaving the candidates that are order-isomorphic with the pattern. Prior to the dueling stage, the pattern is preprocessed to construct a witness table that contains witness pairs for all possible offsets.

Definition 1** (1d-OPPM problem).**

The one-dimensional order-preserving matching problem is defined as follows,

Input:

A text $T\in\Sigma^{*}$ of length $n$ and a pattern $P\in\Sigma^{*}$ of length $m$,

Output:

All occurrences of substrings of $T$ that are order-isomorphic with $P$.

3.1 Pattern preprocessing

Let $a>0$ be an integer such that when $P$ is superimposed on itself with the offset $a$, the overlap regions are not order-isomorphic. We say that a pair $\langle i,j\rangle$ of locations is a witness pair for the offset $a$ if either of the following holds:

• $\bullet$

$P[i]=P[j]\text{ and }P[i+a]\neq P[j+a]$,

• $\bullet$

$P[i]>P[j]\text{ and }P[i+a]\leq P[j+a]$,

• $\bullet$

$P[i]<P[j]\text{ and }P[i+a]\geq P[j+a]$.

Next, we describe how to construct a witness table for $P$, that stores witness pairs for all possible offsets $a$ $(0<a<m)$. For the one-dimensional problem, the witness table $\mathit{WIT\!}_{P}$ is an array of length $m-1$, such that $\mathit{WIT\!}_{P}[a]$ is a witness pair for offset $a$. In the case when there are multiple witness pairs for offset $a$, we take the pair $\langle i,j\rangle$ with the smallest value of $j$ and $i<j$. When the overlap regions are order-isomorphic for offset $a$, which implies that no witness pair exists for $a$, we express it as $\mathit{WIT\!}_{P}[a]=\langle m+1,m+1\rangle$.

Lemma 4**.**

For a pattern $P$ of length $m$, we can construct $\mathit{WIT\!}_{P}$ in $O(m)$ time assuming that $Z_{P}$ is already computed.

Proof.

Remind that $Z_{P}[k]$ is the length of the longest prefix of $P[k\!:\!m]$ that is order-isomorphic with a prefix of $P$. For each $1<k<m$, we have two cases.

Case 1

$Z_{P}[k]=m-k+1$ : Since $P[1\!:\!m-k+1]\approx P[k\!:\!m]$, there is no witness pair for offset $k-1$.

Case 2

$Z_{P}[k]<m-k+1$ : Let $j_{k}=Z_{P}[k]+1$, $i_{\mathit{max}}=\mathit{Lmax}_{P}[j_{k}]$, and $i_{\mathit{min}}=\mathit{Lmin}_{P}[j_{k}]$. Then $P[1\!:\!j_{k}-1]\approx P[k\!:\!k+j_{k}-2]$ and $P[1\!:\!j_{k}]\not\approx P[k\!:\!k+j_{k}-1]$, by the definition of $Z_{P}[k]$. By Lemma 2, neither condition (5) nor (6) holds. If ${P[i_{\mathit{max}}]}=P[j_{k}]$ then $P[j_{k}]=P[i_{\mathit{min}}]$ by property (3), so that

[TABLE]

holds by condition (5). Otherwise, i.e. ${P[i_{\mathit{max}}]}<P[j_{k}]$, we have $P[j_{k}]<P[i_{\mathit{min}}]$ by property (3), so that

[TABLE]

holds by condition (6). Therefore, $\langle i_{\mathit{max}},j_{k}\rangle$ is a witness pair if the leftside of condition (7) or (8) holds, and $\langle i_{\mathit{min}},j_{k}\rangle$ is a witness pair if rightside of condition (7) or (8) holds.

Algorithm 1 describes the procedure. Clearly it runs in $O(m)$ time. ∎

3.2 Dueling stage

A substring of $T$ of length $m$ will be referred to as a candidate. A candidate that starts at the location $x$ will be denoted by $T_{x}$. Witness pairs are useful in the following situation. Let $T_{x}$ and $T_{x+a}$ be two overlapping candidates and $\langle i,j\rangle$ be the witness pair for offset $a$. Without loss of generality, we assume that $P[i]<P[j]$ and $P[i+a]>P[j+a]$.

• $\bullet$

If $T[x+a+i-1]>T[x+a+j-1]$, then $T_{x}\not\approx P$.

• $\bullet$

If $T[x+a+i-1]<T[x+a+j-1]$, then $T_{x+a}\not\approx P$.

Based on this information, we can safely eliminate either candidate $T_{x}$ or $T_{x+a}$ without looking into other locations. This process is called dueling. The procedure for the dueling is described in the Algorithm 2.

Next, we prove that the consistency property is transitive. Suppose $T_{x}$ and $T_{x+a}$ are two overlapping candidates. We say that $T_{x}$ and $T_{x+a}$ are consistent with respect to $P$ if $P[1\!:\!m-a]\approx P[a+1\!:\!m]$. Candidates that do not overlap are trivially consistent.

Lemma 5**.**

For any $a$ and $a^{\prime}$ such that $0<a<a+a^{\prime}<m$, let us consider three candidates $T_{x}$, $T_{x+a}$, and $T_{x+a+a^{\prime}}$. If $T_{x}$ is consistent with $T_{x+a}$ and $T_{x+a}$ is consistent with $T_{x+a+a^{\prime}}$, then $T_{x}$ is consistent with $T_{x+a+a^{\prime}}$.

Proof.

Since $T_{x}$ is consistent with $T_{x+a}$, it follows that $P[1\!:\!m-a]\approx P[a+1\!:\!m]$, so that $P[a^{\prime}+1\!:\!m-a]\approx P[(a+a^{\prime})+1\!:\!m]$. Moreover, since $T_{x+a}$ is consistent with $T_{x+a+a^{\prime}}$, it follows that $P[1\!:\!m-a^{\prime}]\approx P[a^{\prime}+1\!:\!m]$, so that $P[1\!:\!m-a^{\prime}-a]\approx P[a^{\prime}+1\!:\!m-a]$. Thus, $P[1\!:\!m-(a+a^{\prime})]\approx P[(a+a^{\prime})+1\!:\!m]$, which implies that $T_{x}$ is consistent with $T_{x+a+a^{\prime}}$. ∎

During the dueling stage, the candidates are eliminated until all remaining candidates are pairwise consistent. For that purpose, we can apply the dueling algorithm due to Amir et al. [1] developed for ordinal pattern matching.

Lemma 6** ([1]).**

The dueling stage can be done in $O(n^{2})$ time by using $\mathit{WIT\!}_{{\textit{{P}}}}$.

3.3 Sweeping stage

The goal of the sweeping stage is to prune candidates until all remaining candidates are order-isomorphic with the pattern. Suppose that we need to check whether some surviving candidate $T_{x}$ is order-isomorphic with the pattern $P$. It suffices to successively check the conditions (7) and (8) in Lemma 2, starting from the leftmost location in $T_{x}$. If the conditions are satisfied for all locations in $T_{x}$, then $T_{x}\approx P$. Otherwise, $T_{x}\not\approx P$, and obtain a mismatch position $j$.

A naive implementation of the sweeping will result in $O(n^{2})$ time. However, if we take advantage of the fact that all the remaining candidates are pairwise consistent, we can reduce the time complexity to $O(n)$ time. Since the remaining candidates are consistent to each other, for the overlapping candidates $T_{x}$ and $T_{x+a}$, the overlap region is checked only once if $T_{x}$ is order-isomorphic with the pattern $P$. Otherwise, for a mismatch position $j$, $T_{x+a}$ should be checked from position $j-a+1$ of $T_{x+a}$, because $P[a:j-1]\approx T_{x}[a\!:\!j-1]\approx T_{x+a}[1\!:\!j-a]$. Algorithm 3 describes the procedure for the sweeping stage.

Lemma 7**.**

The sweeping stage can be completed in $O(n)$ time.

By Lemmas 4, 6, and 7, we summarize this section as follows.

Theorem 1**.**

The duel-and-sweep algorithm solves 1d-OPPM Problem in $O(n+m\log m)$ time. Moreover, the running time is $O(n+m)$ under the natural assumption that the characters of $P$ can be sorted in $O(m)$ time.

4 Experiment

In order to compare the performance of proposed algorithm with the KMP-based algorithm, we conducted experiments on 1d-OPPM problem. We performed two sets of experiments. In the first experiment, the pattern size $m$ is fixed to $10$, while the text size $n$ is changed from $100000$ to $1000000$. In the second experiment, the text size $n$ is fixed to $1000000$ while the pattern size $m$ is changed from $m$ $5$ to $100$. We measured the average of running time and the number of comparisons for $50$ repetitions on each experiment. We used randomly generated texts and patterns with alphabet size $|\Sigma|=1000$. Experiments are executed on a machine with Intel Xeon CPU E5-2609 8 cores 2.40 GHz, 256 GB memory, and Debian Wheezy operating system.

The results of our preliminary experiments are shown in Fig. 1 and Fig. 2. We can see that our algorithm is better that KMP based algorithm in running time and number of comparison when the pattern size and text size are large. However, our algorithm is worse when the pattern size is small, less than $10$.

5 Two-dimensional order preserving pattern matching

In this section, we will discuss how to perform two-dimensional order preserving pattern matching (2d-OPPM). Array indexing is used for two-dimensional strings, the horizontal coordinate $x$ increases from left to right and the vertical coordinate $y$ increases from top to bottom. ${\textit{{S}}}[x,y]$ denotes an element of S at position $(x,y)$ and ${\textit{{S}}}[x\!:\!x+w-1,y\!:\!y+h-1]$ denotes a substring of S of size $w\times h$ with top-left corner at the position $(x,y)$.

We say that two dimensional strings S and T are order-isomorphic, written ${\textit{{S}}}\approx{\textit{{T}}}$, if ${\textit{{S}}}[i_{x},i_{y}]\leq{\textit{{S}}}[j_{x},j_{y}]\Longleftrightarrow{\textit{{T}}}[i_{x},i_{y}]\leq{\textit{{T}}}[j_{x},j_{y}]$ for all $1\leq i_{x},j_{x}\leq w$ and $1\leq i_{y},j_{y}\leq h$. For a simple presentation, we assume that both text and pattern are squares $(w=h)$ in this paper, but we can generalize it straightforwardly.

Definition 2** (2d-OPPM problem).**

The two-dimensional order-preserving matching problem is defined as follows,

Input:

A text T of size $n\times n$ and a pattern P of size $m\times m$,

Output:

All occurrences of substrings of T that are order-isomorphic with P.

Our approach is to reduce 2d-OPPM problem into 1d-OPPM problem, based on the following observation. For two-dimensional string S, let $\textit{serial}({\textit{{S}}})$ be a (one-dimensional) string which serializing S by traversing it in the left-to-right/top-to-bottom order. We can easily verify the following lemma.

Lemma 8**.**

${\textit{{S}}}\approx{\textit{{T}}}$* if and only if $\textit{serial}({\textit{{S}}})\approx\textit{serial}({\textit{{T}}})$ for any S and T.*

Theorem 2**.**

2d-OPPM problem can be solved in $O(n^{2}m+m^{2}\log{m})$.

Proof.

For a fixed $1\leq x\leq n-m+1$, consider the substring ${\textit{{T}}}[x:x+m-1,1:n]$ and let $S_{x}=\textit{serial}({\textit{{T}}}[x:x+m-1,1:n])$. By Lemma 8, P occurs in T at position $(x,y)$, i.e. ${\textit{{P}}}\approx{\textit{{T}}}[x:x+m-1,y:y+m-1]$ if and only if $\textit{serial}({\textit{{P}}})\approx S_{x}[m(y-1)+1,m(y-1)+m^{2}]$. The positions $m(y-1)+1$ satisfying the latter condition can be found in $O(nm+m^{2}\log{m})$ time by 1d-OPPM algorithms, which we showed in Section 3 or KMP-based ones [15, 14], because $|S_{x}|=nm$ and $|\textit{serial}({\textit{{P}}})|=m^{2}$. Because we need the preprocess for the pattern $\textit{serial}({\textit{{P}}})$ only once, and execute the search in $S_{x}$ for each $x$, the result follows. ∎

In the rest of this paper, we try a direct approach to two-dimensional strings based on the duel-and-sweep paradigm, inspired by the work [2, 9]. A substring of T of size $m\times m$ will be referred as a candidate. ${\textit{{T}}}_{x,y}$ denotes a candidate with the top-left corner at $(x,y)$.

5.1 Pattern preprocessing

For $0\leq a<m$ and $-m<b<m$, we say that a pair $\langle(i_{x},i_{y}),(j_{x},j_{y})\rangle$ of locations is a witness pair for the offset $(a,b)$ if either of the following holds:

• $\bullet$

${\textit{{P}}}[i_{x},i_{y}]={\textit{{P}}}[j]\text{ and }{\textit{{P}}}[i_{x}+a,i_{y}+b]\neq{\textit{{P}}}[j_{x},j_{y}]$,

• $\bullet$

${\textit{{P}}}[i_{x},i_{y}]>{\textit{{P}}}[j]\text{ and }{\textit{{P}}}[i_{x}+a,i_{y}+b]\leq{\textit{{P}}}[j_{x},j_{y}]$,

• $\bullet$

${\textit{{P}}}[i_{x},i_{y}]<{\textit{{P}}}[j]\text{ and }{\textit{{P}}}[i_{x}+a,i_{y}+b]\geq{\textit{{P}}}[j_{x},j_{y}]$.

The witness table $\mathit{WIT\!}_{{\textit{{P}}}}$ for pattern P is a two-dimensional array of size $m\times(2m-1)$, where $\mathit{WIT\!}_{{\textit{{P}}}}[a,b]$ is a witness pair for the offset $(a,b)$. If the overlap regions are order-isomorphic when P is superimposed with offset $(a,b)$, then no witness pair exists. We denote it as $\mathit{WIT\!}_{{\textit{{P}}}}[a,b]=\langle(m+1,m+1),(m+1,m+1)\rangle$.

We show how to efficiently construct the witness table $\mathit{WIT\!}_{{\textit{{P}}}}$. For P and each $0\leq a<m$, we define the Z-array $\textit{Z}_{{\textit{{P}}},a}$ by

[TABLE]

where $P_{1}=\textit{serial}({\textit{{P}}}[1\!:\!m-a,1\!:\!m])$, $P_{2}=\textit{serial}({\textit{{P}}}[a+1\!:\!m,1\!:\!m])$, and $|P_{1}|=|P_{2}|=m(m-a)$.

Lemma 9**.**

For arbitrarily fixed $a\geq 0$, we can compute the value of $\mathit{WIT\!}_{{\textit{{P}}}}[a,b]$ in $O(1)$ time and for each $b$, assuming that $\textit{Z}_{{\textit{{P}}},a}$ is already computed.

Proof.

For an offset $(a,b)$ with $b\geq 0$, let us consider $z_{a,b}=\textit{Z}_{{\textit{{P}}},a}[b\cdot(m-a)+1]$.

Case 1

$z_{a,b}=(m-a)\!\cdot\!(m-b)$: Note that the value is equal to the number of elements in the overlap region. Then ${\textit{{P}}}[1:m-a,1:m-b]\approx{\textit{{P}}}[a+1:m,b+1:m]$, so that no witness pair exists for the offset $(a,b)$.

Case 2

$z_{a,b}<(m-a)\!\cdot\!(m-b)$: There exists a witness pair $\langle(i_{x},i_{y}),(j_{x},j_{y})\rangle$, where $(j_{x},j_{y})$ is the location of the element in P, that corresponds to the $(z_{a,b}+1)$-th element of $P_{1}=\textit{serial}({\textit{{P}}}[1\!:\!m-a,1\!:\!m])$. By a simple calculation, we can obtain the values $(j_{x},j_{y})$ in $O(1)$ time. We can also compute $(i_{x},i_{y})$ from $(j_{x},j_{y})$ in $O(1)$ time, similarly to the proof of Lemma 4, with the help of auxiliary arrays $\mathit{Lmax}_{{\textit{{P}}},a}$ and $\mathit{Lmin}_{{\textit{{P}}},a}$. (Details are omitted.)

Symmetrically, we can compute it for $b<0$. ∎

Lemma 10**.**

We can construct the witness table $\mathit{WIT\!}_{{\textit{{P}}}}$ in $O(m^{3})$ time.

Proof.

Assume that we sorted all elements of P. For an arbitrarily fixed $a$, calculation of $\mathit{Lmax}_{{\textit{{P}}},a}$ and $\mathit{Lmin}_{{\textit{{P}}},a}$ takes $O(m^{2})$ time by using sorted P. $\textit{Z}_{{\textit{{P}}},a}$ can be constructed in $O(m^{2})$ time by Lemma 3. Furthermore, finding witness pairs for all offsets $(a,b)$ takes $O(m)$ time by Lemma 9. Since there are $m$ such $a$’s to consider, $\mathit{WIT\!}_{{\textit{{P}}}}$ can be constructed in $O(m^{3})$ time. ∎

5.2 Dueling stage

Similarly to Lemma 5, we can show the transitivity as follows.

Lemma 11**.**

For any $a,b,a^{\prime},b^{\prime}\geq 0$, let us consider three candidates ${\textit{{T}}}_{1}={\textit{{T}}}_{x,y}$, ${\textit{{T}}}_{2}={\textit{{T}}}_{x+a,y+b}$, and ${\textit{{T}}}_{3}={\textit{{T}}}_{x+a^{\prime},y+b^{\prime}}$. If ${\textit{{T}}}_{1}$ is consistent with ${\textit{{T}}}_{2}$ and ${\textit{{T}}}_{2}$ is consistent with ${\textit{{T}}}_{3}$, then ${\textit{{T}}}_{1}$ is consistent with ${\textit{{T}}}_{3}$.

The dueling algorithm due to Amir et al. [1] is also applicable to the problem.

Lemma 12**.**

([1]) The dueling stage can be done in $O(n^{2})$ time by using $\mathit{WIT\!}_{{\textit{{P}}}}$.

5.3 Sweeping stage

This is the hardest part for two-dimensional strings. We first consider two surviving candidates ${\textit{{T}}}_{x,y_{1}}$ and ${\textit{{T}}}_{x,y_{2}}$ in some column $x$, with $y_{1}<y_{2}$. If we traverse ${\textit{{T}}}[x\!:\!x+m-1,1\!:\!n]$ from top-to-bottom/left-to-right manner we can reduce the problem to one-dimensional order-preserving problem. Thus performing the sweeping stage for some column $x$ will take $O(nm)$ time. Since there are $n-m-1$ such columns, the sweeping stage will take $O(n^{2}m)$ time.

Next, we propose a method that takes advantage of consistency relation in both horizontal and vertical directions. First, we construct $m$ strings $P_{i}=\textit{serial}({\textit{{P}}}[1:m-i,1:m])\textit{serial}({\textit{{P}}}[m-i+1:m,1:m])$ for $0\leq i<m$ by serializing P in different way. We then compute $\mathit{Lmax}_{P_{i}}$ and $\mathit{Lmin}_{P_{i}}$ for $0\leq i<m$, thus we can compare the order-isomorphism of the pattern with the text in several different ways. $\mathit{Lmax}_{P_{i}}$ and $\mathit{Lmin}_{P_{i}}$ for $0\leq i<m$ can be computed in $O(n^{3})$ time by sorting $\textit{serial}({\textit{{P}}})$ once and then calculated $\mathit{Lmax}_{P_{i}}$ and $\mathit{Lmin}_{P_{i}}$ by using the sorted $\textit{serial}({\textit{{P}}})$. Fig. 4 shows $P_{i}$ for $0\leq i<m$ where $m=5$. We also do the same computation for bottom-to-top/left-to-right traversing direction.

Let us consider two overlapping candidates ${\textit{{T}}}_{x_{1},y_{1}}$ and ${\textit{{T}}}_{x_{2},y_{2}}$, where $x_{1}<x_{2}$ and $y_{1}<y_{2}$. Suppose that ${\textit{{T}}}_{x_{1},y_{1}}$ is order-isomorphic with the pattern and we need to check ${\textit{{T}}}_{x_{2},y_{2}}$. Since ${\textit{{T}}}_{x_{1},y_{1}}$ is consistent with ${\textit{{T}}}_{x_{2},y_{2}}$, we need to check the order-isomorphishm of the region of ${\textit{{T}}}_{x_{2},y_{2}}$ that is not an overlap region. We do this by using $P_{j}$, where $j=x_{2}-x_{1}$, without checking the overlap region. This idea is illustrated in Figure 5 (a). The procedure for $y_{1}>y_{2}$ is symmetrical.

Next, consider three overlapping candidates ${\textit{{T}}}_{1}={\textit{{T}}}_{x_{1},y_{1}}$, ${\textit{{T}}}_{2}={\textit{{T}}}_{x_{2},y_{2}}$ and ${\textit{{T}}}_{3}={\textit{{T}}}_{x_{3},y_{3}}$, such that $x_{1}\leq x_{2}\leq x_{3}$ and $y_{2}\leq y_{3}$. We assume that ${\textit{{T}}}_{1}$ and ${\textit{{T}}}_{2}$ are both order-isomorphic with the pattern. If $y_{1}\leq y_{2}$, we can use the method for two overlapping candidates that we described before to perform sweeping efficiently. However, if $y_{1}\geq y_{2}$, as showed in Fig. 5 (b), we need to check the blue region twice since we do not know the order-isomorphism relation between the blue region with the overlap region of ${\textit{{T}}}_{2}$ and ${\textit{{T}}}_{3}$.

By using the above method, we can reduce the number of comparisons for sweep stage. However, the time complexity remains the same.

Lemma 13**.**

The sweeping stage can be completed in $O(n^{2}m)$ time.

By Lemmas 10, 12, and 13, we conclude this section as follows.

Theorem 3**.**

The duel-and-sweep algorithm solves 2d-OPPM Problem in $O(n^{2}m+m^{3})$ time.

6 Discussion

In the current status, the time complexity of duel-and-sweep algorithm for 2d-OPPM problem in Theorem 3 is not better than straightforward reduction to 1d-OPPM problem explained in Theorem 2. We showed this result as a preliminary work on solving 2d-OPPM, and we hope the 2d-OPPM can be solved more efficiently by finding more sophisticated method based on some unknown combinatorial properties, as Cole et al. [9] did for two dimensional parameterized matching problem. This is left for future work.