Order preserving pattern matching on trees and DAGs

TL;DR

This paper studies order preserving pattern matching on trees and DAGs, providing efficient algorithms for trees and proving NP-completeness for DAGs, advancing understanding of pattern matching in complex graph structures.

Contribution

It introduces linear-time algorithms for order preserving pattern matching on trees and establishes NP-completeness for DAGs, highlighting the complexity differences.

Findings

Linear-time solution for trees with polynomial alphabet

Logarithmic factor increase for general ordered alphabet

NP-completeness of pattern matching on DAGs

Abstract

The order preserving pattern matching (OPPM) problem is, given a pattern string $p$ and a text string $t$, find all substrings of $t$ which have the same relative orders as $p$. In this paper, we consider two variants of the OPPM problem where a set of text strings is given as a tree or a DAG. We show that the OPPM problem for a single pattern $p$ of length $m$ and a text tree $T$ of size $N$ can be solved in $O(m+N)$ time if the characters of $p$ are drawn from an integer alphabet of polynomial size. The time complexity becomes $O(m \log m + N)$ if the pattern $p$ is over a general ordered alphabet. We then show that the OPPM problem for a single pattern and a text DAG is NP-complete.

Equations

$$V$$

$$E$$

Full text

1 Introduction

The order preserving pattern matching (OPPM) problem is, given a pattern string $p$ and a text string $t$, find all substrings of $t$ which have the same relative orders as $p$. For instance, let $p=(22,41,35,37)$ and $t=(63,18,48,29,42,56,25,51)$. The relative orders of the characters in $p$ is $1,4,2,3$. A substring $t[2..5]=(18,48,29,42)$ have the same relative orders $1,4,2,3$ as $p$, and hence the occurrence of this substring is reported. OPPM captures structural isomorphism of strings, and thus has potential applications in the analysis of times series such as stock prices, and in melody matching of musical sequences [10, 7].

Let $m$ and $n$ be the lengths of the pattern string $p$ and the text string $t$, respectively. Kim et al. [10] proposed an $O(m\log m+n)$-time algorithm for the OPPM problem. Independently, Kubica et al. [11] proposed an $O(\mathrm{sort}(p)+n)$-time algorithm, where $\mathrm{sort}(p)$ denotes the time complexity to sort the elements in $p$; $\mathrm{sort}(p)=O(m\log m)$ for general ordered alphabets and $\mathrm{sort}(p)=O(m)$ for integer alphabets of size $m^{O(1)}$. These algorithms are based on the Morris-Pratt algorithm [12]. Kubica et al.’s algorithm works when the input strings do not contain same characters. Cho et al. [7] showed how Kubica et al.’s algorithm can be modified when there are same characters in the input strings, retaining the same efficiency. Other types of algorithms for the OPPM problem have also been proposed (e.g., see [10, 7, 6, 9]).

This paper considers two natural extensions to the OPPM problem, where a set of text strings is given as a tree or a DAG. We show that the OPPM problem for a single pattern $p$ and a text tree $T$ of size $N$ can be solved in $O(\mathrm{sort}(p)+N)$ time. (and hence $O(m\log m+N)$ time for general ordered alphabets and $O(m+N)$ time for integer alphabets polynomial size). Our method uses a Morris-Pratt type of (non-deterministic) pattern matching automaton, and generalizes the existing results for the OPPM problem on a single text string. We then show that the OPPM problem for a single pattern and a text DAG is NP-complete.

Related work

The exact pattern matching problem on a single pattern string and a tree was first considered by Dubiner et al. [8]. Their algorithm is based on a (non-deterministic) Morris-Pratt automaton.

Amir and Navarro [3] considered the parameterized pattern matching (PPM) problem on trees. Let $\sigma$ be the alphabet size. They showed that the PPM problem on trees can be solved in $O(N\log(\min\{\sigma,m\}))$ time, provided that the deterministic version of a Morris-Pratt type automaton is available. However, the size of the deterministic version of such an automaton can be as large as $O(m^{2})$. Hence, their algorithm takes $O(m^{2}+N(\min\{\sigma,m\}))$ time in the worst case111Simon [14] proposed an $O(m)$-space Morris-Pratt automaton for exact pattern matching, however, it is unclear if this can be extended to PPM or OPPM..

