LeetCode刷题-字符串14：最长公共前缀

Not_meli_coco

已于 2023-07-21 13:50:28 修改

阅读量65

点赞数

文章标签： leetcode 算法职场和发展 python

于 2023-07-21 00:24:51 首次发布

本文链接：https://blog.csdn.net/Not_meli_coco/article/details/131841732

版权

题目

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

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

示例1：

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

示例2：

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

提示：

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

解题思路

在本题中比较推荐前两种，即横纵向扫描，比较好理解，而且时间复杂度相对后面两种少。分治法和二分查找在这里使用显得有点绕，感兴趣的可以自己研究下。

奇招！！！

在LeetCode评论区发现大佬xshura发的方法！爱了爱了

利用python的max()和min()，在Python里字符串是可以比较的，从字符串首位开始比较，按照ascII值排，举例abb， aba，abac，最大为abb，最小为aba。所以只需要比较最大最小的公共前缀就是整个数组的公共前缀

本题代码如下：

    def longestCommonPrefix(self, strs):
        if not strs:
            return ""
        s1 = min(strs)
        s2 = max(strs)
        
        # i为s1的下标，x为s1中该下标对应字符
        for i,x in enumerate(s1):
            if x != s2[i]:
                return s2[:i]
        return s1

补充小知识：

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标。

season=['spring','summer','fall','winter']
print(enumerate(season))
print(list(enumerate(season)))
for i in enumerate(season):
    print(i)
for i,element in enumerate(season):
    print(i,season[i])
    print(i)

输出结果：

<enumerate object at 0x000002CE4C2EC870>

[(0, 'spring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]

(0, 'spring')
(1, 'summer')
(2, 'fall')
(3, 'winter')

0 spring
0
1 summer
1
2 fall
2
3 winter
3

法1：横向扫描

用 LCP(S1…Sn)LCP(S1…Sn) 表示字符串 S1…SnS1…Sn 的最长公共前缀。

可以得到以下结论：

LCP(S1…Sn)=LCP(LCP(LCP(S1,S2),S3),…Sn)

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

用 LCP(S1…Sn)LCP(S1…Sn) 表示字符串 S1…SnS1…Sn 的最长公共前缀。

可以得到以下结论：

LCP(S1…Sn)=LCP(LCP(LCP(S1,S2),S3),…Sn)LCP(S1…Sn)=LCP(LCP(LCP(S1,S2),S3),…Sn)

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

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        # 如果数组为空，则最长公共前缀为空
        if not strs:
            return ""
        
        #构造循环，将数组中的字符串两个两个传入函数来求解最长公共前缀，如果结果为空，则结束循环
        prefix = strs[0]
        for i in range(1,len(strs)):
            prefix = self.lcp(prefix,strs[i])
            if not prefix:
                break
        return prefix
            

    #构造函数来求两个数组的最长公共前缀
    def lcp(self,str1,str2):
        length = min(len(str1),len(str2))
        index = 0
        while index < length and str1[index] == str2[index]:
            index +=1
        return str1[:index]

法2：纵向扫描

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

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:
            return ""
    
        for i in range(len(strs[0]):
            c = strs[0][i] 
            for j in range(1,len(strs)):
                #当i == len(strs[j])时，说明已经到达某个字符串的末尾，当前列之前的部门就是最长公共前缀，不需要再往下扫描了
                if i == len(strs[j]) or strs[j][i] != c:
                    return strs[0][:i]
        return strs[0]

法3：分治

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

LCP(S1…Sn)=LCP(LCP(S1…Sk),LCP(Sk+1…Sn))LCP(S1…Sn)=LCP(LCP(S1…Sk),LCP(Sk+1…Sn))

其中 LCP(S1…Sn)LCP(S1…Sn) 是字符串 S1…SnS1…Sn 的最长公共前缀，1<k<n1<k<n。

基于上述结论，可以使用分治法得到字符串数组中的最长公共前缀。对于问题 LCP(Si⋯Sj)LCP(Si⋯Sj)，可以分解成两个子问题 LCP(Si…Smid)LCP(Si…Smid) 与 LCP(Smid+1…Sj)LCP(Smid+1…Sj)，其中 mid=i+j2mid=2i+j。对两个子问题分别求解，然后对两个子问题的解计算最长公共前缀，即为原问题的解。

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        
        # 构造函数
        def lcp(start,end):
            # 只有一个字符串，该字符串就是这两个字符串的最长公共前缀
            if start == end:
                return strs[start]
            
            # //是整除，/是除号
            mid = (start + end) // 2
            lcp_Left, lcp_Right = lcp(start,mid), lcp(mid+1,end)
            minlength = min(len(lcp_Left), len(lcp_Right))
            for i in range(minLenght):
                if lcp_Left[i] != lcp_Right[i]:
                    return lcp_Left[:i]
            return lcp_Left[:minlength]

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

法4：二分查找

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

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]

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/longest-common-prefix/solution/zui-chang-gong-gong-qian-zhui-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。