leetcode205. 同构字符串 290. 单词规律

205. 同构字符串

法一：单哈希表，我写的原始代码。

优点：逻辑清晰，正确处理了双射关系（containsValue检查了 t 中的字符是否已被映射，防止了多对一）。

潜在瓶颈：containsValue方法在最坏情况下需要遍历整个 HashMap 的值集合，时间复杂度为 O(n)，这使得循环内操作的最坏情况时间复杂度可能接近 O(n²) 。

class Solution {
    public boolean isIsomorphic(String s, String t) {
        HashMap<Character,Character> charMap = new HashMap<>();
        int len = s.length();
        for(int i = 0;i < len;++i){
            if(charMap.containsKey(s.charAt(i))){
                if(charMap.get(s.charAt(i)) != t.charAt(i))  return false;
            }else{
                //containsValue方法在最坏情况下需要遍历整个 HashMap 的值集合，时间复杂度为 O(n)，这使得循环内操作的最坏情况时间复杂度可能接近 O(n²)
                if(charMap.containsValue(t.charAt(i)))  return false;
                charMap.put(s.charAt(i),t.charAt(i));
            }
        }
        return true;
    }
}

法二：双哈希表

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

法三：使用数组进行映射（高效）

class Solution {
    public boolean isIsomorphic(String s, String t) {
        int[] s2t = new int[256]; // 映射 s字符 -> t字符最后一次出现的位置索引
        int[] t2s = new int[256]; // 映射 t字符 -> s字符最后一次出现的位置索引
        for (int i = 0; i < s.length(); i++) {
            char c1 = s.charAt(i);
            char c2 = t.charAt(i);
            // 如果当前字符对上次建立映射的位置索引不同，则说明映射关系不一致
            if (s2t[c1] != t2s[c2]) {
                return false;
            }
            // 记录当前字符对映射的位置索引（i+1以避免与初始值0混淆）
            s2t[c1] = i + 1;
            t2s[c2] = i + 1;
        }
        return true;
    }
}

 

290. 单词规律

法一：两个HashMap。根据205题得到的启发。

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

法二：一个HashMap，一个HashSet。HashSet保存值是否唯一，可以节约很多空间。

class Solution {
    public boolean wordPattern(String pattern, String s) {
        String[] sSplit = s.split(" ");
        int len = pattern.length();        
        if(len != sSplit.length)  return false;
        HashMap<Character,String> c2s = new HashMap<>();
        HashSet<String> sSet = new HashSet<>();
        for(int i = 0;i < len;++i){
            if(c2s.containsKey(pattern.charAt(i))){
                if(!c2s.get(pattern.charAt(i)).equals(sSplit[i]))  return false;
            }else{
                if(sSet.contains(sSplit[i]))  return false;
                c2s.put(pattern.charAt(i),sSplit[i]);
                sSet.add(sSplit[i]);
            }
        }
        return true;
    }
}