Day50 单词规律

给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

class Solution {
    public boolean wordPattern(String pattern, String s) {
        // 将字符串s按照空格拆分成单词数组
        String[] words = s.split(" ");
        // 如果模式的长度和单词数组的长度不相等，直接返回false
        if (pattern.length() != words.length) {
            return false;
        }
        // 创建两个哈希映射
        Map<Character, String> patternToWord = new HashMap<>();
        Map<String, Character> wordToPattern = new HashMap<>();
        // 遍历模式和单词数组
        for (int i = 0; i < pattern.length(); i++) {
            char patternChar = pattern.charAt(i);
            String word = words[i];
            // 如果模式字符没有对应的的单词，或者单词没有对应的模式字符，则说明不符合要求，返回false
            if (patternToWord.containsKey(patternChar) && !patternToWord.get(patternChar).equals(word)) {
                return false;
            }
            if (wordToPattern.containsKey(word) && wordToPattern.get(word) != patternChar) {
                return false;
            }
            // 设置双向映射
            patternToWord.put(patternChar, word);
            wordToPattern.put(word, patternChar);
        }
        // 如果没有冲突，返回true
        return true;
    }
}

时间复杂度是 O(n)，其中 n 是字符串 s 中单词的数量，或者是模式 pattern 的长度。因为我们只遍历了一次字符串和模式。

空间复杂度是 O(n)，因为我们使用了两个哈希映射来存储字符和单词的映射关系。

给定两个字符串 s 和 t ，判断它们是否是同构的。
如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

class Solution {
    public boolean isIsomorphic(String s, String t) {
        Map<Character, Character> set1 = new HashMap<>();
        Map<Character, Character> set2 = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char x = s.charAt(i), y = t.charAt(i);
            if ((set1.containsKey(x) && set1.get(x) != y)) {
                return false;
            }
            if (set2.containsKey(y) && set2.get(y) != x) {
                return false;
            }
            set1.put(x, y);
            set2.put(y, x);
        }
        return true;
    }
}

s=“egg”，t=“add”：

e→a，g→d，双向映射一致，返回true。

s=“foo”，t=“bar”：

第二个o尝试映射到r，但已映射到a，返回false。

通过维护双向映射，确保每个字符替换严格一一对应，从而高效判断同构关系。

时间复杂度O(n)
空间复杂度O(n)