leetcode题：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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/word-pattern
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解题思路

1、使用map记录pattern每个字符的下标

2、抽取word到数组中

3、遍历每种字符，判断字符所有下标的word数组中对应的单词是否相等，并且判断word数量是否和这个字符的数量相等。

三、代码

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        map<char,vector<int>> pt;
  
        //map<char,string> sstr;
        for(int i = 0; i < pattern.size(); i ++)
        {
            if(pt.count(pattern[i]) == 0)
            {
                pt[pattern[i]] = vector<int>();
            }
            pt[pattern[i]].push_back(i);
        }
        int left = 0;
        int right = 0;
        map<string,int> str_count;
        vector<string> sstr;
        while(left < str.size() && str[left] == ' ')
        {
            left++;
        }
        right = left + 1;
        for(; right < str.size(); right++)
        {
            if(str[right] == ' ')
            {
                sstr.push_back(str.substr(left,right - left));
                left = right + 1;
            }
            if(right == str.size() - 1)
            {
                sstr.push_back(str.substr(left,right - left + 1));
            }
        }
        print_s(sstr);
        if(sstr.size() != pattern.size())
            return false;
        for(auto it = pt.begin(); it != pt.end(); it ++)
        {
            vector<int> & tmp_str = it->second;
            string tmp;
            for(int i = 0;i < tmp_str.size();i++)
            {
                if(i == 0)
                {
                    tmp = sstr[tmp_str[0]];
                    str_count[tmp]++;
                    continue;
                }
                str_count[tmp]++;
                if(sstr[tmp_str[i]] != tmp)
                    return false;
            }
            if(str_count[tmp] != tmp_str.size())
                return false;
            
        }
        return true;
    }
    void print_s(vector<string> & strs)
    {
        for(int i = 0; i < strs.size(); i ++)
        {
            cout << strs[i]<<",";
        }
        cout<<endl;
    }
};

代码二（一个大神写的及其简单的代码）

思路是同时遍历当前pattern的字符c和str里的word，如果当前c 的前一个位置不等于word的前一个则说明不匹配，如果c的前一个位置和word的前一个位置相等说明匹配（这一点有点难理解），然后记录c和word的位置为当前位置。直到遍历完pattern和str则匹配（如果pattern长度和str的单词长度不想等也不匹配）

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        unordered_map<char, int> m1;
        unordered_map<string, int> m2;
        istringstream in(str);
        int i = 0, n = pattern.size();
        for(string word; in >> word; i++){
            if(i == n || m1[pattern[i]] != m2[word])
                return false;
            m1[pattern[i]] = m2[word] = i + 1;
        }
        return i == n;
    }
};