leedcode-同构字符串

自己写的：

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        # 使用 match 函数分别检查 s 到 t 和 t 到 s 的映射关系
        res_a = self.match(s, t)
        res_b = self.match(t, s)
        
        # 如果两个方向的映射关系都成立，则说明字符串是同构的
        if res_a and res_b:
            return True
        else:
            return False

    def match(self, s, t):
        s_len = len(s)
        t_len = len(t)
        
        # 如果两个字符串长度不相等，直接返回 False
        if s_len != t_len:
            return False

        match_list = dict()  # 用于存储字符映射关系的字典

        # 遍历字符串 s 中的每个字符
        for i in range(s_len):
            # 如果当前字符不在映射字典中，添加映射关系
            if s[i] not in match_list:
                match_list.update({s[i]: t[i]})

        # 再次遍历字符串 s，检查映射关系是否符合
        for i in range(s_len):
            if match_list[s[i]] != t[i]:
                return False  # 如果映射关系不符合，返回 False

        return True  # 如果所有映射关系都符合，返回 True

一个新想法，检查双向映射关系  若映射关系相等  根据映射关系构建新字符串  再检查字符串是否相等：

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        s_len = len(s)
        t_len = len(t)
        match_dict_s = dict()
        match_dict_t = dict()

        # 检查字符串长度是否相等
        if s_len != t_len:
            return False

        # 构建 s 到 t 的映射关系
        for i in range(s_len):
            if s[i] not in match_dict_s:
                match_dict_s.update({s[i]: t[i]})

        # 构建 t 到 s 的映射关系
        for i in range(t_len):
            if t[i] not in match_dict_t:
                match_dict_t.update({t[i]: s[i]})

        # 构建 t 到 s 的反向映射关系
        match_dict_t_swap = {v: k for k, v in match_dict_t.items()}

        # 检查 s 到 t 和 t 到 s 的映射关系是否相等
        if match_dict_s != match_dict_t_swap:
            return False
        else:
            s_new = ''

            # 构建新的字符串 s_new
            for i in range(s_len):
                s_new = s_new + match_dict_s[s[i]]

            # 检查新构建的字符串是否等于 t
            return s_new == t