Recall that the running time per text character of a non-deterministic Morris-Pratt automaton depends on the number of failure transitions used per text character. The key analysis of a total linear running time of this method on a single text string is that this number is amortized constant. The same amortization argument holds for its OPPM and PPM variants on a single text string.

The difficulty in using a non-deterministic Morris-Pratt automaton for a tree text is that if we simply run the automaton on the tree as is, then the above amortization argument does not hold. It seems that this point was overlooked even in the exact pattern matching problem on trees (see the proof of Lemma 2.2 of the work by Dubiner et al. [8]).

Still, we will show that a small trick permits us to bound the number of failure transitions per character to amortized constant, achieving our result for the OPPM problem on trees. We here emphasize that the same trick can be employed in any variant of a non-deterministic Morris-Pratt type automaton. This implies that it is actually possible to solve the exact pattern matching problem on trees in $O(m+N)$ time using the Morris-Pratt automaton, and the PPM problem on trees in $O((m+N)\log(\min\{\sigma,m\}))$ time. Both of these results are optimal; the former is clear, and the latter matches the lower bound of the PPM problem in the comparison model [3].

Several results for the exact pattern matching problem with a single pattern string and a labeled graph are known (e.g. [13, 1]). See a survey [2] for other schemes of pattern matching on graph texts.

Amir and Navarro [3] showed the PPM problem on DAGs is NP-complete. Coupled with their afore-mentioned results on trees, we can observe that the PPM and OPPM problems have similar complexities on trees and DAGs.

2 Preliminaries

Let $\Sigma$ be a totally ordered alphabet. An element of $\Sigma^{*}$ is called a string. The length of a string $w$ is denoted by $|w|$. The empty string $\varepsilon$ is a string of length [math]. For a string $w=xyz$, $x$, $y$ and $z$ are called a prefix, substring, and suffix of $w$, respectively. The length of a string $w$ is denoted by $|w|$. The $i$-th character of a string $w$ is denoted by $w[i]$ for each $1\leq i\leq|w|$. For a string $w$ and two integers $1\leq i\leq j\leq|w|$, let $w[i..j]$ denote the substring of $w$ that begins at position $i$ and ends at position $j$. For convenience, let $w[i..j]=\varepsilon$ when $i>j$.

Any strings $x,y\in\Sigma^{*}$ of equal length $m$ are said to be order-isomorphic [11] if the relative orders of the characters of $x$ and $y$ are the same, i.e., $x[i]\leq x[j]\iff y[i]\leq y[j]$ for any $1\leq i,j\leq m$. A non-empty pattern string $p$ is said to order-preserving match (op-match in short) a non-empty text string $t$ iff there is a position $i$ in $t$ such that $p\approx t[i-|p|+1..i]$. The order-preserving pattern matching (OPPM) problem is to find all such text positions.

For any string $x$ of length $m$, an integer $i$ ($1\leq i<m$) is said to be an order-preserving border of $x$ if $x[1..i]\approx x[m-i+1..m]$.

We consider the following two variants of the OPPM problem: Assume that the set of text strings is given as a tree $T$ or a DAG $G$ where each edge is labeled by a character from $\Sigma$. A pattern string $p$ of length $m$ is said to op-match a tree $T$ (resp. a DAG $G$) if $p$ op-matches the label of a path in $T$ (resp. $G$). In this paper, we consider the locating version of the OPPM on trees and the decision version of the OPPM on DAGs, which are respectively defined as follows.

Problem 1** **(The OPPM problem on trees)

Given a pattern string $p$ and an edge-labeled tree $T$, report the final node of every path in $T$ that $p$ op-matches.

Problem 2** **(The OPPM problem on DAGs)

Given a pattern string $p$ and an edge-labeled DAG $G$, determine whether $p$ op-matches $G$ or not.

