What's the significance of suffixes being sorted in suffix array?

Question

I know that the definition of suffix array itself is that its a sorted array of all the suffixes of a string. But I am trying to understand whats the significance of this sorting operation here? Suppose we create an array of all the suffixes of the string and choose not to sort it and go ahead with the construction of LCP array, what do we loose in this situation when we try to solve those common problems such as Longest Palindromic sub string, Longest Repeated sub string?

Answer 1

There are two main reasons why you would want to have all the suffixes sorted inside of a suffix array.

First, if S and T are strings, we know the following:

T is a substring of S if and only if it is a prefix of a suffix of S.

For example, if S is "avoidance" and T is "ida," then T is a substring of S because it's a prefix of the suffix "idance." Therefore, applications that require quick queries about substrings of S can be rephrased in terms of searching for prefixes of suffixes of S.

Given this, if you're interested in searching for prefixes of suffixes of S, it makes sense to store those suffixes in a data structure that allows for quick searching. If we put the suffixes in an array, keeping them sorted then allows you to look up where various prefixes must be efficiently. Therefore, having a suffix array be an array of all the suffixes of S stored in sorted order enables quick searches for prefixes of suffixes and therefore for substrings of S.

As to your second question about LCP arrays - could you compute them if the suffixes weren't sorted and what would you lose if you did? - you absolutely can compute them for any array, even a non-sorted array of suffixes, so there's no fundamental reason why you couldn't do this. However, the LCP array of the sorted suffix array has a bunch of nice properties that an LCP array of an unsorted suffix array doesn't have. For example, the LCP array in a suffix array can be used to determine the depths of internal nodes in the corresponding suffix tree, or to compute longest common extensions, etc.

One hugely important property of sorted suffix arrays and LCP is that if you compute the pairwise LCP information for all the strings, you can compute LCP over arbitrary pairs of strings by performing a range minimum query over the LCP array. The reason this works is that if the suffixes are sorted, the maximum amount of overlap between adjacent strings is preserved. This doesn't work in the case where the array is unsorted (I'll mention this at the very end again.)

To see specifically where things break down, let's take the longest repeated substring problem. The normal linear-time algorithm for this using suffix arrays is the following:

• Construct a suffix array for the string T.
• Construct the LCP array for the generalized suffix array.
• Iterate across the suffix array and find the string whose LCP value is maximum.

It's important to think about why this last step works. Consider any substring that's repeated twice, call it S. Because any substring is a prefix of a suffix, this means that the strings Sα and Sβ must be suffixes of the string T. If you store the suffix array in sorted order, then all strings beginning with the prefix S will appear consecutively in the suffix array (do you see why?). Therefore, if S is the longest repeated substring, then the first suffix starting with S with have an LCP with the next string of length |S|.

Now, consider what happens if you do this without sorting the array. In that case, if S is the longest repeated substring, the strings Sα and Sβ will still be suffixes of string T. However, they won't necessarily be consecutive in the suffix array, and so there won't necessarily be a linear-time algorithm for finding them. For example, consider the string

abracadabra

The unsorted suffix array is

abracadabra$
bracadabra$
racadabra$
acadabra$
cadabra$
adabra$
dabra$
abra$
bra$
ra$
a$
$

After annotating with LCP information, we get

0 abracadabra$
0 bracadabra$
0 racadabra$
0 acadabra$
0 cadabra$
0 adabra$
0 dabra$
0 abra$
0 bra$
0 ra$
0 a$
  $

So you can see that this algorithm won't find "abra" because they aren't consecutive. You could still conceivably figure out that it was "abra" by trying all pairs, but that's not efficient for large strings.

I mentioned earlier that LCP information about adjacent pairs of strings in sorted suffix arrays can be used to compute LCP information about arbitrary pairs of strings in sorted suffix arrays. This isn't true if the strings are unsorted; above, you can see that the strings all have adjacent pairwise LCP of 0 even though some of the strings certainly do have nonzero common prefix.

Hope this helps!