1, 题目

给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

示例 1:

  1. 输入: s = "egg", t = "add"
  2. 输出: true

示例 2:

  1. 输入: s = "foo", t = "bar"
  2. 输出: false

示例 3:

  1. 输入: s = "paper", t = "title"
  2. 输出: true

说明:
你可以假设 s 和 t 具有相同的长度。

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

2, 算法

  1. object Solution {
  2.     def isIsomorphic(s: String, t: String): Boolean = {
  3.         if (s.length != t.length) {
  4.             return false
  5.         }
  6.         val z1 = s.zip(t)
  7.         val m1 = scala.collection.mutable.Map[Char, Char]()
  8.         z1.foreach {
  9.             case (k, v) => {
  10.                 if (m1.contains(k)) {
  11.                     if (m1(k) != v) {
  12.                         return false
  13.                     }
  14.                 } else {
  15.                     m1(k) = v
  16.                 }
  17.             }
  18.         }
  19.         val z2 = t.zip(s)
  20.         val m2 = scala.collection.mutable.Map[Char, Char]()
  21.         z2.foreach {
  22.             case (k, v) => {
  23.                 if (m2.contains(k)) {
  24.                     if (m2(k) != v) {
  25.                         return false
  26.                     }
  27.                 } else {
  28.                     m2(k) = v
  29.                 }
  30.             }
  31.         }
  32.         true
  33.     }
  34. }
  1. class Solution:
  2.     def isIsomorphic(self, s: str, t: str) -> bool:
  3.         if len(s) != len(t):
  4.             return False
  5.         z1 = zip(s, t)
  6.         m1 = {}
  7.         for k, v in z1:
  8.             if k in m1:
  9.                 if v != m1[k]:
  10.                     return False
  11.             else:
  12.                 m1[k] = v
  13.         z2 = zip(t, s)
  14.         m2 = {}
  15.         for k, v in z2:
  16.             if k in m2:
  17.                 if v != m2[k]:
  18.                     return False
  19.             else:
  20.                 m2[k] = v
  21.         return True