Leetcode（205）——同构字符串

SmileGuy17

已于 2022-05-16 16:38:06 修改

阅读量498

点赞数

分类专栏： Leetcode 文章标签： leetcode 算法

于 2022-05-16 16:10:54 首次发布

本文链接：https://blog.csdn.net/KCDCY/article/details/124798946

版权

Leetcode 专栏收录该内容

77 篇文章 6 订阅

订阅专栏

Leetcode（205）——同构字符串

题目

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

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

示例 1：

输入：s = “egg”, t = “add”
输出：true

示例 2：

输入：s = “foo”, t = “bar”
输出：false

示例 3：

输入：s = “paper”, t = “title”
输出：true

提示：

$1$ <= s.length <= $5 * 10^4$
t.length == s.length
s 和 t 由任意有效的 ASCII 字符组成

题解

方法一：双哈希表 + 双映射关系

思路

两个字符串同构的特点就是——字符串 s 中的每个字符可以唯一的映射到 t 中的每个字符，同时 t 中的每个字符也可以唯一的映射到 s 中的每个字符 。这也被称为「双射」的关系。
因此，我们维护两张哈希表，第一张哈希表 $\textit{s2t}$ 以 $s$ 中字符为键，映射至 $t$ 的字符为值，第二张哈希表 $\textit{t2s}$ 以 $t$ 中字符为键，映射至 $s$ 的字符为值。从左至右遍历两个字符串的字符，不断更新两张哈希表，如果出现冲突（即当前下标 $\textit{index}$ 对应的字符 $s[\textit{index}]$ 已经存在映射且不为 $t[\textit{index}]$ 或当前下标 $\textit{index}$ 对应的字符 $t[\textit{index}]$ 已经存在映射且不为 $s[\textit{index}]$ ）时说明两个字符串无法构成同构，返回 $\rm false$ 。
如果遍历结束没有出现冲突，则表明两个字符串是同构的，返回 $\rm true$ 即可。

代码实现

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        unordered_map<char, char> s2t;
        unordered_map<char, char> t2s;
        int len = s.length();
        for (int i = 0; i < len; ++i) {
            char x = s[i], y = t[i];
            if ((s2t.count(x) && s2t[x] != y) || (t2s.count(y) && t2s[y] != x)) {
                return false;
            }
            s2t[x] = y;
            t2s[y] = x;
        }
        return true;
    }
};

复杂度分析

时间复杂度： $O (n)$ ，其中 $n$ 为字符串的长度。我们只需同时遍历一遍字符串 $s$ 和 $t$ 即可。
空间复杂度： $O (∣ Σ ∣)$ ，其中 $\Sigma$ 是字符串的字符集。哈希表存储字符的空间取决于字符串的字符集大小，最坏情况下每个字符均不相同，需要 $O(|\Sigma|)$ 的空间。

方法二：单一哈希表 + 单一映射关系

思路

大体思路与方法一类似，只是这次我们只使用一个哈希表。

因为单一字符最多只能对应一个字符，且多个字符不能同时对应一个字符，所以构建新对应映射关系时，哈希表中最多已存在 12 个映射关系（即 26/2 -1 = 12），所以如果不采用双哈希表的话，只需要遍历一个哈希表中的元素，并查看关键字和值是否与新映射关系冲突即可，冲突则返回 false，否则加入哈希表中，因为哈希表的大小很小，所以可以省略不计。

代码实现

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        unordered_map<char, char> relation;
        if(s.size() != t.size())
            return false;
        int l = s.size();
        for(int n = 0; n < l; n++){
            if(relation.count(s[n]) == 0){      // 是否存在其对应的映射关系
                for(auto& it: relation)			// 遍历哈希表
                    if(it.second == t[n])       // 是否与其它字符映射到同一个字符上
                        return false;
                relation.emplace(s[n], t[n]);   // 没有冲突，创建新的映射关系
            }else if(relation[s[n]] != t[n])    // 是否符合已存在的映射关系
                return false;
        }
        return true;
    }
};

复杂度分析

方法三：索引

思路

这次将问题重定义一下：记录两个字符串每个位置的字符第一次出现的位置，如果两个字符串中相同位置的字符和它们第一次出现的位置一样，那么这两个字符串同构。举例来说，对于 “paper” 和 “title” ，假设我们现在遍历到第三个字符 “p” 和 “t” ，发现它们第一次出现的位置都在第一个字符，则说明目前位置满足同构。

代码实现

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        vector<int> s_first_index(256, 0), t_first_index(256, 0);   // ASCII 的编码范围
        if(s.length() != t.length())
            return false;
        int l = s.length();
        for(int i = 0; i < l; ++i){
            if(s_first_index[s[i]] != t_first_index[t[i]])
                return false;
            s_first_index[s[i]] = t_first_index[t[i]] = i + 1;
        }
        return true;
    }
};