LeetCode笔记：Weekly Contest 328

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

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

1. 题目一

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

• 2535. Difference Between Element Sum and Digit Sum of an Array

1. 解题思路

这一题翻译一下题目就行了，就是求一下list当中所有数字的和以及把每一个数拆分为digit然后求和比较绝对值的差即可。

2. 代码实现

给出python代码实现如下：

class Solution:
    def differenceOfSum(self, nums: List[int]) -> int:
        s = sum(nums)
        
        def digit(num):
            return sum(int(d) for d in str(num))
        
        t = sum(digit(x) for x in nums)
        return abs(s-t)

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

2. 题目二

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

• 2536. Increment Submatrices by One

1. 解题思路

这一题其实也简单，就是一个二维累积数组的问题。

我们对于每一个query，在边界位置标记好累积变化值，然后对整体的矩阵进行累计求和之后就能够得到最终的matrix上面每一个元素的具体的值了。

2. 代码实现

给出python代码实现如下：

class Solution:
    def rangeAddQueries(self, n: int, queries: List[List[int]]) -> List[List[int]]:
        matrix = [[0 for _ in range(n+1)] for _ in range(n+1)]
        for a, b, c, d in queries:
            matrix[a][b] += 1
            matrix[c+1][b] -= 1
            matrix[a][d+1] -= 1
            matrix[c+1][d+1] += 1
        
        for j in range(n):
            matrix[0][j+1] += matrix[0][j]
        for i in range(1, n):
            matrix[i][0] += matrix[i-1][0]
            for j in range(1, n+1):
                matrix[i][j] = matrix[i][j] + matrix[i-1][j] + matrix[i][j-1] - matrix[i-1][j-1]
        return [line[:-1] for line in matrix[:-1]]

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

3. 题目三

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

• 2537. Count the Number of Good Subarrays

1. 解题思路

这一题我的思路是考察遍历每一个位置作为左边界时，要使得满足good subarray条件，最近的右边界的位置在哪里，此时往后所有的位置都可以满足good subarray的条件，且右边界是单调的，因此我们可以通过一个滑动窗口在$O(N)$的时间复杂度内搞定这道题。

2. 代码实现

给出python代码实现如下：

class Solution:
    def countGood(self, nums: List[int], k: int) -> int:
        n = len(nums)
        i, j, t = 0, 0, 0
        cnt = defaultdict(int)
        res = 0
        while i < n:
            while j < n and t < k:
                t -= cnt[nums[j]] * (cnt[nums[j]] - 1) // 2
                cnt[nums[j]] += 1
                t += cnt[nums[j]] * (cnt[nums[j]] - 1) // 2
                j += 1
            if t >= k:
                res += (n-j+1)
                t -= cnt[nums[i]] * (cnt[nums[i]] - 1) // 2
                cnt[nums[i]] -= 1
                t += cnt[nums[i]] * (cnt[nums[i]] - 1) // 2
                i += 1
            else:
                break
        return res

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

4. 题目四

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

• 2538. Difference Between Maximum and Minimum Price Sum

1. 解题思路

这一题没有想到啥好的思路，就是遍历一下一下每一个点作为root时的答案，然后找出最大值。

而在每一个点作为root的情况下，其最小的路径就是其本身，最大的路径则可以通过一个单向遍历来获得，不过这里没有想到啥特别好的思路，就简单的试了一下暴力地动态规划，结果没有超时，能够通过测试样例，就先这样了……

如果有更好的思路，也欢迎大家分享。

2. 代码实现

给出python代码实现如下：

class Solution:
    def maxOutput(self, n: int, edges: List[List[int]], price: List[int]) -> int:
        if n == 1:
            return 0
        
        graph = defaultdict(list)
        for u, v in edges:
            graph[u].append(v)
            graph[v].append(u)
            
        @lru_cache(None)
        def dfs(u, pre):
            if len(graph[u]) == 1 and pre != -1:
                return price[u]
            else:
                return price[u] + max(dfs(v, u) for v in graph[u] if v != pre)
            
        return max(dfs(u, -1) - price[u] for u in range(n))

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