力扣刷题记录&整理——（十七）Math&Geometry

---

前言

整理力扣刷题思路。

• 语言：python
• 题库：来自neetcode: link

---

一、预备知识

---

二、解题思路

1.快慢指针

202.happy-number

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
link

class Solution:
    def isHappy(self, n: int) -> bool:
        slow = n
        fast = sum(int(i)**2 for i in str(n))
        while slow!=fast:
            slow = sum(int(i)**2 for i in str(slow))
            fast = sum(int(i)**2 for i in str(fast))
            fast = sum(int(i)**2 for i in str(fast))
        return slow==1

2.遍历

73.set-matrix-zeroes

给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。
link

class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        r,c = set(),set()
        #记录需要置0的行列序号
        for i in range(len(matrix)):
            for j in range(len(matrix[0])):
                if matrix[i][j]==0 and (len(r)<len(matrix) or len(c)<len(matrix[0])):
                    r.add(i)
                    c.add(j)
        for i in r:
            matrix[i] = [0]*len(matrix[0])
        for j in c:
            for i in range(len(matrix)):
                matrix[i][j]=0

54.spiral-matrix

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
link

import numpy as np
class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        ans = []
        #上下左右边界
        t,b,l,r = 0,len(matrix)-1,0,len(matrix[0])-1
        #按顺时针顺序遍历
        while True:
            ans += matrix[t][l:r+1]
            t+=1
            if t>b: break

            for i in range(t,b+1):
                ans.append(matrix[i][r])
            r-=1
            if l>r: break

            ans += matrix[b][l:r+1][::-1]
            b-=1
            if t>b: break

            for i in range(b,t-1,-1):
                ans.append(matrix[i][l])
            l+=1
            if l>r: break
        return ans

48.rotate-image

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
link

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        n = len(matrix)
        tmp = [[0]*n for _ in range(n)]
        for i in range(n):
            for j in range(n): 
                tmp[i][j] = matrix[n-1-j][i]
        matrix[:] = tmp

还有一种很巧妙的方法

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        n = len(matrix)
        for i in range(n//2):
            for j in range((n+1)//2):
                tmp = matrix[i][j]
                matrix[i][j] = matrix[n-1-j][i]
                matrix[n-1-j][i] = matrix[n-1-i][n-1-j]
                matrix[n-1-i][n-1-j] = matrix[j][n-1-i]
                matrix[j][n-1-i] = tmp

3.分治法

50.powx-n

实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，xn ）。
link

class Solution:
    def myPow(self, x: float, n: int) -> float:
        if x==0 or x==1:
            return x
        
        ans = 1
        if n<0:
            x,n = 1/x,-n
        while n:
            if n%2==1:
                ans *= x
            x *= x
            n = n//2
        return ans

参考：link

4.哈希

2013.detect-squares

给你一个在 X-Y 平面上的点构成的数据流。设计一个满足下述要求的算法：

添加 一个在数据流中的新点到某个数据结构中。可以添加 重复 的点，并会视作不同的点进行处理。
给你一个查询点，请你从数据结构中选出三个点，使这三个点和查询点一同构成一个 面积为正 的 轴对齐正方形 ，统计 满足该要求的方案数目。
轴对齐正方形 是一个正方形，除四条边长度相同外，还满足每条边都与 x-轴 或 y-轴 平行或垂直。

实现 DetectSquares 类：

DetectSquares() 使用空数据结构初始化对象
void add(int[] point) 向数据结构添加一个新的点 point = [x, y]
int count(int[] point) 统计按上述方式与点 point = [x, y] 共同构造 轴对齐正方形 的方案数。
link

class DetectSquares:

    def __init__(self):
        self.cnts = defaultdict(lambda:defaultdict(int))

    def add(self, point: List[int]) -> None:
        self.cnts[point[1]][point[0]] += 1

    def count(self, point: List[int]) -> int:
        a,b = point
        cnt = 0
        for x, v in self.cnts[b].items():
            diff = x - a
            if diff != 0:
                c1 = self.cnts[b+diff][x] * self.cnts[b+diff][a]
                c2 = self.cnts[b-diff][x] * self.cnts[b-diff][a]
                cnt += v * (c1 + c2)
        return cnt


# Your DetectSquares object will be instantiated and called as such:
# obj = DetectSquares()
# obj.add(point)
# param_2 = obj.count(point)

参考：link