找最长公共前缀

前言：在python中，比较两个字符串的大小，比较的是首个字母的ascll码值，如果首个字母的值相同，就以此类推，继续往下进行比较，直到得出结果为止

1、利用字符串比较大小，找出最长公共前缀：

from typing import List
 
class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs: return ""
        s1 = min(strs)
        s2 = max(strs)
        print(s1, s2)
        for i, x in enumerate(s1):
            if x != s2[i]:
                return s2[:i]
        return s1
 
 
s = Solution()
print("\033[32m[+]\033[0m", "\033[33m", s.longestCommonPrefix(["flowers", "flow", "flight", "forjrigdfl"]), "\033[0m")
print("""\033[31m
巧妙利用python比较两个字符串的方法：
    python比较两个字符串比较的是首个字母ascll码值，若相等就比较下一个，以此类推\033[0m
""")

 2、利用横向扫描的方法找出最长公共前缀：

第二种找出公共前缀的方法，定义一个lcp方法用于过滤出两个字符串相同的部分，然后循环调用这个过滤的方法，最后得出这个字符串数组里面的字符串的最长公共前缀：

from typing import List
 
class Solution1:
    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]
 
 
s1 = Solution1()
print("\033[32m[+]\033[0m", "\033[33m", s1.longestCommonPrefix(["leecode", "leet", "ledem", "leet"]), "\033[0m")
 
print("""\033[31m
复杂度分析：
    时间复杂度：O(mn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。
    最坏情况下，字符串数组中的每个字符串的每个字符都会被比较一次。
    空间复杂度：O(1)。因为使用的额外空间复杂度为常数。\033[0m
""")

3、利用纵向扫描的方法，将字符串的最长前缀找出：

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

from typing import List
 
class Solution2:
    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]
 
 
s2 = Solution2()
print('\033[32m[+]\033[0m', "\033[33m", s2.longestCommonPrefix(["dog", "dat", "does", "dpon"]), "\033[0m")
print("""
\033[31m复杂度分析：\033[0m
\033[35m时间复杂度：O(mn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。最坏情况下，字符串数组中的每个字符串的每个字符都会被比较一次。
        空间复杂度：O(1)。使用的额外空间复杂度为常数。\033[0m
""")

4、可以采用分而治之的方法，先将数组按两个一组进行比较找出最长公共前缀，再以此类推继续进行比较，得到的结果再进行比较，最后合并得到的结果，找出最终的最长公共前缀 

from typing import List
 
class Solution3:
    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)
 
 
s3 = Solution3()
print("\033[45m", s3.longestCommonPrefix(["leetcode", "leet", "leed"]), "\033[0m")
print("""
\033[46m复杂度分析:\033[0m
    \033[45m时间复杂度：O(mn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。递推式:T(n) = 2*T(n/2) + O(m),计算得T(n) = O(mn)
    空间复杂度：O(m log n)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。空间复杂度主要取决于递归调用的层数，
                层数最大为log n，每层需要 m 的空间存储返回结果。\033[0m
""")

5、二分法

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

from typing import List
 
class Solution4:
    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]
 
 
s4 = Solution4()
print("\033[45m", s4.longestCommonPrefix(["leetcode", "leet", "leed"]), "\033[0m")
print("""
\033[41m复杂度:\033[0m
    \033[45m时间复杂度：O(mn log m)，其中 m 是字符串数组中的字符串的最小长度，
                n 是字符串的数量。二分查找的迭代执行次数是 O(log m)，
                每次迭代最多需要比较 mn 个字符，因此总时间复杂度是 O(mn log m)。
    空间复杂度：O(1)。使用的额外空间复杂度为常数。\033[0m
 
""")

 Finished!