1. 题目
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀,返回空字符串 “”。
示例 1:
输入:strs = [“flower”,“flow”,“flight”]
输出:“fl”
示例 2:
输入:strs = [“dog”,“racecar”,“car”]
输出:“”
解释:输入不存在公共前缀。
提示:
- 1 < = s t r s . l e n g t h < = 200 1 <= strs.length <= 200 1<=strs.length<=200
- 0 < = s t r s [ i ] . l e n g t h < = 200 0 <= strs[i].length <= 200 0<=strs[i].length<=200
- strs[i] 仅由小写英文字母组成
2. 思路及代码实现(Python)
2.1 横向扫描
用 L C P ( S 1 … S n ) LCP(S_1…S_n) LCP(S1…Sn) 表示字符串 S 1 … S n S_1…S_n S1…Sn 的最长公共前缀。
可以得到以下结论:
L C P ( S 1 , . . . , S n ) = L C P ( L C P ( L C P ( S 1 , S 2 ) , S 3 ) , . . . S n ) LCP(S_1,...,S_n)=LCP(LCP(LCP(S_1,S_2), S_3),...S_n) LCP(S1,...,Sn)=LCP(LCP(LCP(S1,S2),S3),...Sn)
基于该结论,可以得到一种查找字符串数组中的最长公共前缀的简单方法。依次遍历字符串数组中的每个字符串,对于每个遍历到的字符串,更新最长公共前缀,当遍历完所有的字符串以后,即可得到字符串数组中的最长公共前缀。
如果在尚未遍历完所有的字符串时,最长公共前缀已经是空串,则最长公共前缀一定是空串,因此不需要继续遍历剩下的字符串,直接返回空串即可。
时间复杂度: O ( m n ) O(mn) O(mn),其中 m m m 是字符串数组中的字符串的平均长度, n n n 是字符串的数量。最坏情况下,字符串数组中的每个字符串的每个字符都会被比较一次。空间复杂度: O ( 1 ) O(1) 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 ( m n ) O(mn) O(mn),其中 m m m 是字符串数组中的字符串的平均长度, n n n 是字符串的数量。最坏情况下,字符串数组中的每个字符串的每个字符都会被比较一次。空间复杂度: O ( 1 ) O(1) 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 分治
注意到 L C P LCP LCP 的计算满足结合律,有以下结论:
L C P ( S 1 , . . . , S n ) = L C P ( L C P ( S 1 , S k ) , L C P ( S k + 1 , . . . , S n ) ) LCP(S_1,...,S_n)=LCP(LCP(S_1,S_k), LCP(S_{k+1},...,S_n)) LCP(S1,...,Sn)=LCP(LCP(S1,Sk),LCP(Sk+1,...,Sn))
其中, L C P ( S 1 , . . . , S n ) LCP(S_1,...,S_n) LCP(S1,...,Sn) 是字符串 S 1 … S n S_1…S_n S1…Sn 的最长公共前缀, 1 < k < n 1<k<n 1<k<n。
基于上述结论,可以使用分治法得到字符串数组中的最长公共前缀。对于问题 LCP ( S i ⋯ S j ) \textit{LCP}(S_i\cdots S_j) LCP(Si⋯Sj),可以分解成两个子问题 LCP ( S i … S m i d ) \textit{LCP}(S_i \ldots S_{mid}) LCP(Si…Smid) 与 LCP ( S m i d + 1 … S j ) \textit{LCP}(S_{mid+1} \ldots S_j) LCP(Smid+1…Sj),其中 m i d = i + j 2 mid=\frac{i+j}{2} mid=2i+j。对两个子问题分别求解,然后对两个子问题的解计算最长公共前缀,即为原问题的解。
时间复杂度: O ( m n ) O(mn) O(mn),其中 m m m 是字符串数组中的字符串的平均长度, n n n 是字符串的数量。时间复杂度的递推式是 T ( n ) = 2 ⋅ T ( n 2 ) + O ( m ) T(n)=2 \cdot T(\frac{n}{2})+O(m) T(n)=2⋅T(2n)+O(m),递推次数是 n n n 级别的复杂度,因此可得 T ( n ) = O ( m n ) T(n)=O(mn) T(n)=O(mn)。空间复杂度: O ( m log n ) O(m \log n) O(mlogn),其中 m m m 是字符串数组中的字符串的平均长度, n n n 是字符串的数量。空间复杂度主要取决于递归调用的层数,层数最大为 log n \log n logn,每层需要 m m 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 二分查找
显然,最长公共前缀的长度不会超过字符串数组中的最短字符串的长度。用 minLength \textit{minLength} minLength 表示字符串数组中的最短字符串的长度,则可以在 [ 0 , minLength ] [0,\textit{minLength}] [0,minLength] 的范围内通过二分查找得到最长公共前缀的长度。每次取查找范围的中间值 mid \textit{mid} mid,判断每个字符串的长度为 mid \textit{mid} mid 的前缀是否相同,如果相同则最长公共前缀的长度一定大于或等于 mid \textit{mid} mid,如果不相同则最长公共前缀的长度一定小于 mid \textit{mid} mid,通过上述方式将查找范围缩小一半,直到得到最长公共前缀的长度。
时间复杂度: O ( m n log m ) O(mn \log m) O(mnlogm),其中 m m m 是字符串数组中的字符串的最小长度, n n n 是字符串的数量。二分查找的迭代执行次数是 O ( log m ) O(\log m) O(logm),每次迭代最多需要比较 m n mn mn 个字符,因此总时间复杂度是 O ( m n log m ) O(mn \log m) O(mnlogm)。空间复杂度: O ( 1 ) O(1) 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
参考来源:力扣官方题解