程序员面试金典 16.18

最新推荐文章于 2023-06-10 20:11:52 发布

原创最新推荐文章于 2023-06-10 20:11:52 发布 · 232 阅读

1 ·

CC 4.0 BY-SA版权

《程序员面试金典》专栏收录该内容

110 篇文章

订阅专栏

本文深入探讨了一种模式匹配算法，该算法通过给定的模式串和目标字符串来判断两者是否匹配，模式串仅由'a'和'b'组成。文章详细解释了如何根据模式串中的'a'和'b'数量，确定匹配串并进行比较，提供了两种实现方式：一种是通过构造完整字符串进行匹配；另一种是直接对比分割后的字符串部分。此外，还讨论了时间复杂度为O(n^2)的解决方案。

Pattern Matching：给定模式串和一个字符串，模式串中只包含a和b，判断字符串是否和模式串匹配。

首先要明确模式串中只有a和b，所以一旦确定了a的匹配串，就可以根据a和b的数量，确定b的匹配串，然后构造出字符串进行完整比较，时间复杂度为O(n ^ 2)。

评论区中有人说边界条件比较复杂，可能是没看书吧 😃

class Solution {
public:
    bool patternMatching(string pattern, string value) {
        char MainPat = pattern[0];
        char AltPat = pattern[0] == 'a' ? 'b' : 'a';
        size_t MainCnt = 0, AltCnt = 0;
        for(char c : pattern)
        {
            if(c == MainPat) MainCnt++;
            else AltCnt++;
        }
        size_t FirstAlt = pattern.find(AltPat);
        for(size_t MainSize = 0; MainSize <= value.size(); MainSize++)
        {
            if(value.size() < MainSize * MainCnt) continue;
            size_t RemLen = value.size() - MainSize * MainCnt;
            string MainStr(value.data(), MainSize);
            if(AltCnt == 0 || RemLen % AltCnt == 0){
                size_t AltSize = AltCnt == 0 ? 0 : RemLen / AltCnt;
                string AltStr = AltSize == 0 ? "" : value.substr(FirstAlt * MainSize, AltSize);
                if(AltCnt > 0 && MainStr == AltStr) continue;
                if(value == build(pattern, MainPat, MainStr, AltStr)) return true;
            }
        }
        return false;
    }
private:
    string build(const string &pattern, const char MainPat, const string &MainStr, const string &AltStr)
    {
        string ret;
        for(char c : pattern)
        {
            if(c == MainPat) ret += MainStr;
            else ret += AltStr;
        }
        return ret;
    }
};

判断是否匹配时，也可以不构造完整的字符串，根据模式串对原字符串进行划分，比较划分后的每一部分是否和MainStr或者AltStr相等。

class Solution {
public:
    bool patternMatching(string pattern, string value) {
        char MainPat = pattern[0];
        char AltPat = pattern[0] == 'a' ? 'b' : 'a';
        size_t MainCnt = 0, AltCnt = 0;
        for(char c : pattern)
        {
            if(c == MainPat) MainCnt++;
            else AltCnt++;
        }
        size_t FirstAlt = pattern.find(AltPat);
        for(size_t MainSize = 0; MainSize <= value.size(); MainSize++)
        {
            if(value.size() < MainSize * MainCnt) continue;
            size_t RemLen = value.size() - MainSize * MainCnt;
            string MainStr(value.data(), MainSize);
            if(AltCnt == 0 || RemLen % AltCnt == 0){
                size_t AltSize = AltCnt == 0 ? 0 : RemLen / AltCnt;
                string AltStr = AltSize == 0 ? "" : value.substr(FirstAlt * MainSize, AltSize);
                if(AltCnt > 0 && MainStr == AltStr) continue;
                size_t ValueIdx = MainSize;
                for(size_t PatternIdx = 1; PatternIdx < pattern.size(); PatternIdx++)
                {
                    if(pattern[PatternIdx] == MainPat){
                        if(MainStr != value.substr(ValueIdx, MainSize)) break;
                        else ValueIdx += MainSize;
                    }
                    else{
                        if(AltStr != value.substr(ValueIdx, AltSize)) break;
                        else ValueIdx += AltSize;
                    }
                }
                if(ValueIdx == value.size()) return true;
            }
        }
        return false;
    }
};