What's the runtime of this algorithm?

Question

I just wrote an answer to a question:

longest common subsequence: why is this wrong?

This function is supposed to find the longest substring between two strings, but when I tried to figure out the worst-case runtime and the input that would cause that, I realized I didn't know. Consider the code to be C pseudocode.

// assume the shorter string is passed in as A
int lcs(char * A, char * B)
{
  int length_a = strlen(A);
  int length_b = strlen(B);

  // This holds the length of the longest common substring found so far
  int longest_length_found = 0;

  // for each character in one string (doesn't matter which), look for 
  //   incrementally larger strings in the other
  // once a longer substring can no longer be found, stop
  for (int a_index = 0; a_index < length_a - longest_length_found; a_index++) {
    for (int b_index = 0; b_index < length_b - longest_length_found; b_index++) {

      // check the next letter until a mismatch is found or one of the strings ends.
      for (int offset = 0; 
           A[a_index+offset] != '\0' && 
             B[b_index+offset] != '\0' && 
             A[a_index+offset] == B[b_index+offset]; 
           offset++) {          
        longest_length_found = longest_length_found > offset ? longest_length_found : offset;
      }
    }
  }
  return longest_found_length;
}

Here's my thinking so far:

Below, I'll be assuming A and B are roughly equivalent size as to not have to say ABA, I'll just say n^3. If this is terribly bad, I can update the question.

Without some of the optimizations in the code, I believe the runtime is ABA for a N^3 runtime.

However, if the strings are dissimilar and a long substring is never found, the inner-most for loop would drop out to a constant leaving us with A*B, right?

If the strings are exactly the same, the algorithm takes linear time, as there is only one simultaneous pass through each of the strings.

If the strings are similar, but not identical, then the longest_length_found would become a significant fraction of the smaller of A or B, which would divide out one of the factors in the N^3 leaving us with N^2, right? I'm just trying to understand what happens when they are remarkably similar but not identical.

Thinking out loud, what if on the first letter, you find a substring with a length around half of the length of A. This would mean that you would run A/2 iterations of the first loop, B-(A/2) iterations of the second loop, and then up to A/2 iterations in the third loop (assuming the strings were very similar) without finding a longer substring. Assuming roughly even length strings, that's N/2 * N/2 * N/2 = O(N^3).

Sample strings which could show this behavior:

A A A B A A A B A A A B A A A B

A A A A B A A A A B A A A A B A

Am I close or am I missing something or misapplying something?

I'm pretty sure I could do better using a trie/prefix tree, but again, I'm just really interested in understanding the behavior of this specific code.

Answer 1

I think what roliu said in the comments is bang on the money. I think your algorithm is O(N³) with a best-case of O(N²).

What I actually wanted to point out is the over-indulgence of this algorithm. You see, for every possible starting offset in each string, you test every subsequent matching character to count the number of matches. But consider something like this:

A = "01111111"
B = "11111110"

Almost the first thing you will find is the maximum matching substring starting at A[1] and B[0], and then later on you will test parts of that exact overlap, beginning at A[2], B[1] and so on... What's important here is the relative offset. You can completely drop the N³ part of the algorithm by realising this. Then it becomes a matter of shifting one of the arrays beneath the other.

A         01111111
B  11111110
B   11111110
B    11111110
B        ... -->
B                11111110

To make the code less complicated, you can test just half of the system, then swap the arrays and test the other half:

// Shift B under A
A  01111111
B  11111110
B      ... -->
B         11111110

// Shift A under B
B  11111110
A  01111111
A      ... -->
A         01111111

If you do this, then you have something like O((A+B-2) * min(A,B) / 2), or more conveniently O(N²)

int lcs_half(char * A, char * B)
{
    int maxlen = 0, len = 0;
    int offset, i;
    for( offset = 0; B[offset]; offset++ )
    {
        len = 0;
        for( i = 0; A[i] && B[i+offset]; i++ )
        {
            if( A[i] == B[i+offset] ) {
                len++;
                if( len > maxlen ) maxlen = len;
            }
            else len = 0;
        }
    }
    return maxlen;
}

int lcs(char * A, char * B)
{
    int run1 = lcs_half(A,B);
    int run2 = lcs_half(B,A);
    return run1 > run2 ? run1 : run2;
}

Answer 2

So after we talked about it in the comments we agreed that the question is finding the worst-case runtime for the code. We can claim it's at least Omega(n^3) with the following proof:

Let
A = aaaa...aabb...bbbb meaning that |A| = n and it's composed of n/2 a's and n/2 b's.
B = aaaa.... where |B| = n.

Now we consider the first n/2 iterations of the outer-most loop (i.e. the first n/2 starting indices for the A string). Fix some iteration i of those first n/2 iterations of the outer-most loop. The upper bound of the second loop is at least n-n/2 = n/2 because the LCS of the two strings has length n/2. For each iteration of the second loop we match a string of length n/2 - i (you can prove this by contradiction). So we have that after the first n/2 iterations of the outer-most loop that the line:

longest_length_found = longest_length_found > offset ? longest_length_found : offset;

has run:

n/2*(n/2) + n/2*(n/2-1) + n/2*(n/2-2) + ... + n/2*(2) + n/2*(1) = n/2*Omega(n^2) = Omega(n^3)

Specifically, for the first iteration of the outer-most loop we have a string of n/2 a's in string A and there are n/2 starting spots in B. For each starting spot in B we'll match a full common substring of length n/2 (meaning we'll hit that line n/2 times). So that's n/2*(n/2). For the next iteration of the outer-most loop we have a string of n/2-1 a's in string A and there are still n/2 starting spots in B. In this case we match a common substring of length n/2-1 for each starting index => n/2(n/2-1). The same argument works inductively up to i = n/2.

Anyways, we know that the running time of the algorithm on the input is longer than the running time of the first n/2 iterations of the outer-most loop so it's also Omega(n^3).