LeetCode笔记：Weekly Contest 324

• LeetCode笔记：Weekly Contest 324
  • 1. 题目一
    • 1. 解题思路
    • 2. 代码实现
  • 2. 题目二
    • 1. 解题思路
    • 2. 代码实现
  • 3. 题目三
    • 1. 解题思路
    • 2. 代码实现
  • 4. 题目四
    • 1. 解题思路
    • 2. 代码实现

• 比赛链接：https://leetcode.com/contest/weekly-contest-324/

1. 题目一

给出题目一的试题链接如下：

• 2506. Count Pairs Of Similar Strings

1. 解题思路

这一题思路上就是找到每一个单词对应的字符集合，然后考察每一个字符集合下有多少个单词，然后计算$C_n^2$求和即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def similarPairs(self, words: List[str]) -> int:
        cnt = defaultdict(int)
        for w in words:
            s = [0 for _ in range(26)]
            for ch in w:
                s[ord(ch) - ord('a')] = 1
            cnt[tuple(s)] += 1
        res = sum(i*(i-1) // 2 for i in cnt.values())
        return res

提交代码评测得到：耗时86ms，占用内存14MB。

2. 题目二

给出题目二的试题链接如下：

• 2507. Smallest Value After Replacing With Sum of Prime Factors

1. 解题思路

这一题思路上其实就是按照题意进行迭代就行了，退出条件就是其质因子之和不小于原始的数。

因此，这道题的难点其实也就在于质因子的分解，我们这边的处理比较暴力，就是先计算一下全部的质数，保存到缓存当中，然后用一个for循环找出所有的质数分解即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    @lru_cache(None)
    def get_primes(self):
        s = [0 for _ in range(10**5+1)]
        res = []
        for i in range(2, 10**5+1):
            if s[i] != 0:
                continue
            res.append(i)
            for j in range(i, 10**5+1, i):
                s[j] = 1
        return res
        
    def smallestValue(self, n: int) -> int:
        primes = self.get_primes()
        m = n
        if n in primes:
            return n
        res = 0
        for p in primes:
            if p > n:
                break
            while n % p == 0:
                n = n // p
                res += p
        return self.smallestValue(res) if res < m else res

提交代码评测得到：耗时4153ms，占用内存93.9MB。

3. 题目三

给出题目三的试题链接如下：

• 2508. Add Edges to Make Degrees of All Nodes Even

1. 解题思路

这一题我们的思路还是蛮简单的，就是实现上有点繁琐。

我们首先就是统计一下每一个点的度，要使得能够成立的话，那么必须满足以下几个条件：

1. 如果度为奇数的节点数为0，那么一定可以实现；
2. 如果度为奇数的节点数为2，那么成立的条件当且仅当：
   1. 这两个节点相互之间没有连接，或者
   2. 存在一个额外的节点与这两个节点均不相连；
3. 如果度为奇数的节点数为4，那么成立的条件当且仅当：
   1. 存在一种分割将这4个点分为两组，他们之间相互原本均没有连接

因此，我们一一对其进行一下考察即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def isPossible(self, n: int, edges: List[List[int]]) -> bool:
        deg = defaultdict(set)
        for u, v in edges:
            deg[u].add(v)
            deg[v].add(u)

        odd = set()
        for u in range(1, n+1):
            if len(deg[u]) % 2 == 1:
                odd.add(u)
        if len(odd) == 0:
            return True
        elif len(odd) == 2:
            u, v = list(odd)
            return v not in deg[u] or len(deg[u] | deg[v]) < n
        elif len(odd) == 4:
            return any((b not in deg[a] and c not in deg[d]) for a, b, c, d in permutations(odd))
        else:
            return False

提交代码评测得到：耗时2708ms，占用内存70MB。

4. 题目四

给出题目四的试题链接如下：

• 2509. Cycle Length Queries in a Tree

1. 解题思路

这一题思路其实也极其简单，就是分别从query的两个节点向上遍历，直到找到公共结点之后，这个环也就找到了，然后我们只要看一下这个环的长度即可。

而由于这个二叉树是一个完全二叉树，因此要找寻一个节点的父节点我们只需要将其整除2即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def cycleLengthQueries(self, n: int, queries: List[List[int]]) -> List[int]:
        
        def query(u, v):
            depth = {u:0}
            while u > 1:
                depth[u // 2] = depth[u] + 1
                u = u // 2
            d = 0
            while v >= 1:
                if v in depth:
                    return d + depth[v] + 1
                v = v // 2
                d += 1
            return -1
        
        return [query(u, v) for u, v in queries]

提交代码评测得到：耗时4084ms，占用内存53.7MB。