LeetCode第 47 场双周赛（前3道题——python）_判断一个数字是否可以表示为7的幂的和

相关链接可点击：

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.

因此，思路为：

1. 求出有效点
2. 求出每个有效点与当前位置（即题目中所给出的（x, y）的曼哈顿距离
3. 返回曼哈顿距离最小的点的下标 

四、代码

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 只包含小写英文字母。

三、思路

题意：

美丽值：出现频率最高字符与出现频率最低字符的出现次数之差。

返回：该字符串中的所有子字符串的美丽值之和。

思路：

1. 求出当前字符串的所有子字符串
2. 求出每个子字符串的美丽值
3. 返回所有美丽值之和

在这里运用了一个小技巧，如果单纯的暴力的去求每个子字符串的美丽值很容易超时。

例如：字符串 “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)