leetcode双周赛-47

5680. 找到最近的有相同 X 或 Y 坐标的点

AC

题目

给你两个整数 x 和 y ，表示你在一个笛卡尔坐标系下的 (x, y) 处。同时，在同一个坐标系下给你一个数组 points ，其中 points[i] = [ai, bi] 表示在 (ai, bi) 处有一个点。当一个点与你所在的位置有相同的 x 坐标或者相同的 y 坐标时，我们称这个点是 有效的 。

请返回距离你当前位置 曼哈顿距离 最近的 有效 点的下标（下标从 0 开始）。如果有多个最近的有效点，请返回下标 最小 的一个。如果没有有效点，请返回 -1 。

两个点 (x1, y1) 和 (x2, y2) 之间的 曼哈顿距离 为 abs(x1 - x2) + abs(y1 - y2) 。

示例 1：

输入：x = 3, y = 4, points = [[1,2],[3,1],[2,4],[2,3],[4,4]]
输出：2
解释：所有点中，[3,1]，[2,4] 和 [4,4] 是有效点。有效点中，[2,4] 和 [4,4] 距离你当前位置的曼哈顿距离最小，都为 1 。[2,4] 的下标最小，所以返回 2 。

示例 2：

输入：x = 3, y = 4, points = [[3,4]]
输出：0
提示：答案可以与你当前所在位置坐标相同。

示例 3：

输入：x = 3, y = 4, points = [[2,3]]
输出：-1
解释：没有有效点。

提示：

1 <= points.length <= 10^4
points[i].length == 2
1 <= x, y, ai, bi <= 10^4

解题思路

从前向后遍历，当后面的距离严格小于当前距离时更新

代码

class Solution:
    def nearestValidPoint(self, x: int, y: int, points: List[List[int]]) -> int:
        ans = -1
        distance = 100000
        for index, each_point in enumerate(points):
            if x == each_point[0] or y == each_point[1]:
                man_dis = abs(x - each_point[0]) + abs(y - each_point[1])
                if man_dis < distance:
                    ans = index
                    distance = man_dis
        return ans

5681. 判断一个数字是否可以表示成三的幂的和

AC

题目

给你一个整数 n ，如果你可以将 n 表示成若干个不同的三的幂之和，请你返回 true ，否则请返回 false 。

对于一个整数 y ，如果存在整数 x 满足 y == 3^x ，我们称这个整数 y 是三的幂。

示例 1：

输入：n = 12
输出：true
解释：12 = 3^1 + 3^2

示例 2：

输入：n = 91
输出：true
解释：91 = 3^0 + 3^2 + 3^4

示例 3：

输入：n = 21
输出：false

提示：

1 <= n <= 10^7

解题思路

写一个3的幂表，然后从大往小遍历，对n减去能减的数字，减完之后如果n还不是0，则说明无法表示为3的幂相加

代码

class Solution:
    def checkPowersOfThree(self, n: int) -> bool:
        d = {}
        for index in range(50):
            pow3 = pow(3, index)
            d[index] = pow3
            if pow3 > n:
                break
        for i in range(index, -1, -1):
            if d[i] <= n:
                n -= d[i]
        return n == 0

5682. 所有子字符串美丽值之和

AC

题目

一个字符串的 美丽值 定义为：出现频率最高字符与出现频率最低字符的出现次数之差。

比方说，“abaacc” 的美丽值为 3 - 1 = 2 。
给你一个字符串 s ，请你返回它所有子字符串的 美丽值 之和。

示例 1：

输入：s = "aabcb"
输出：5
解释：美丽值不为零的字符串包括 ["aab","aabc","aabcb","abcb","bcb"] ，每一个字符串的美丽值都为 1 。

示例 2：

输入：s = "aabcbaa"
输出：17

提示：

1 <= s.length <= 500
s 只包含小写英文字母。

解题思路

看长度觉得可以暴力的，结果居然T了。。。
求出所有子字符串，然后对所有子字符串求美丽值再相加即可。求子字符串的时间复杂度是$o(n^2)$

不用Counter类，自己写个字典，在枚举子字符串的同时计算美丽值即可

代码

Counter类

class Solution:
    def beautySum(self, s: str) -> int:
        from collections import Counter
        def beauty_value(s: str) -> int:
            s_cnter = Counter(s)
            return max(s_cnter.values()) - min(s_cnter.values())
        # generate all substrings
        substrings = []
        s_len = len(s)
        for i in range(s_len):
            for j in range(i + 1, s_len + 1):
                substrings.append(s[i:j])
        return sum(map(beauty_value, substrings))

字典写法

class Solution:
    def beautySum(self, s: str) -> int:
        ans = 0
        s_len = len(s)
        for i in range(s_len):
            s_cnt = {}
            for j in range(i, s_len):
                s_cnt[s[j]] = s_cnt.get(s[j], 0) + 1
                ans += max(s_cnt.values()) - min(s_cnt.values())
        return ans

5683. 统计点对的数目

TLE

题目

给你一个无向图，无向图由整数 n ，表示图中节点的数目，和 edges 组成，其中 edges[i] = [ui, vi] 表示 ui 和 vi 之间有一条无向边。同时给你一个代表查询的整数数组 queries 。

第 j 个查询的答案是满足如下条件的点对 (a, b) 的数目：

a < b
cnt 是与 a 或者 b 相连的边的数目，且 cnt 严格大于 queries[j] 。

请你返回一个数组 answers ，其中 answers.length == queries.length 且 answers[j] 是第 j 个查询的答案。

请注意，图中可能会有 重复边 。

示例 1：

输入：n = 4, edges = [[1,2],[2,4],[1,3],[2,3],[2,1]], queries = [2,3]
输出：[6,5]
解释：每个点对中，与至少一个点相连的边的数目如上图所示。

示例 2：

输入：n = 5, edges = [[1,5],[1,5],[3,4],[2,5],[1,3],[5,1],[2,3],[2,5]], queries = [1,2,3,4,5]
输出：[10,10,9,8,6]

提示：

2 <= n <= 2 * 10^4
1 <= edges.length <= 10^5
1 <= ui, vi <= n
ui != vi
1 <= queries.length <= 20
0 <= queries[j] < edges.length

解题思路

先计算出来如图的表，然后遍历表找符合query要求的个数

计算如图的表：
点对的边 = 点a的边 + 点b的边 - (a,b)之间的边
遍历点对，时间复杂度是$o(n^2)$

得到表后，对第二列做一个统计次数的字典，然后可以用前缀和求出一个字典。这个字典的key和value表示“与点对中至少一个点相连的边的数目”大于key的个数为value，然后query直接查询即可

代码

class Solution:
    def countPairs(self, n: int, edges: List[List[int]], queries: List[int]) -> List[int]:
        node_degree = {node: 0 for node in range(1, n + 1)}
        pair_degree = {}
        for each_edge in edges:
            node_a, node_b = min(each_edge), max(each_edge)
            node_degree[node_a] += 1
            node_degree[node_b] += 1
            pair_degree[(node_a, node_b)] = pair_degree.get((node_a, node_b), 0) + 1
        degree_cnt = {}
        for i in range(1, n):
            for j in range(i + 1, n + 1):
                new_degree = node_degree[i] + node_degree[j] - pair_degree.get((i, j), 0)
                degree_cnt[new_degree] = degree_cnt.get(new_degree, 0) + 1
        # presum
        ans = []
        max_cnt = max(max(degree_cnt), len(edges))
        d = {max_cnt: 0}
        for i in range(max_cnt - 1, -1, -1):
            d[i] = d[i + 1] + degree_cnt.get(i + 1, 0)
        return [d[q] for q in queries]