LeetCode#14 - 最长公共前缀

LeetCode#14 - 最长公共前缀

题目描述

代码实现

// 自己想出来的算法，纵向扫描
class Solution
{
public:
    string longestCommonPrefix(vector<string> &strs)
    {
        string res = "";
        if(!strs.size())
        return res;
        for (int i = 0; i < strs[0].length(); i++)
        {
            // 取出第一个字符串中的字符
            char ch = strs[0][i];
            // 与其他字符串对应位置的字符比较
            for (int j = 1; j < strs.size(); j++)
            {
                if (strs[j][i] != ch)
                    return res;
            }
                res.push_back(ch);
        }
        return res;
    }
};

// JS实现
var longestCommonPrefix = function (strs) {
    var res = "";
    if (strs.length === 0)
        return res;
    for (var i = 0; i < strs[0].length; i++) {
        var ch = strs[0][i];
        for (var j = 1; j < strs.length; j++) {
            if (strs[j][i] != ch)
                return res;
        }
        res += ch;
    }
    return res;
};

力扣题解补充算法

分治法

/* 
LCP计算满足结合律：LCP(S1...Sn)=LCP(LCP(S1...Sk),LCP(Sk+1...Sn))
分治法得到字符串数组中的最长公共前缀，对于问题可以分解为两个子问题，其中k=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);
    }
};
/* 
时间复杂度：O(mn)，其中m是字符串数组中的字符串的平均长度，n是字符串的数量。时间复杂度的递推式是 T(n)=2*T(n/2)+O(m),通过计算可得 T(n)=O(mn)。

空间复杂度：O(mlogn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。空间复杂度主要取决于递归调用的层数，层数最大为logn，每层需要 m 的空间存储返回结果。

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

二分查找

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

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/longest-common-prefix/solution/zui-chang-gong-gong-qian-zhui-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
 */
#include <string>
#include <iostream>
#include <vector>
using namespace std;
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;
    }
};
/* 
时间复杂度：O(mnlogm)，其中 m 是字符串数组中的字符串的最小长度，n 是字符串的数量。二分查找的迭代执行次数是 O(logm)，每次迭代最多需要比较 mn 个字符，因此总时间复杂度是O(mnlogm)。

空间复杂度：O(1)。使用的额外空间复杂度为常数。
 */