Question

Consider the following variant of string alignment: given two strings x,y, and a positive integer L, find all contiguous substrings of length at least L that are aligned (using no-ops = substituting a letter for itself) in some optimal alignment of x and y. Assume the costs of substitution, insertion, and deletion are given by constants csubs,cins,cdel, and that the cost of substituting a letter for itself is zero.

(a) Show that the output here contains at most O((n−L)^3) substrings.

(b) Give an algorithm that solves this problem

Answer 1

According to my understanding of your question, you want all the contiguous substrings of length L to appear in the list for strings X and Y. I will first show you the algorithm and code to help you understand and then discuss the time complexity of the same. Note : Coded in Python

Let X and Y be two strings 

X = 'Today is a good day, it is a good idea to have a walk.'
Y = 'Yesterday was not a good day, but today is good, shall we have a walk?'

Algorithm

1. Remove punctuation from both X and Y.

2. Split both Strings into words using Split() function.

3. Use Two loops to detect common strings and while loop so as to change value of i in the loop itself.

4. Take a string r to store values of substring and check if string is same then keep adding to r. Else if not same then check if there is already one in buffer and add it to result (here z as in code)

5. Print the list Z

Code

import string

X = 'Today is a good day, it is a good idea to have a walk.'
Y = 'Yesterday was not a good day, but today is good, shall we have a walk?'
z=[]
L = 5                                    #random length 5
s1=X.translate(None, string.punctuation) #remove punctuation
s2=Y.translate(None, string.punctuation)
print s1
print s2
sw1=s1.lower().split()                   #split it into words
sw2=s2.lower().split()
print sw1,sw2
i=0
while i<len(sw1):          #two loops to detect common strings. used while so as to change value of i 
    x=0
    r=""
    d=i
    #print r
if len(r)<=L                                     #checking the length less than L
    for j in range(len(sw2)):                        
        #print r
        if sw1[i]==sw2[j] :        
            r=r+' '+sw2[j]                       #if string same keep adding to a variable
            x+=1
            i+=1
        else:
            if x>0        # if not same check if there is already one in buffer and add it to result                                                                  
                z.append(r)
                i=d
                r=""
                x=0
    if x>0:                                            #end case of above loop
        z.append(r)
        r=""
        i=d
        x=0
    i+=1 
    #print i
print list(set(z)) 

#O(n^3) normally but for length L it will become O((n-L)^3)

Time Complexity

Now, we have used a while loop and a for loop for 2 strings and calculating substrings for the same. Its taking O(n^3) time.

However since we have introduced condition that only length L substrings are to be found then, loop will take n-L steps to calculate the same.

Hence Time Complexity = O((n-L)^3) at worst case