最长公共字串算法, 文本比较算法, longest common subsequence(LCS) algorithm

 '''
 merge two configure files, basic file is aFile
 insert the added content of bFile compare to aFile
 for example, 'bbb' is added content
 -----------------------------------------------------------
 a file content  |  b file content  |  c merged file content
     111         |       111        |    111
     aaa         |       bbb        |    aaa
                 |                  |    bbb
     222         |       222        |    222
 ------------------------------------------------------------
 '''
 def mergeFiles(aPath, bPath, cPath):

     with open(aPath, 'r') as f:
         aLines = f.readlines();
         aLines = [ line.strip() + '\n' for line in aLines]

     with open(bPath, 'r') as f:
         bLines = f.readlines();
         bLines = [ line.strip() + '\n' for line in bLines]

     cLines = mergeSequences(aLines, bLines)

     with open(cPath, 'w') as f:
         for line in cLines:
             f.write(line)

 '''
 merge the sequence
 '''
 def mergeSequences(aLines, bLines):
     record = {}
     lcs = findLCS(record, aLines, 0, bLines, 0)
     currA = currB = 0
     merged = []
     for (line, aI, bI) in lcs:

         # add deleted
         if aI > currA:
             merged.extend(aLines[currA:aI])
         currA = aI + 1

         # add added
         if bI > currB:
             merged.extend(bLines[currB:bI])
         currB = bI + 1

         # add common
         merged.append(line)

     if currA < len(aLines):
         merged.extend(aLines[currA:])
     if currB < len(bLines):
         merged.extend(bLines[currB:])

     return merged

 '''
 find Longest common subsequence
 return list of (line, x, y)
 line is common line, x is the index in aLines, y is the index in bLines
 TODO: eliminate recursive invoke, use dynamic algorithm
 '''
 def findLCS(record, aLines, aStart, bLines, bStart):

     key = lcsKey(aStart, bStart)
     if record.has_key(key):
         return record[key]

     aL = aLines[aStart:]
     bL = bLines[bStart:]
     if len(aL) > 0 and len(bL) > 0:
         if aL[0] == bL[0]:
             lsc = [(aL[0], aStart, bStart)]
             lsc.extend(findLCS(record, aLines, aStart + 1, bLines, bStart + 1))
             record[key] = lsc
             return lsc
         else:
             aLsc = findLCS(record, aLines, aStart, bLines, bStart + 1)
             bLsc = findLCS(record, aLines, aStart + 1, bLines, bStart)

             if len(aLsc) > len(bLsc):
                 record[key] = aLsc
                 return aLsc
             else:
                 record[key] = bLsc
                 return bLsc
     else:
         return []

 Code