leetcode890. 查找和替换模式

leetcode890. 查找和替换模式

你有一个单词列表 words 和一个模式 pattern，你想知道 words 中的哪些单词与模式匹配。

如果存在字母的排列 p ，使得将模式中的每个字母 x 替换为 p(x) 之后，我们就得到了所需的单词，那么单词与模式是匹配的。

（回想一下，字母的排列是从字母到字母的双射：每个字母映射到另一个字母，没有两个字母映射到同一个字母。）

返回 words 中与给定模式匹配的单词列表。

你可以按任何顺序返回答案。

示例：

输入：words = [“abc”,“deq”,“mee”,“aqq”,“dkd”,“ccc”], pattern = “abb”
输出：[“mee”,“aqq”]
解释：
“mee” 与模式匹配，因为存在排列 {a -> m, b -> e, …}。
“ccc” 与模式不匹配，因为 {a -> c, b -> c, …} 不是排列。
因为 a 和 b 映射到同一个字母。

思路一普通版

：单映射hashmap，从words向pattern映射；如果word当前字母已经映射过字母并且所映射的字母也是pattern中对应的字母，就表明符合规定，不用产生新的映射；如果word当前字母已经映射过字母并且所映射的字母不是pattern中对应的字母，那么就不符合规定；如果pattern中当前位置的字母已经被映射过，因为不能重复映射，所以不符合规定。

代码：

class Solution {
    public List<String> findAndReplacePattern(String[] words, String pattern) {
        List<String> list = new ArrayList<>();
        HashMap<Character, Character> map = new HashMap<>();
        int i;
        for (String word : words) {
            map.clear();
            for (i = 0; i < word.length(); i++) {
                char w=word.charAt(i);
                char p=pattern.charAt(i);
                if (map.containsKey(w) && map.get(w) == p)
                    continue;
                else if (map.containsKey(w) && map.get(w) != p||map.containsValue(p))
                    break;
                map.put(w, p);
            }
            if (i == word.length())
                list.add(word);
        }
        return list;
    }
}

思路一进阶：

先将word中的字母一一映射到pattern中去，然后对map中的value进行第二次的审查，看一看有没有映射过两次的。

代码：

class Solution {
    public List<String> findAndReplacePattern(String[] words, String pattern) {
        List<String> ans = new ArrayList();
        for (String word: words)
            if (match(word, pattern))
                ans.add(word);
        return ans;
    }

    public boolean match(String word, String pattern) {
        Map<Character, Character> M = new HashMap();
        for (int i = 0; i < word.length(); ++i) {
            char w = word.charAt(i);
            char p = pattern.charAt(i);
            if (!M.containsKey(w)) M.put(w, p);
            if (M.get(w) != p) return false;
        }

        boolean[] seen = new boolean[26];
        for (char p: M.values()) {
            if (seen[p - 'a']) return false;
            seen[p - 'a'] = true;
        }
        return true;
    }
}

思路二：

双映射，一个进行正常值的映射，另一个用于检擦是否有重复映射的。

代码：

class Solution {
    public List<String> findAndReplacePattern(String[] words, String pattern) {
        List<String> ans = new ArrayList();
        for (String word: words)
            if (match(word, pattern))
                ans.add(word);
        return ans;
    }

    public boolean match(String word, String pattern) {
        Map<Character, Character> m1 = new HashMap();
        Map<Character, Character> m2 = new HashMap();

        for (int i = 0; i < word.length(); ++i) {
            char w = word.charAt(i);
            char p = pattern.charAt(i);
           //一个是word向pattern映射，一个是从pattern向word映射如果他们对应的值不一样，就代表重复映射
            if (!m1.containsKey(w)) m1.put(w, p);
            if (!m2.containsKey(p)) m2.put(p, w);
            if (m1.get(w) != p || m2.get(p) != w)
                return false;
        }

        return true;
    }
}