290. 单词规律

290. 单词规律

难度：简单🌟🌟🌟

---

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", str = "dog cat cat dog"
输出: true

示例 2:

输入:pattern = "abba", str = "dog cat cat fish"
输出: false

示例 3:

输入: pattern = "aaaa", str = "dog cat cat dog"
输出: false

示例 4:

输入: pattern = "abba", str = "dog dog dog dog"
输出: false

说明:
你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。

---

题解：

利用哈希表

判断字符与字符串之间是否恰好一一对应。即任意一个 $pattern$ 中的字符都对应着唯一的 $str$ 中的字符串，任意一个 $str$ 中的字符串也只被唯一的一个 $pattern$ 中的字符对应。

双向连接意味着，$a$ 只对应着 $dog$ ，且 $dog$ 也只对应着 $a$ ，因此在双向连接的对应规律下，上述的 $abba$ 与 $dogdogdogdog$ 是匹配失败的，只有 $abba$ 与 $dogcatcatdog$ 这种可以匹配成功

c++

因为没有 $split$ 函数处理空格稍微麻烦点。

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        unordered_map<string,char> str2ch;
        unordered_map<char,string> ch2str;

        vector<string> arr;
        int j=0;
        for(int i=0;i<str.size();i++)
        {
            if(i==str.size()-1)
            {
                arr.push_back(str.substr(j,str.size()-j));
            }
            if(str[i]==' ')
            {
                arr.push_back(str.substr(j,i-j));
                j=i+1;
            }
        }
        if(pattern.size()!=arr.size()) return false;
        
        for(int i=0;i<pattern.size();i++)
        {
            if(str2ch.find(arr[i])!=str2ch.end() && str2ch[arr[i]]!=pattern[i])
            {
                return false;
            }
            if(ch2str.find(pattern[i])!=ch2str.end() && ch2str[pattern[i]]!=arr[i])
            {
                return false;
            }
            ch2str[pattern[i]]=arr[i];
            str2ch[arr[i]]=pattern[i];
        }

        return true;
    }
};

python

投机取巧的做法…

class Solution:
    def wordPattern(self, pattern: str, s: str) -> bool:
        strList = s.split(' ')

        return list(map(pattern.index,pattern)) == list(map(strList.index,strList))

复杂度分析：

• 时间复杂度：$O(n+m)$ ，其中 $n$ 为$pattern$ 的长度，$m$ 为 $str$ 的长度。插入和查询哈希表的均摊时间复杂度均为$O(n+m)$ 。每一个字符至多只被遍历一次。
• 空间复杂度：$O(n+m)$ ，其中 $n$ 为 $pattern$ 的长度，$m$ 为 $str$ 的长度。最坏情况下，我们需要存储 $pattern$ 中的每一个字符和 $str$ 中的每一个字符串。

参考：

• LC-official