【每日力扣20】最长公共前缀

最新推荐文章于 2023-12-06 16:17:13 发布

一饭名厨姚鲲鲲

最新推荐文章于 2023-12-06 16:17:13 发布

阅读量324

点赞数 1

分类专栏： # 【算法】字符串文章标签： leetcode 算法 c++ 字符串分治算法

本文链接：https://blog.csdn.net/micah_yaokunkun/article/details/122469201

版权

算法同时被 2 个专栏收录

42 篇文章 0 订阅

订阅专栏

【算法】字符串

9 篇文章 0 订阅

订阅专栏

一、题目[LeetCode-14]

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

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

示例 1：

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

输出："fl"

示例 2：

输入：strs = ["dog","racecar","car"]

输出：""

解释：输入不存在公共前缀。

提示：

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

二、思路

对strs的每个string，用一个for循环从length=0开始依次访问每一个string[length]，如果所有string[length]相等，则length更新，否则退出循环，返回length即可。

不过为防止数组越界，要找出strs数组中长度最小的string，以它的长度n作为for循环的上界。并要先考虑到它是空字符串的退化情况（“提示”中0 <= strs[i].length ，即允许存在空字符串的情况）。

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        int strNum = strs.size();
        int n = strs[0].size();//n保存strs中长度最小的字符串的长度
        if (strNum == 1)//题目中规定1≤strs.length，因此可能有strNum=1的情况，为防后续for循环数组越界，这里先讨论strNum=1的退化情况
            return strs[0];
        for (int i = 1; i < strNum; i++)//找出长度最小字符串的长度
        {
            if (strs[i].size() < n)
                n = strs[i].size();
        }
        if (n == 0)//先考虑n=0的退化情况
            return "";
        int commonLength = 0;//commonLength保存公有前缀的长度
        bool breakFor = false;//让下面的嵌套循环达到终止条件时通过它来跳出外层for循环
        for (; commonLength < n&&!breakFor; commonLength++)
        {
            for (int i = 1; i < strNum; i++)
                if (strs[i][commonLength] != strs[i - 1][commonLength])
                {
                    commonLength--;
                    breakFor = true;
                    break;//跳出内层循环
                }
        }//所得commonLength-1即为公共前缀长度
        string commonPrefix;
        for (int j = 0; j < commonLength; j++)
            commonPrefix.push_back(strs[0][j]);
        return commonPrefix;
    }
};

三、官方题解（来源：力扣（LeetCode））

方法一：横向扫描

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

可以得到以下结论：

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

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

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

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if (!strs.size()) {
            return "";
        }
        string prefix = strs[0];
        int count = strs.size();
        for (int i = 1; i < count; ++i) {
            prefix = longestCommonPrefix(prefix, strs[i]);
            if (!prefix.size()) {
                break;
            }
        }
        return prefix;
    }

    string longestCommonPrefix(const string& str1, const string& str2) {
        int length = min(str1.size(), str2.size());
        int index = 0;
        while (index < length && str1[index] == str2[index]) {
            ++index;
        }
        return str1.substr(0, index);
    }
};

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

复杂度分析

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

方法二：纵向扫描

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

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if (!strs.size()) {
            return "";
        }
        int length = strs[0].size();
        int count = strs.size();
        for (int i = 0; i < length; ++i) {
            char c = strs[0][i];
            for (int j = 1; j < count; ++j) {
                if (i == strs[j].size() || strs[j][i] != c) {
                    return strs[0].substr(0, i);
                }
            }
        }
        return strs[0];
    }
};

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

复杂度分析

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

方法三：分治（二分分治）

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

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

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

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

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if (!strs.size()) {
            return "";
        }
        else {
            return longestCommonPrefix(strs, 0, strs.size() - 1);
        }
    }

    string longestCommonPrefix(const vector<string>& strs, int start, int end) {
        if (start == end) {
            return strs[start];
        }
        else {
            int mid = (start + end) / 2;
            string lcpLeft = longestCommonPrefix(strs, start, mid);
            string lcpRight = longestCommonPrefix(strs, mid + 1, end);
            return commonPrefix(lcpLeft, lcpRight);
        }
    }

    string commonPrefix(const string& lcpLeft, const string& lcpRight) {
        int minLength = min(lcpLeft.size(), lcpRight.size());
        for (int i = 0; i < minLength; ++i) {
            if (lcpLeft[i] != lcpRight[i]) {
                return lcpLeft.substr(0, i);
            }
        }
        return lcpLeft.substr(0, minLength);
    }
};

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

复杂度分析

时间复杂度：O(mn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。时间复杂度的递推式是 T(n)=2·T(n/2)+O(m)，通过计算可得 T(n)=O(mn)。
空间复杂度：O(mlogn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。空间复杂度主要取决于递归调用的层数，层数最大为 logn，每层需要 m 的空间存储返回结果。

方法四：二分查找（纵向二分）

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

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if (!strs.size()) {
            return "";
        }
        int minLength = min_element(strs.begin(), strs.end(), [](const string& s, const string& t) {return s.size() < t.size();})->size();
        int low = 0, high = minLength;
        while (low < high) {
            int mid = (high - low + 1) / 2 + low;
            if (isCommonPrefix(strs, mid)) {
                low = mid;
            }
            else {
                high = mid - 1;
            }
        }
        return strs[0].substr(0, low);
    }

    bool isCommonPrefix(const vector<string>& strs, int length) {
        string str0 = strs[0].substr(0, length);
        int count = strs.size();
        for (int i = 1; i < count; ++i) {
            string str = strs[i];
            for (int j = 0; j < length; ++j) {
                if (str0[j] != str[j]) {
                    return false;
                }
            }
        }
        return true;
    }
};

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

复杂度分析

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

四、学习心得

①主算法调用子方法的思想

方法一、三、四都有调用子方法，上层算法先写主要框架，具体主要功能由调用子方法来实现，写在子方法里。这样可以使代码更有条理层次感，思路清晰。如方法一，主算法即string longestCommonPrefix(vector<string>& strs)，用于实现“横向扫描”方法的主框架，而具体对于两个具体字符串的公共前缀求取则由重载子方法string longestCommonPrefix(const string& str1, const string& str2)实现。

②退化情况的考虑

诸如本题的问题都会出现空字符串strs[i]和空数组strs的可能，最好在最开始先讨论，以免后面for循环时出现越界的问题。如官解四种方法都在主框架的开头写上了

if (!strs.size()) {

            return "";

③分治法

方法三相当于横向扫描的二分处理，使用了分治策略，方法四相当于纵向扫描的二分处理，使用了二分查找。

虽然本题分治策略没有降低时间复杂度，但是诸如归并排序等二分的分治策略可以将原本为O(N²)降低至O(NlogN)。

而本题二分查找可以将时间复杂度从O(mn)降至O(mnlogm)（纵向扫描二分）。

另外注意的是分治策略需要调用递归，会有额外空间复杂度O(mlogn)，因为递归调用了子函数O(logn)次，O(m)是字符串长度。

一饭名厨姚鲲鲲

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【每日力扣20】最长公共前缀

一、题目[LeetCode-14]编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。示例 1：输入：strs = ["flower","flow","flight"]输出："fl"示例 2：输入：strs = ["dog","racecar","car"]输出：""解释：输入不存在公共前缀。提示：1 <= strs.length <= 200 0 <= strs[i].length <= ..
复制链接

扫一扫