3 Order preserving pattern matching on trees

Our algorithm for order preserving pattern matching on a text tree is inspired by the algorithms for order preserving pattern matching on a text string [11, 7]. We will utilize the following tools in our algorithm.

For any string $x$ let $\mathit{LMax}_{x}$ be an array of length $|x|$ such that $\mathit{LMax}_{x}[i]=j$ if $x[j]=\max\{x[k]\mid 1\leq k<i,x[k]\leq x[i]\}$. Similarly, let $\mathit{LMin}_{x}$ be an array of length $|x|$ such that $\mathit{LMin}_{x}[i]=j$ if $x[j]=\min\{x[k]\mid 1\leq k<i,x[k]\geq x[i]\}$. If there is no such $j$, then let $\mathit{LMax}_{x}[i]=0$ and $\mathit{LMin}_{x}[i]=0$, respectively. If there are several such $j$’s, then we select the rightmost one among them.

Lemma 1** **([11])

Given a string $x$, we can compute the $\mathit{LMax}_{x}$ and $\mathit{LMin}_{x}$ arrays in $O(\mathrm{sort}(x))$ time, where $\mathrm{sort}(x)$ is the time to sort the elements of $x$.

Lemma 2** **([7])

For strings $x$ and $y$, assume $x[1..i]\approx y[1..i]$ for $1\leq i<\min\{|x|,|y|\}$. Let $a=\mathit{LMax}_{x}[i+1]$ and $b=\mathit{LMin}_{x}[i+1]$. Let $\alpha$ be the condition that $y[a]<y[i+1]$ and $\beta$ be the condition that $y[i+1]<y[b]$. Then, $x[1..i+1]\approx y[1..i+1]\Longleftrightarrow(\alpha\land\beta)\lor(\lnot\alpha\land\lnot\beta)$. In case $a$ or $b$ is equal to [math], we assume the respective condition $\alpha$ or $\beta$ is true.

Let $p$ be a pattern string of length $m$. We compute the order-preserving border array $B_{p}$ of length $m$ such that $B_{p}[1]=0$ and $B_{p}[i]=\max\{j\mid j<i,p[1..j]\approx p[i-j+1..i]\}$ for $2\leq i\leq m$. Namely, $B_{p}[i]$ stores the largest order-preserving border of the prefix $p[1..i]$. Suppose that $\mathit{LMin}_{p}$ and $\mathit{LMax}_{p}$ have already been computed using Lemma 1. Kubica et al. [11] showed that using a variant of the Morris-Pratt (MP) algorithm [12] based on Lemma 2, the $B_{p}$ array can be computed in $O(m)$ time. Then, given a text string $t$ of length $n$, all positions $i$ in $t$ where $p\approx t[i-m+1..i]$ can be computed in $O(n)$ time.

We will extend the above algorithm to the case where the text strings are given as a tree $T$ of size $N$. It is convenient to consider an MP-style automaton $\mathcal{A}_{p}$ based on the op border array $B_{p}$ such that the set of states is $\{s_{0},\ldots,s_{m}\}$; the initial state is $s_{0}$; the only accepting state is $s_{m}$; for each $1\leq i\leq m$ there is a goto transition from $s_{i-1}$ to $s_{i}$ with character $c=p[i]$; and there is a failure transition from $s_{i}$ to $s_{j}$ iff $B_{p}[i]=j$. See Fig. 1 for a concrete example of $\mathcal{A}_{p}$. We run $\mathcal{A}_{p}$ over the text tree $T$ in depth first manner. Let $v$ be any node in $T$. For any $1\leq i\leq m$, let $v_{i}$ denote the $i$th ancestor of $v$ (if it exists), and $\mathit{path}(v_{i},v)$ the path label from $v_{i}$ to $v$. At each node $v$ visited during the DFS, we compute the length $\ell(v)$ of the longest path $v_{\ell(v)},\ldots,v$ such that $p[1..\ell(v)]\approx\mathit{path}(v_{\ell(v)},v)$. We report every node $v$ with $\ell(v)=m$. If $\ell(v)<m$, then we store a pointer to state $s_{\ell(v)}$ at node $v$, and otherwise we store a pointer to state $s^{\prime}$ at node $v$, where $s^{\prime}$ is the state pointed by the failure transition of $s_{\ell(v)}$.

