LeetCode —— 890. 查找和替换模式 [Medium] [Java] 剑走偏锋，脑洞大开

题目：
你有一个单词列表 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 映射到同一个字母。

提示：

• 1 <= words.length <= 50
• 1 <= pattern.length = words[i].length <= 20

要点：
本题的要点在于 words 与 pattern 中的字母间的一一映射。

题解：

• 双映射表
  来自力扣 (LeetCode)的题解

我们可以用两个映射表(map)存储字母到字母的映射关系，第一个映射表保证一个字母不会映射到两个字母，第二个映射表保证不会有两个字母映射到同一个字母。例如 word 为 a，pattern 为 x，那么第一个映射表存储 a -> x，第二个映射表存储 x -> a。

这也是我看到这个题目的第一反应，但是总觉得会浪费不少空间。

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);
            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;
    }
}

成绩

• 单映射表
  来自力扣 (LeetCode)的题解

我们可以删去方法一中的第二个映射表，改成在添加完所有映射关系后，遍历第一个映射表并使用一个数组记录每个值出现的次数。如果某个值出现了超过一次，就说明有两个字母映射到同一个字母，否则映射就是合法的。

与双映射表相比可以节约一些空间，性能差距看不出来。

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;
    }
}

成绩

• 剑走偏锋

在看完映射表的处理方法之后，发现并不能做到最快速度，我便想去结果分析的执行用时分布图看看那超过100%的方法是啥样，果然，发现了完全不一样的东西。

通过 string 的 indexOf() 方法来查找映射之间最开始的位置，若两者间是一对一的映射时，返回的值是相等的，一旦有一对多的情况发生时便会有不等的值返回。

这思路，我只能说绝了！不仅快，而且不需要额外建表，节省空间。
(由于是LeeCode给出的范例，并没有给出提交人，我只能直接贴代码)

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;
    }
    
    private boolean match(String word, String pattern) {
        for (int i = 0; i < word.length(); i++) {
            char wc = word.charAt(i);
            char pc = pattern.charAt(i);
            if (word.indexOf(wc) != pattern.indexOf(pc)) {
                return false;
            }
        }
        return true;
    }
}

成绩

这成绩正是这思路优秀的一个证明！！！