[LeetCode] 205. Isomorphic Strings

Given two strings s and t, determine if they are isomorphic.

Two strings s and t are isomorphic if the characters in s can be replaced to get t.

All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character, but a character may map to itself.

Example 1:

Input: s = "egg", t = "add"
Output: true

Example 2:

Input: s = "foo", t = "bar"
Output: false

Example 3:

Input: s = "paper", t = "title"
Output: true

Constraints:

• 1 <= s.length <= 5 * 104
• t.length == s.length
• s and t consist of any valid ascii character.

同构字符串。

给定两个字符串 s 和 t ，判断它们是否是同构的。

如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。

每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/isomorphic-strings
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

给两个字符串 s 和 t，判断他们是否互为同位字符串。同位字符串的定义是比如在 s 中有个字母“e”，在 t 中对应位置上有一个字母“g”，那么 s 中剩下所有的 e 应该在t对应位置上对应的是字母 g。

两种实现方式，思路本质上是一样的。一个是用 hashmap 做，一个是用 counting sort 的办法做。

遍历两个字符串，用 hashmap 存同一个下标位置上 s 和 t 字母的对应关系。如果发觉有对不上的，就 return false；遍历完的话就 return true。比如在某个下标处 s 的字符是 c1，t 的字符是 c2，我们只能得到 c1 -> c2 的单向关系，我们是不能同时得到 c2 -> c1 这个结论的。所以这道题在写代码的时候用数组更方便。

时间O(n)

空间O(n)

JavaScript实现

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isIsomorphic = function(s, t) {
    if (s.length !== t.length) {
        return false;
    }
    if (s === t) {
        return true;
    }
    const obj1 = {};
    const obj2 = {};
    for (let i = 0; i < s.length; i++) {
        const letter = s[i];
        const tLetter = t[i];
        if (!obj2[tLetter]) {
            obj2[tLetter] = letter;
        }
        if (!obj1[letter]) {
            obj1[letter] = tLetter;
        }
        if (obj1[letter] !== tLetter || obj2[tLetter] !== letter) {
            return false;
        }
    }
    return true;
};

 

Java实现

class Solution {
    public boolean isIsomorphic(String s, String t) {
        // corner case
        if (s == null || t == null) {
            return true;
        }

        // normal case
        HashMap<Character, Character> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            char a = s.charAt(i);
            char b = t.charAt(i);
            if (map.containsKey(a)) {
                if (map.get(a).equals(b)) {
                    continue;
                } else {
                    return false;
                }
            } else {
                if (!map.containsValue(b)) {
                    map.put(a, b);
                } else {
                    return false;
                }
            }
        }
        return true;
    }
}

 

counting sort的思路跟hashmap很像，也是遍历字符串。用以上的example 1举例好了。当s遇到第一个字母e的时候，记录letters["e"] = "a"，这样就记下了字母e和字母a的对应关系。如果发现有对不上的，就return false，直到遍历结束。

时间O(n)

空间O(1)

JavaScript实现

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isIsomorphic = function(s, t) {
    if (s === t) {
        return true;
    }
    var len = s.length;
    var i = 1;
    if (len !== t.length) {
        return false;
    }
    while (i < len) {
        if (s.indexOf(s[i]) === t.indexOf(t[i])) {
            i++;
        } else {
            break;
        }
    }
    return i === len;
};

 

Java实现

class Solution {
    public boolean isIsomorphic(String s, String t) {
        int[] sChars = new int[256];
        int[] tChars = new int[256];
        for (int i = 0; i < s.length(); i++) {
            char c1 = s.charAt(i);
            char c2 = t.charAt(i);
            if (sChars[c1] != tChars[c2]) {
                return false;
            } else {
                sChars[c1] = tChars[c2] = c2;
            }
        }
        return true;
    }
}

 

相关题目

205. Isomorphic Strings

890. Find and Replace Pattern

LeetCode 题目总结