LeetCode笔记：Weekly Contest 344

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

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

1. 题目一

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

• 2670. Find the Distinct Difference Array

1. 解题思路

这一题只需要分别从左到右以及从右到左count一下distinct的元素个数即可，然后将两者相减即是我们所需的答案。

2. 代码实现

给出python代码实现如下：

class Solution:
    def distinctDifferenceArray(self, nums: List[int]) -> List[int]:
        pre, post = [], []
        elems = set()
        for i in nums:
            elems.add(i)
            pre.append(len(elems))
        elems = set()
        for i in nums[::-1]:
            post.insert(0, len(elems))
            elems.add(i)
        return [x-y for x, y in zip(pre, post)]

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

2. 题目二

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

• 2671. Frequency Tracker

1. 解题思路

这一题的思路同样比较直接，我们只需要记录一下当前各个元素的个数，然后用一个有序数组来记录一下当前存在的frequency即可。

2. 代码实现

给出python代码实现如下：

class FrequencyTracker:

    def __init__(self):
        self.cnt = defaultdict(int)
        self.freq = []

    def add(self, number: int) -> None:
        if self.cnt[number] != 0:
            self.freq.pop(bisect.bisect_left(self.freq, self.cnt[number]))
        self.cnt[number] += 1
        bisect.insort(self.freq, self.cnt[number])
        return

    def deleteOne(self, number: int) -> None:
        if self.cnt[number] == 0:
            return 
        self.freq.pop(bisect.bisect_left(self.freq, self.cnt[number]))
        self.cnt[number] -= 1
        if self.cnt[number] != 0:
            bisect.insort(self.freq, self.cnt[number])
        return

    def hasFrequency(self, frequency: int) -> bool:
        idx = bisect.bisect_left(self.freq, frequency)
        return idx < len(self.freq) and self.freq[idx] == frequency

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

3. 题目三

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

• 2672. Number of Adjacent Elements With the Same Color

1. 解题思路

这一题思路其实也比较单纯，因此我们每次改动一个位置，只会影响其前后两个位置的情形，因此，我们只需要对其变动情况进行一下考察即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def colorTheArray(self, n: int, queries: List[List[int]]) -> List[int]:
        colors = [0 for _ in range(n)]
        
        def is_same_color(i, j):
            if i < 0 or i >= n or j < 0 or j >= n:
                return False
            if colors[i] == 0 or colors[j] == 0:
                return False
            return colors[i] == colors[j]
        
        cnt = 0
        res = [0 for _ in queries]
        for i, (idx, color) in enumerate(queries):
            if is_same_color(idx, idx-1):
                cnt -= 1
            if is_same_color(idx, idx+1):
                cnt -= 1
            colors[idx] = color
            if is_same_color(idx, idx-1):
                cnt += 1
            if is_same_color(idx, idx+1):
                cnt += 1
            res[i] = cnt
        return res

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

4. 题目四

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

• 2673. Make Costs of Paths Equal in a Binary Tree

1. 解题思路

这一题我们只需要自下而上做一次遍历即可。

显然，对于每一个节点，其左子树和右子树在调整之后的路径和如果还存在和的差，那么我们就必须在少的那一侧加上他们的差值，确保两条子路径的长度相同，而后这个路径加上当前节点的cost就是整条路径的cost。

我们遍历一下即可得到所需加上的最小的cost。

2. 代码实现

给出python代码实现如下：

class Solution:
    def minIncrements(self, n: int, cost: List[int]) -> int:
        res = 0
        
        def dfs(idx):
            nonlocal res
            if idx >= n:
                return 0
            left = dfs(2*idx+1)
            right = dfs(2*idx+2)
            res += abs(left - right)
            return cost[idx] + max(left, right)
        
        dfs(0)
        return res

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