[LeetCode]290. Word Pattern 解题报告(C++)

[LeetCode]290. Word Pattern 解题报告(C++)

题目描述

Given a pattern and a string str, find if str follows the same pattern.

Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty word in str.

Example 1:

Input: pattern = "abba", str = "dog cat cat dog"
Output: true

Example 2:

Input:pattern = "abba", str = "dog cat cat fish"
Output: false

Example 3:

Input: pattern = "aaaa", str = "dog cat cat dog"
Output: false

Example 4:

Input: pattern = "abba", str = "dog dog dog dog"
Output: false

题目大意

• 判断str和给定 pattern 是不是相同的模式.

解题思路

方法1:

• 首先先将 str 按” “划分成几个string.存到vector中.
• 比较个数是否一致.不一致就直接返回false.
• 用 map<char,string> 来存储 pattern 字符和vector中字符串的一一对应关系.
• 遍历 pattern. 要去哈希表中查看.
• 1 若这个字符出现过. 但这个字符对应字符串和当前字符串不一致. 则false
• 2 若其他字符对应的对应的字符串和这个字符串一致. 则false
• 若没有出现过. 则将映射关系加入 map.

代码实现:

class Solution0 {
public:
    bool wordPattern(string pattern, string str) {
        map<char, string> m;
        vector<string> s;
        for (int i = 0; i < str.size(); i++) {
            int j = str.find(" ", i);
            string sub = str.substr(i, j - i);
            s.push_back(sub);
            if (j == -1) {
                break;
            }
            i = j;
        }
        int pn = pattern.size();
        int sn = s.size();
        if (pn != sn) return false;
        for (int i = 0; i < pn; i++) {
            for (auto x : m) {
                if (x.first == pattern[i]&&x.second!=s[i]) {
                    return false;
                }
                if (x.first != pattern[i] && x.second == s[i]) {
                    return false;
                }
            }
            m[pattern[i]] = s[i];
        }

        return true;
    }
};

方法2:

• 求单词字符串中单词出现的规律是否符合模式字符串中的规律。
• 那么首先想到就是用哈希表来做，建立模式字符串中每个字符和单词字符串每个单词之间的映射，而且这种映射必须是一对一关系的，不能’a‘和’b’同时对应‘dog’
• 在碰到一个新字符时，首先检查其是否在哈希表中出现，若出现，其映射的单词若不是此时对应的单词，则返回false。
• 如果没有在哈希表中出现，我们还要遍历一遍哈希表，看新遇到的单词是否已经是哈希表中的映射，如果没有，再跟新遇到的字符建立映射

代码实现:

class Solution1 {
public:
    bool wordPattern(string pattern, string str) {
        unordered_map<char, string> m;
        istringstream in(str);
        int i = 0;
        for (string word; in >> word; ++i) {
            if (m.find(pattern[i]) != m.end()) {
                if (m[pattern[i]] != word) return false;
            }
            else {
                for (unordered_map<char, string>::iterator it = m.begin(); it != m.end(); ++it) {
                    if (it->second == word) return false;
                }
                m[pattern[i]] = word;
            }
        }
        return i == pattern.size(); // 最后这个判断 nice. 长度不同也不对.
    }
};

方法3:

• 可以用两个哈希表完成
• 1 pattern中的char与当前位置的映射
• 2 string字符串与当前位置的映射
• 当遇到新字符时候,若两个哈希表至少一个存在映射.则判断下映射是否相等.
• 若都不存在.加入两个表的映射.

代码实现:

class Solution2 {
public:
    bool wordPattern(string pattern, string str) {

        unordered_map<char, int> m1;
        unordered_map<string, int> m2;

        istringstream in(str);

        int i = 0;
        for (string word; in >> word; i++) {
            if (m1.find(pattern[i]) != m1.end() || m2.find(word) != m2.end()) {
                if (m1[pattern[i]] != m2[word]) {
                    return false;
                }
            }
            else {
                m1[pattern[i]] = m2[word] = i + 1; // +1 
            }
        }

        return i == pattern.size();
    }
};

// 更简洁的写法
bool wordPattern(string pattern, string str) {
    map<char, int> p2i;
    map<string, int> w2i;
    istringstream in(str);
    int i = 0, n = pattern.size();
    for (string word; in >> word; ++i) {
        if (i == n || p2i[pattern[i]] != w2i[word])
            return false;
        p2i[pattern[i]] = w2i[word] = i + 1;
    }
    return i == n;
}