LeetCode 题解(257) : Word Pattern

题目：

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

Examples:

1. pattern = "abba", str = "dog cat cat dog" should return true.
2. pattern = "abba", str = "dog cat cat fish" should return false.
3. pattern = "aaaa", str = "dog cat cat dog" should return false.
4. pattern = "abba", str = "dog dog dog dog" should return false.

Notes:

1. patterncontains only lowercase alphabetical letters, and str contains words separated by a single space. Each word in str contains only lowercase alphabetical letters.
2. Both pattern and str do not have leading or trailing spaces.
3. Each letter in pattern must map to a word with length that is at least 1.

题解：

需要用两个HashMap。需要注意的情况有，pattern长度和tokens长度不相等，token已经被之前的某一个character用过了。

C++版：

#include <algorithm>
#include <iterator>
#include <sstream>

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        unordered_map<char, string> d;
        unordered_map<string, bool> used;
        stringstream ss(str);
        istream_iterator<std::string> begin(ss);
        istream_iterator<std::string> end;
        vector<string> tokens(begin, end);
        if(tokens.size() != pattern.length())
            return false;
        for(int i = 0; i < pattern.length(); i++) {
            if(d.find(pattern[i]) == d.end()) {
                if(used.find(tokens[i]) == used.end()) {
                    d.insert(pair<char, string>(pattern[i], tokens[i]));
                    used.insert(pair<string, bool>(tokens[i], true));
                } else
                    return false;
            } else if(d[pattern[i]] != tokens[i])
                return false;
        }
        return true;
    }
};

Java版：

public class Solution {
    public boolean wordPattern(String pattern, String str) {
        HashMap<Character, String> d = new HashMap<>();
        HashMap<String, Boolean> used = new HashMap<>();
        
        String[] tokens = str.split("\\s+");
        if(pattern.length() != tokens.length)
            return false;
        for(int i = 0; i < pattern.length(); i++) {
            if(!d.containsKey(pattern.charAt(i))) {
                if(used.containsKey(tokens[i]))
                    return false;
                else {
                    d.put(pattern.charAt(i), tokens[i]);
                    used.put(tokens[i], true);
                }
            } else if(!d.get(pattern.charAt(i)).equals(tokens[i]))
                return false;
        }
        return true;
    }
}

Python版：

class Solution(object):
    def wordPattern(self, pattern, str):
        """
        :type pattern: str
        :type str: str
        :rtype: bool
        """
        tokens = str.split()
        if len(pattern) != len(tokens):
            return False
        d, used = {}, {}
        for i in range(len(pattern)):
            if pattern[i] not in d:
                if tokens[i] in used:
                    return False
                else:
                    d[pattern[i]] = tokens[i]
                    used[tokens[i]] = True
            elif d[pattern[i]] != tokens[i]:
                return False
        return True