算法千题案例⚡️每日LeetCode打卡⚡️——65.单词规律

Posted 2021-11-24 呆呆敲代码的小Y

• • • • 📢前言
  • 🌲原题样例：二叉树的所有路径
  • • 🌻C#方法：递归
    • 🌻Java 方法：哈希表
  • 💬总结

---

📢前言

🚀 算法题 🚀

• 🌲 每天打卡一道算法题，既是一个学习过程，又是一个分享的过程😜
• 🌲 提示：本专栏解题 编程语言一律使用 C# 和 Java 两种进行解题
• 🌲 要保持一个每天都在学习的状态，让我们一起努力成为算法大神吧🧐！
• 🌲 今天是力扣算法题持续打卡第65天🎈！

🚀 算法题 🚀

---

🌲原题样例：二叉树的所有路径

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", str = "dog cat cat dog"
输出: true

示例2:

输入:pattern = "abba", str = "dog cat cat fish"
输出: false

示例 3:

输入: pattern = "aaaa", str = "dog cat cat dog"
输出: false

示例 4:

输入: pattern = "abba", str = "dog dog dog dog"
输出: false

---

🌻C#方法：递归

将patter的每个字母和S的每个单词分别存在俩个字典内互相对应，每次枚举的时候都比较是否相等，
如果不相等就返回false，全部通过就返回true

代码：

public class Solution
{
    public bool WordPattern(string pattern, string s)
    {
        Dictionary<char, string> dic = new Dictionary<char, string>();
        Dictionary<string, char> dic1 = new Dictionary<string, char>();
        var newS = s.Split(' ');//分割的S单词
        if(pattern.Length != newS.Length) return false;//检测长度，长度不等直接返回false

        for(int i = 0; i < pattern.Length; i++)
        {
            if(dic.ContainsKey(pattern[i]) || dic1.ContainsKey(newS[i]))//只要有一个字典含有键就进入判断
            {
                if (!dic.ContainsKey(pattern[i])) return false;
                if (!dic1.ContainsKey(newS[i])) return false;//如果有一个字典有Key另一个没有Key，一定不能通过
                if(dic[pattern[i]] != newS[i] || dic1[newS[i]] != pattern[i])//俩个都有Key，开始比较Value是否相等
                {
                    return false;
                }
            }
            else
            {
                if (!dic.ContainsKey(pattern[i]))//建立映射
                {
                    dic.Add(pattern[i], newS[i]);
                }
                if (!dic1.ContainsKey(newS[i]))//建立映射
                {
                    dic1.Add(newS[i], pattern[i]);
                }
            }
        }
        return true;
    }
}

执行结果

通过
执行用时：88 ms，在所有 Java  提交中击败了22.50%的用户
内存消耗：36.4 MB，在所有 Java 提交中击败了12.50%的用户

---

🌻Java 方法：哈希表

思路解析

• 在本题中，我们需要判断字符与字符串之间是否恰好一一对应。即任意一个字符都对应着唯一的字符串，任意一个字符串也只被唯一的一个字符对应。在集合论中，这种关系被称为「双射」。

• 想要解决本题，我们可以利用哈希表记录每一个字符对应的字符串，以及每一个字符串对应的字符。然后我们枚举每一对字符与字符串的配对过程，不断更新哈希表，如果发生了冲突，则说明给定的输入不满足双射关系。

• 在实际代码中，我们枚举pattern 中的每一个字符，利用双指针来均摊线性地找到该字符在str 中对应的字符串。每次确定一个字符与字符串的组合，我们就检查是否出现冲突，最后我们再检查两字符串是否比较完毕即可。

代码：

class Solution {
    public boolean wordPattern(String pattern, String str) {
        Map<String, Character> str2ch = new HashMap<String, Character>();
        Map<Character, String> ch2str = new HashMap<Character, String>();
        int m = str.length();
        int i = 0;
        for (int p = 0; p < pattern.length(); ++p) {
            char ch = pattern.charAt(p);
            if (i >= m) {
                return false;
            }
            int j = i;
            while (j < m && str.charAt(j) != ' ') {
                j++;
            }
            String tmp = str.substring(i, j);
            if (str2ch.containsKey(tmp) && str2ch.get(tmp) != ch) {
                return false;
            }
            if (ch2str.containsKey(ch) && !tmp.equals(ch2str.get(ch))) {
                return false;
            }
            str2ch.put(tmp, ch);
            ch2str.put(ch, tmp);
            i = j + 1;
        }
        return i >= m;
    }
}

执行结果

通过
执行用时：1 ms，在所有 Java  提交中击败了90.26%的用户
内存消耗：36.3 MB，在所有 Java 提交中击败了51.35%的用户

复杂度分析

时间复杂度：O( n+m )
空间复杂度：O( n+m ) ，其中 Σ 是字符串的字符集。哈希表存储字符的空间取决于字符串的字符集大小，最坏情况下每个字符均不相同，需要O(∣Σ∣) 的空间。

---

💬总结

• 今天是力扣算法题打卡的第六十五天！
• 文章采用 C#和 Java 两种编程语言进行解题
• 一些方法也是参考力扣大神写的，也是边学习边分享，再次感谢算法大佬们
• 那今天的算法题分享到此结束啦，明天再见！