Leetcode 14最长公共前缀

题目描述

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

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

示例1：

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

示例2：

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

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

解法
同时连续比较多个字符串，不知道如何遍历，是用n个指针还是怎样；
不知道如何寻找两个字符串的公共子串。

横向扫描法

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);
    }
};

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

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];
    }
};

分治策略

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);
    }
};