LeetCode_14_简单_最长公共前缀

---

1. 题目

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1：

输入：strs = [“flower”,“flow”,“flight”]
输出：“fl”

示例 2：

输入：strs = [“dog”,“racecar”,“car”]
输出：“”
解释：输入不存在公共前缀。

---

提示：

• $1<=strs.length<=200$
• $0<=strs[i].length<=200$
• strs[i] 仅由小写英文字母组成

2. 思路及代码实现（Python）

2.1 横向扫描

用 $LCP(S_1\dots S_n)$ 表示字符串 $S_1\dots S_n$ 的最长公共前缀。

可以得到以下结论：

$LCP(S_1,...,S_n)=LCP(LCP(LCP(S_1,S_2),S_3),...S_n)$

基于该结论，可以得到一种查找字符串数组中的最长公共前缀的简单方法。依次遍历字符串数组中的每个字符串，对于每个遍历到的字符串，更新最长公共前缀，当遍历完所有的字符串以后，即可得到字符串数组中的最长公共前缀。

如果在尚未遍历完所有的字符串时，最长公共前缀已经是空串，则最长公共前缀一定是空串，因此不需要继续遍历剩下的字符串，直接返回空串即可。

时间复杂度：$O(mn)$，其中 $m$ 是字符串数组中的字符串的平均长度，$n$ 是字符串的数量。最坏情况下，字符串数组中的每个字符串的每个字符都会被比较一次。空间复杂度：$O(1)$，使用的额外空间复杂度为常数。

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:
            return ""
        
        prefix, count = strs[0], len(strs)
        for i in range(1, count):
            prefix = self.lcp(prefix, strs[i])
            if not prefix:
                break
        
        return prefix

    def lcp(self, str1, str2):
        length, index = min(len(str1), len(str2)), 0
        while index < length and str1[index] == str2[index]:
            index += 1
        return str1[:index]

执行用时：42 ms
消耗内存：16.39 MB

参考来源：力扣官方题解

2.2 纵向扫描

上一个方法是横向扫描，依次遍历每个字符串，更新最长公共前缀。另一种方法是纵向扫描。纵向扫描时，从前往后遍历所有字符串的每一列，比较相同列上的字符是否相同，如果相同则继续对下一列进行比较，如果不相同则当前列不再属于公共前缀，当前列之前的部分为最长公共前缀。

时间复杂度：$O(mn)$，其中 $m$ 是字符串数组中的字符串的平均长度，$n$ 是字符串的数量。最坏情况下，字符串数组中的每个字符串的每个字符都会被比较一次。空间复杂度：$O(1)$，使用的额外空间复杂度为常数。

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:
            return ""
        
        length, count = len(strs[0]), len(strs)
        for i in range(length):
            c = strs[0][i]
            if any(i == len(strs[j]) or strs[j][i] != c for j in range(1, count)):
                return strs[0][:i]
        
        return strs[0]

执行用时：33 ms
消耗内存：16.43 MB

参考来源：力扣官方题解

2.3 分治

注意到 $LCP$ 的计算满足结合律，有以下结论：

$LCP(S_1,...,S_n)=LCP(LCP(S_1,S_k),LCP(S_{k+1},...,S_n))$

其中，$LCP(S_1,...,S_n)$ 是字符串 $S_1\dots S_n$ 的最长公共前缀，$1<k<n$。

基于上述结论，可以使用分治法得到字符串数组中的最长公共前缀。对于问题 $\text{LCP}(S_i\cdots S_j)$，可以分解成两个子问题 $\text{LCP}(S_i\dots S_{mid})$ 与 $\text{LCP}(S_{mid+1}\dots S_j)$，其中 $mid=\frac{i+j}{2}$。对两个子问题分别求解，然后对两个子问题的解计算最长公共前缀，即为原问题的解。

时间复杂度：$O(mn)$，其中 $m$ 是字符串数组中的字符串的平均长度，$n$ 是字符串的数量。时间复杂度的递推式是 $T(n)=2\cdot T(\frac{n}{2})+O(m)$，递推次数是 $n$ 级别的复杂度，因此可得 $T(n)=O(mn)$。空间复杂度：$O(m\log n)$，其中 $m$ 是字符串数组中的字符串的平均长度，$n$ 是字符串的数量。空间复杂度主要取决于递归调用的层数，层数最大为 $\log n$，每层需要 $m$ 的空间存储返回结果。

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        def lcp(start, end):
            if start == end:
                return strs[start]

            mid = (start + end) // 2
            lcpLeft, lcpRight = lcp(start, mid), lcp(mid + 1, end)
            minLength = min(len(lcpLeft), len(lcpRight))
            for i in range(minLength):
                if lcpLeft[i] != lcpRight[i]:
                    return lcpLeft[:i]

            return lcpLeft[:minLength]

        return "" if not strs else lcp(0, len(strs) - 1)

执行用时：30 ms
消耗内存：16.46 MB

参考来源：力扣官方题解

2.4 二分查找

显然，最长公共前缀的长度不会超过字符串数组中的最短字符串的长度。用 $\text{minLength}$ 表示字符串数组中的最短字符串的长度，则可以在 $[0,\text{minLength}]$ 的范围内通过二分查找得到最长公共前缀的长度。每次取查找范围的中间值 $\text{mid}$，判断每个字符串的长度为 $\text{mid}$ 的前缀是否相同，如果相同则最长公共前缀的长度一定大于或等于 $\text{mid}$，如果不相同则最长公共前缀的长度一定小于 $\text{mid}$，通过上述方式将查找范围缩小一半，直到得到最长公共前缀的长度。

时间复杂度：$O(mn\log m)$，其中 $m$ 是字符串数组中的字符串的最小长度，$n$ 是字符串的数量。二分查找的迭代执行次数是 $O(\log m)$，每次迭代最多需要比较 $mn$ 个字符，因此总时间复杂度是 $O(mn\log m)$。空间复杂度：$O(1)$。使用的额外空间复杂度为常数。

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        def isCommonPrefix(length):
            str0, count = strs[0][:length], len(strs)
            return all(strs[i][:length] == str0 for i in range(1, count))

        if not strs:
            return ""

        minLength = min(len(s) for s in strs)
        low, high = 0, minLength
        while low < high:
            mid = (high - low + 1) // 2 + low
            if isCommonPrefix(mid):
                low = mid
            else:
                high = mid - 1

        return strs[0][:low]

执行用时：35 ms
消耗内存：16.39 MB

参考来源：力扣官方题解