Leetcode（205）——同构字符串

原创已于 2022-05-16 16:38:06 修改 · 615 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法

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

Leetcode 专栏收录该内容

77 篇文章

订阅专栏

本文解析LeetCode 205题——同构字符串，探讨了三种方法：双哈希表维护映射关系、单一哈希表简化处理及利用字符首次出现位置判断。通过实例演示并分析了每种方法的时间和空间复杂度。

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