Suppose we have just visited node $v$. Initially, let $\ell\leftarrow\ell(v)$. Let $u$ be any child of $v$ and let $c$ be the edge label from $v$ to $u$. We proceed to node $u$ and find $\ell(u)$. We test if the characters $\mathit{path}(v_{\ell},u)[a]$ and $\mathit{path}(v_{\ell},u)[b]$ satisfy one of the conditions in Lemma 2, where $a=\mathit{LMax}_{p}[\ell+1]$ and $b=\mathit{LMin}_{p}[\ell+1]$. If they do, then we let $\ell(u)=\ell+1$ and proceed with the DFS. Otherwise, then let $\ell\leftarrow B_{p}[\ell]$, and repeat the above procedure until we find the largest $\ell$ with which one of the conditions in Lemma 2 is satisfied. For each candidate $\ell$ above, accessing the character $\mathit{path}(v_{\ell},u)[a]$ from the currently visited node $u$ means accessing the $(\ell-a+1)$th ancestor of $u$. Let $L$ be the length of the longest path in $T$. During the DFS, we store the edge labels of the current path from the root into an array of length $L$. Using this array we can access $\mathit{path}(v_{\ell},u)[a]$ (and $\mathit{path}(v_{\ell},u)[b]$) in $O(1)$ time. It is easy to update this array during the DFS, in total $O(N)$ time. When we come back to node $v$ after a back track, then we resume pattern matching from state $s_{\ell(v)}$ of $\mathcal{A}_{p}$ using a pointer stored at $v$, and proceed to the next child of $v$. This pointer is used after a back track.

One delicacy remains. For a single text string the number of candidate $\ell$’s, which is the same as the number of failure transitions used per text character, can be amortized constant. This amortization argument is based on the fact that the total number of times the failure transitions are used for the whole text cannot exceed the total number of times the goto transitions are used in the automaton $\mathcal{A}_{p}$, which is bounded by the length of the single text string. However, in our tree case, this amortization argument does not hold if we carelessly continue the DFS at branching nodes that are close to leaves, leading to $O(mN)$ worst case time. See Appendix for an example. To avoid this, at each node $u$ of the tree $T$ we store the distance $D_{u}$ between $u$ and a furthest leaf in the subtree rooted at $u$. Namely, $D_{u}$ is the length of the longest path from $u$ and a leaf below $u$. Suppose that we are currently visiting a node $u$ during the DFS with $D_{u}\geq m-\ell$, and that the respective state of the automaton $\mathcal{A}_{p}$ is $s_{\ell}$ (Notice that if $D_{u}<m-\ell$, then clearly the pattern $p$ does not op-match any path ending in the subtree under $u$, and thus we need not search the subtree under $u$ in this case). Let $v$ be any child of $u$. If at least one of the conditions of Lemma 2 is satisfied, then we let $\ell\leftarrow\ell+1$ and the DFS proceeds to $v$. Otherwise, we let $\ell\leftarrow B_{p}[\ell]$ and check if $D_{u}\geq m-\ell$ holds each time the value of $\ell$ gets updated. We stop updating $\ell$ as soon as we encounter $\ell$ for which $D_{u}<m-\ell$, and the DFS immediately starts a back track from this child $v$. This permits us to charge the cost for amortization to the length $D_{u}$ of this longest path under $u$. Thus, this method correctly finds all locations in the tree $T$ where $p$ op-matches. We can easily precompute $D_{u}$ for all nodes $u$ in $T$ in $O(N)$ total time by a standard traversal on $T$.

Overall, we obtain the main result of this section.

Theorem 1

Given a pattern $p$ of length $m$ and a text tree $T$ of size $N$, the OPPM problem on trees (Problem 1) can be solved in $O(\mathrm{sort}(p)+N)$ time.

