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

 gpt提供的思路：保证一个字符只有唯一映射

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

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

        match_dict_s = dict()

        # 遍历 s 和 t，同时构建映射关系并检查是否存在冲突
        for char_s, char_t in zip(s, t):
            if char_s not in match_dict_s:
                # 如果 char_s 没有映射，则添加映射关系
                match_dict_s[char_s] = char_t
            else:
                # 如果 char_s 已经有映射关系，则检查是否与当前映射一致
                if match_dict_s[char_s] != char_t:
                    return False

        # 检查 s 到 t 的映射关系是否能够唯一确定t   看看t里面有没有重复字符
        return len(set(match_dict_s.values())) == len(match_dict_s)
       

根据gpt改进的新思路：

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

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

        match_dict_s = dict()  # 用于存储 s 到 t 的映射关系的字典
        match_dict_t = dict()  # 用于存储 t 到 s 的映射关系的字典

        # 构建 s 到 t 的映射关系，并检查是否存在冲突
        for i in range(s_len):
            if s[i] not in match_dict_s:
                # 如果 s[i] 没有映射，则添加映射关系
                match_dict_s[s[i]] = t[i]
            else:
                # 如果 s[i] 已经有映射关系，则检查是否与当前映射一致
                if match_dict_s[s[i]] != t[i]:
                    return False

        # 构建 t 到 s 的映射关系，并检查是否存在冲突
        for i in range(t_len):
            if t[i] not in match_dict_t:
                # 如果 t[i] 没有映射，则添加映射关系
                match_dict_t[t[i]] = s[i]
            else:
                # 如果 t[i] 已经有映射关系，则检查是否与当前映射一致
                if match_dict_t[t[i]] != s[i]:
                    return False

        # 如果上述两个映射关系都没有冲突，返回 True，表示字符串是同构的
        return True