最长递增子序列-golang 实现

对于数组a = []int{3,1,2,8,9,5,6},最长递增子序列为：{1,2,8,9}或者{1,2,5,6}。
建立数组dp，用来保存以元素a

_i

结尾的递增子序列的最长长度，得到dp如下：

dp = []int{1,1,2,3,4,3,4}
其中dp的求解过程可以是：

    for key, val := range a{
        maxLen := 1
        for j := (key-1); j>=0; j-- {
            if a[j] < val && dp[j] >= maxLen{
                maxLen = dp[j] + 1
            }
        }
        dp[key] = maxLen
    }

　可以得到该方法的时间复杂度为O(n²)

可以通过二分查找来提高查找maxLen的效率，如下边代码所示：

func binarySearch(arr []int, target int )int{
    s, e := 0, len(arr)-1
    for s <= e {
        if arr[e] < target {
            return e+1
        }
        if arr[s] > target{
            return s
        }
        mid := s + (e-s)/2
        if arr[mid] == target {
            return -1
        }else if arr[mid] > target{
            e = mid - 1
        }else {
            s = mid + 1
        }
    }
    return -1
}
func getDp(arr []int)[]int{
    dp := make([]int, len(arr))
    en := make([]int, 0, len(arr))
    dp[0] = 1
    en = append(en, arr[0])
    for key, val := range arr{
        p := binarySearch(en, val)
        if p >= 0 {
            en = append(en[0:p], val)
            dp[key] = len(en)
        }
    }
    return dp
}