LeetCode第 47 场双周赛（前3道题——python）
相关链接可点击：
5680. 找到最近的有相同 X 或 Y 坐标的点
5681. 判断一个数字是否可以表示成三的幂的和
1781. 所有子字符串美丽值之和
目录
5680_找到最近的有相同X或Y坐标的点
一、题目
二、示例
三、思路
四、代码
5681_判断一个数字是否可以成三的幂的和
一、题目
二、示例
三、思路
四、代码
1781_所有子字符串美丽值之和
一、题目
二、示例
三、思路
四、代码
5680_找到最近的有相同X或Y坐标的点
一、题目
给你两个整数 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
三、思路
题意：
有效点：一个点与你所在的位置有相同的 x 坐标或者相同的 y 坐标时，我们称这个点是 有效的 ；
曼哈顿距离：两个点 (x1, y1) 和 (x2, y2) 之间的 曼哈顿距离 为 abs(x1 - x2) + abs(y1 - y2)；
返回：最近的 有效 点的下标（下标从 0 开始），如果有多个最近的有效点，请返回下标 最小 的一个。否则，返回 -1.
因此，思路为：
- 求出有效点
- 求出每个有效点与当前位置（即题目中所给出的（x, y）的曼哈顿距离
- 返回曼哈顿距离最小的点的下标
四、代码
class Solution:
def nearestValidPoint(self, x: int, y: int, points) -> int:
import sys
"""
:param x: int
:param y: int
:param points: List[List[int]]
:return: int
"""
min_dist = sys.maxsize # 最小曼哈顿距离
ans = sys.maxsize
for index in range(len(points)):
if points[index][0] == x or points[index][1] == y:
dist = abs(points[index][1] - y) + abs(points[index][0] - x)
if dist < min_dist:
min_dist = dist
ans = index
return -1 if ans == sys.maxsize else ans
if __name__ == '__main__':
x = 3
y = 4
points = [[1, 2], [3, 1], [2, 4], [2, 3], [4, 4]]
# x = 3
# y = 4
# points = [[2, 3]]
# x = 5
# y = 1
# points = [[1, 1], [6, 2], [1, 5], [3, 1]]
s = Solution()
ans = s.nearestValidPoint(x, y, points)
print(ans)5681_判断一个数字是否可以成三的幂的和
一、题目
给你一个整数 n ，如果你可以将 n 表示成若干个不同的三的幂之和，请你返回 true ，否则请返回 false 。
对于一个整数 y ，如果存在整数 x 满足 
，我们称这个整数 y 是三的幂。
二、示例
示例 1：
输入：n = 12
输出：true
解释：
示例 2：
输入：n = 91
输出：true
解释：
示例 3：
输入：n = 21
输出：false
提示：
三、思路
题意：
对于一个整数 n，如果其可以由 多项式 
，其中，
为 0 或 1。
若满足，则返回 True， 否则，返回 False。
思路：
因为题中给出 
，因此 指数幂 最大不超过14。
因此，数组 martix 长度为15，初始化为：[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]，下标表示指数幂。
例如：整数12
因此令 martix[1] = 1, martix[2] = 1，即转换成三进制。
若转换后的数组 martix 中的数字只有0 和 1，返回True，否则，返回 False.
四、代码
import math
class Solution:
def checkPowersOfThree1(self, n: int) -> bool:
martix = [0 for _ in range(15)]
while n != 0:
x = int(math.log(n, 3)) # 指数
martix[x] += 1
n -= pow(3, x)
return max(martix) <= 1
if __name__ == '__main__':
# n = 12
# n = 91
n = 21
s = Solution()
ans = s.checkPowersOfThree(n)
print(ans)1781_所有子字符串美丽值之和
一、题目
一个字符串的 美丽值 定义为：出现频率最高字符与出现频率最低字符的出现次数之差。
比方说，"abaacc" 的美丽值为 3 - 1 = 2 。
给你一个字符串 s ，请你返回它所有子字符串的 美丽值 之和。
二、示例
示例 1：
输入：s = "aabcb"
输出：5
解释：美丽值不为零的字符串包括 ["aab","aabc","aabcb","abcb","bcb"] ，每一个字符串的美丽值都为 1 。
示例 2：
输入：s = "aabcbaa"
输出：17
提示：
- 1 <= s.length <= 500
- s 只包含小写英文字母。
三、思路
题意：
美丽值：出现频率最高字符与出现频率最低字符的出现次数之差。
返回：该字符串中的所有子字符串的美丽值之和。
思路：
- 求出当前字符串的所有子字符串
- 求出每个子字符串的美丽值
- 返回所有美丽值之和
在这里运用了一个小技巧，如果单纯的暴力的去求每个子字符串的美丽值很容易超时。
例如：字符串 “aabcb”
每一次只需在上一次的基础上添加新的字符即可。
四、代码
class Solution:
# 返回每个子字符串的美丽值
def single_beauty_num(self, left, right):
if left != right:
if self.s[right] not in self.martix:
self.martix[self.s[right]] = 1
else:
self.martix[self.s[right]] += 1
self.maxnum = max(self.martix.values())
self.minnum = min(self.martix.values())
# print(self.maxnum, self.minnum)
return self.maxnum - self.minnum
def beautySum(self, s: str) -> int:
ans = 0 # 美丽值总和
self.s = s
for i in range(len(self.s)):
self.martix = dict() # dict记录子字符串各个字符出现的次数
self.martix[self.s[i]] = 1
for j in range(1, len(self.s) - i + 1):
ans += self.single_beauty_num(i, i + j - 1)
return ans
if __name__ == '__main__':
s = "aabcb"
obj = Solution()
ans = obj.beautySum(s)
print(ans)