For general ordered alphabets, $\mathrm{sort}(p)=O(m\log m)$. For integer alphabets of size $m^{O(1)}$, $\mathrm{sort}(p)=O(m)$. For integer alphabets of size $N^{O(1)}$, $\mathrm{sort}(p)=O(m+N)$.

4 Order preserving pattern matching on DAGs

A string $x$ is said to be a subsequence of another string $t$ if there exists an increasing sequence of positions $1\leq i_{1}<\cdots<i_{|x|}\leq|t|$ of $t$ such that $x=t[i_{1}]\cdots t[i_{|x|}]$. Intuitively, $x$ is a subsequence of $t$ if $x$ can be obtained by removing zero or more characters from $t$.

The order-preserving subsequence matching problem (OPSM in short) is, given a pattern string $p$ and a text string $t$, to determine whether there is a subsequence $s$ of $t$ such that $p\approx s$. This problem is known to be NP-complete [5].

Theorem 2

The OPPM problem on DAGs (Problem 2) is NP-complete.

Proof.

It is clear that the OPPM problem on DAGs is in NP. The proof for NP-completeness is via the above OPSM problem. Suppose $p$ is a given pattern string and $t$ is a given text string for the OPSM problem. Consider the directed acyclic subsequence graph (DASG in short) [4] $G_{t}=(V,E)$ such that

[TABLE]

The DASG $G_{t}$ represents all subsequences of $t$, i.e., $s$ is a subsequence of $t$ if and only if there is a path in $G_{t}$ of which label coincides with $s$ (see Fig. 2 for an example). Hence, if we can solve the op-matching problem for the given pattern string $p$ and the DASG $G_{t}$, then we can immediately solve the OPSM problem. The size of DASG $G_{t}$ is clearly polynomial in the length of the given text $t$ and $G_{t}$ can be easily constructed in polynomial time. This completes the proof. ∎

Appendix A Appendix

In this appendix, we show that applying a Morris-Pratt type algorithm for the order-preserving pattern matching (OPPM) problem to a text tree as is can lead to $O(mN)$ worst-case time for some instances.

Consider a complete binary tree $T$ of height $h$ such that

• •

the path from the root to each node of depth $h-2$ is labeled by non-negative integers in increasing order,

• •

the two out-going edges of each node of depth $h-2$ are labeled by [math] and $1$, and

• •

the edge leading to any leaf is labeled by any character.

Also, consider pattern string $p=(2,3,\ldots,m+1)$ of length $m\leq h-2$. See Fig. 3 for a concrete example of tree $T$ and pattern $p$.

The failure transition of each state $s_{i}$ of the automaton $\mathcal{A}_{p}$ points to state $s_{i-1}$. Suppose we have arrived at a node $v$ of depth $h-2$ during the DFS. By the definitions of tree labels and $p$, pattern $p$ op-matches the path of length $m$ ending at this node $v$, and hence the current state of the automaton is $s_{m}$. Now we proceed to a child of $v$, say $u$, and suppose that the edge label from $v$ to $u$ is [math] (the case with the edge label being $1$ is analogous). Since the edge label is [math], the longest prefix of $p$ that op-matches a path ending at $u$ is $p[1]=1$ and hence $m-1$ failure transitions are used at this point of the DFS.

The tree $T$ contains $K=2^{h}$ leaves and hence contains $N=2K-1$ total nodes. The number of tree edges labeled by [math] is $K/2=(N+1)/4$. Thus, the total number of times the failure transitions are used is $\Theta(mN)$ for this tree $T$ and pattern $p$.

We remark that the same instance leads to an $O(mN)$ worst-case time bound for the parameterized pattern matching (PPM) problem on trees as well.

For the exact pattern matching problem, if we allow out-going edges of a node to have the same labels, then it is easy to show $O(mN)$ worst-case time bound: In the above example, replace [math] with $b$, $1$ with $c$, and all the other tree edge labels with $a$. For pattern $p=a^{m}$, the total number of failure transitions of the Morris-Pratt automaton used for this new tree and $p$ is $\Theta(mN)$.