LCS(最长公共字序列)实现

LCS(Loggest common subsequence)

最长公共子序列的解法，可以说是老生常谈了。最近一段时间工作上在用到了该算法。打算记录下，同时也准备重启下博客之路，作下自我驱动。

何为LCS，举例来讲，假设 字符串 A={a,b,d,e,c}, B={b,f,g,e,c},那么AB的LCS即是 bec，因为是序列(sequence)，所以它在两个字符串中必须是从前往后保持序列一致。

LCS并不是唯一的，一般应用场景下获取一个实例即可。

LCS经典的解法一般是时间复杂度为O(n^2)的动态规划(DP)算法，可参考下网易公开课-算法导论，老爷子的经典视频，这里不做讨论。

James W. Hunt和Thomas G. Szymansky 的论文"A Fast Algorithm for Computing Longest Common Subsequence"提出了一种下限为O(nlogn)的算法。

定理：设序列A长度为n，{A₁A₂A...A_iA...A_n}，序列B长度为m，{B₁B₂B...B_jB...B_m}，获取A中所有元素在B中的序号，形成一个新序列{C₁C₂C...C_k}，，获取新序列的最长严格递增子序列（LIS）,然后根据该序列的序号从B中还原,即对应为A、B的最长公共子序列。

举例来说，A={a,b,d,e,c}，B={b,f,g,e,c,b}，则

a对应在B的序号为空

b对应序号为{0,5}

d对应序号为空

e对应为{3}

c对应为{4}

根据以上结果生成的新序列为{0,5,3,4}，其最长严格递增子序列为{0,3,4}，我们根据这个序号，从B序列中找出对应字符， 对应的公共子序列为{b, e, c}。

具体的证明过程可以Google原论文查看，根据以上的过程我们其实可以总结它具体的流程。

1)定义一个结构，记录B的字符的序号和值，然后排序（我们例子是可以肉眼看出，实际过程需要排序，以便二分查找），得到一个C

2)遍历A序列，从C中二分查找得到一个新序列D

3)对D做LIS计算，得到最长严格递增子序列。

4)根据此序列，从B中还原出LCS

那么我们按照这个步骤来实现代码。我们用Golang实现。

第一步 

type comparedValPos struct {
    val rune //原始值
    pos int //原始位置
}

type comparedValPosSlice []comparedValPos

func (b comparedValPosSlice) Len() int { return len(b) }
func (b comparedValPosSlice) Less(i, j int) bool {
    if b[i].val < b[j].val {
        return true
    } else if b[i].val > b[j].val {
        return false
    } else {
        return !(b[i].pos < b[j].pos)
    }
}
func (b comparedValPosSlice) Swap(i, j int) { b[i], b[j] = b[j], b[i] }

//遍历原始字符串并排序
func lcsSort(target string) comparedValPosSlice {
    var slice comparedValPosSlice

    runeSlice := []rune(target)
    for i := 0; i < len(runeSlice); i++ {
        var l comparedValPos
        l.pos = i
        l.val = runeSlice[i]
        slice = append(slice, l)
    }
    sort.Sort(slice)
    return slice

第二步，二分查找并得到新序列，我们需要新序列中的值的原始的位置，代码如下

//需要记录原始位置
type lcsTargetPosInfo struct {
    slicePos int
    rawPos   int
}
//二分查找 由于字符可能有重复 返回具体匹配的长度
func findMatchList(ch rune, slice comparedValPosSlice, left int, right int, start *int) (matchLen int) {
    var middle, matchedLen1, matchedLen2 int
    var start1, start2 int
    if left > right {
        matchLen = 0
        return
    } else if left == right {
        if ch == slice[left].val {
            *start = left
            matchLen = 1
            return
        }
        matchLen = 0
        return
    }

    middle = (left + right) >> 1
    if slice[middle].val < ch {
        matchedLen1 = findMatchList(ch, slice, middle+1, right, &start1)
    } else if slice[middle].val > ch {
        matchedLen1 = findMatchList(ch, slice, left, middle-1, &start1)
    } else {
        matchedLen1 = findMatchList(ch, slice, left, middle-1, &start1)
        matchedLen2 = findMatchList(ch, slice, middle+1, right, &start2) + 1
        if matchedLen1 == 0 {
            start1 = middle
        }
        matchedLen1 += matchedLen2
    }
    *start = start1
    matchLen = matchedLen1
    return
}
//在前面生成的comparedValPosSlice的对rawStr进行二分查找
//并生成新序列
func matchListLcs(rawStr string, slice comparedValPosSlice) (matchedSlice []lcsTargetPosInfo) {
    var start int
    runeSlice := []rune(rawStr)
        //遍历字符串 并进行二分查找
    for i := 0; i < len(runeSlice); i++ {
        matchLen := findMatchList(runeSlice[i], slice, 0, len(slice)-1, &start)
               //获取到该字符匹配的个数 位置信息全部记录下来
        for k := 0; k < matchLen; k++ {
            var l lcsTargetPosInfo
            l.slicePos = slice[start+k].pos
            l.rawPos = i
            matchedSlice = append(matchedSlice, l)
        }
    }
    return
}

第三步 对新序列做lis匹配 最长严格递增子序列 可以参考 最长递增子序列nlogn算法

func findPos(l []int, currLen int, value int) int {
	left := 0
	right := currLen - 1
	middle := 0
	for left <= right {
		middle = (left + right) >> 1
		if l[middle] < value {
			left = middle + 1
		} else {
			right = middle - 1
		}
	}
	return left
}

func lis(slice []lcsTargetPosInfo, incSeq []int) int {
	if len(slice) == 0 {
		return 0
	}
	L := make([]int, len(slice))
	M := make([]int, len(slice))
	prev := make([]int, len(slice))
	L[0] = slice[0].slicePos
	M[0] = 0
	prev[0] = -1
	currLen := 1
	for i := 1; i < len(slice); i++ {
		pos := findPos(L, currLen, slice[i].slicePos)
		L[pos] = slice[i].slicePos
		M[pos] = i
		if pos > 0 {
			prev[i] = M[pos-1]
		} else {
			prev[i] = -1
		}
		if pos+1 > currLen {
			currLen++
		}
	}

	pos := M[currLen-1]
	for i := currLen - 1; i >= 0 && pos != -1; i-- {
		incSeq[i] = slice[pos].rawPos
		pos = prev[pos]
	}
	return currLen

}

　　最后我们根据生成的lis来得到LCS

func Lcs(rawStr string, targetStr string) (int ,string) {
     slice :=  lcsSort(targetStr)
     return calcLcsUsingLis(rawStr,slice)
}

func calcLcsUsingLis(rawStr string, slice comparedValPosSlice) (int, string) {
    var maxIncreaseSequencerLen int
    if len(rawStr) > slice.Len() {
        maxIncreaseSequencerLen = slice.Len()

    } else {
        maxIncreaseSequencerLen = len(rawStr)
    }
    lcsPosSlice := matchListLcs(rawStr, slice)

        //LIS 保存的是字符位置
    increaseSequnceSlice := make([]int, maxIncreaseSequencerLen)
    ret := lis(lcsPosSlice, increaseSequnceSlice)
    var result []rune
    runeSlice := []rune(rawStr)

        //利用具体字符位置 得到最后的LCS
    for i := 0; i < ret; i++ {
        result = append(result, runeSlice[increaseSequnceSlice[i]])
    }

    return ret, string(result)
}

 全部代码在 github