leetcode--算法day1

题目：有效的数独
基本思想：
行判断
列判断
九宫格判断即可

方法二：笨方法
对每个数进行行和列和九宫格判断，这里写了对行判断函数，列判断函数和九宫格判断函数

class Solution(object):
    def check_l(self,l, r, board):  # l :line r:row
        for captcha_l in range(0, 9):
            if captcha_l != r:
                if board[l][r] == board[l][captcha_l]:
                    print('xxxxxx')
                    return False
        return True
    def check_r(self,l, r, board):  # l :line r:row
        for captcha_r in range(0, 9):
            if captcha_r != l:
                if board[l][r] == board[captcha_r][r]:
                    print('xxx')
                    return False
        return True
    def check_nine(self,l, r, board):
        ###确定l的左边界 和右边界 确定r的左边界和右边界
        templ_r = 0  ###line 的右边节
        templ_l = 0
        tempr_r = 0  ###row 的右边节
        tempr_l = 0
        for i in range(0, 12, 3):
            if i > l:
                templ_r = i
                break
        templ_l = templ_r - 3

        for i in range(0, 12, 3):
            if i > r:
                tempr_r = i
                break
        tempr_l = tempr_r - 3

        if templ_l <= l < templ_r and tempr_l <= r < tempr_r:
            for L in range(templ_l, templ_r):
                for R in range(tempr_l, tempr_r):
                    if l != L and r != R :
                        if board[l][r] == board[L][R] and board[l][r] != '.':
                            print('check_nine')
                            return False

            return True


    def isValidSudoku(self,board):
        line = len(board)
        row = len(board[0])
        for l in range(line):
            for r in range(row):
                ###验证行和列是否符合要求
                if board[l][r] != '.':
                    if not (Solution().check_l(l, r, board) and Solution().check_r(l, r, board) and Solution().check_nine(l, r, board)):
                        return False
        else:
            return True


print(Solution().isValidSudoku([["5", "3", ".", ".", "7", ".", ".", ".", "."]
, ["6", ".", ".", "1", "9", "5", ".", ".", "."]
, [".", "9", "8", ".", ".", ".", ".", "6", "."]
, ["8", ".", ".", ".", "6", ".", ".", ".", "3"]
, ["4", ".", ".", "8", ".", "3", ".", ".", "1"]
, ["7", ".", ".", ".", "2", ".", ".", ".", "6"]
, [".", "6", ".", ".", ".", ".", "2", "8", "."]
, [".", ".", ".", "4", "1", "9", ".", ".", "5"]
, [".", ".", ".", ".", "8", ".", ".", "7", "9"]]))

题解：
https://leetcode.cn/problems/valid-sudoku/solutions/2485644/valid-sudoku-by-meng-ci-v-h1ro/

题目二：50. Pow(x, n)

题目分析，这里要进行快速幂+迭代
前言
本题的方法被称为「快速幂算法」，有递归和迭代两个版本。这篇题解会从递归版本的开始讲起，再逐步引出迭代的版本。

class Solution:
    def myPow(self, x: float, n: int) -> float:
        def quickMul(N):
            if N == 0:
                return 1.0
            y = quickMul(N // 2)
            return y * y if N % 2 == 0 else y * y * x
        
        return quickMul(n) if n >= 0 else 1.0 / quickMul(-n)

复杂度分析

• 时间复杂度：O(log⁡n)O(\log n)O(logn)，即为递归的层数。

• 空间复杂度：O(log⁡n)O(\log n)O(logn)，即为递归的层数。这是由于递归的函数调用会使用栈空间。

方法二：快速幂 + 迭代
由于递归需要使用额外的栈空间，我们试着将递归转写为迭代。在方法一中，我们也提到过，从左到右进行推导是不容易的，因为我们不知道是否需要额外乘 xxx。但我们不妨找一找规律，看看哪些地方额外乘了 xxx，并且它们对答案产生了什么影响。

class Solution:
    def myPow(self, x: float, n: int) -> float:
        def quickMul(N):
            ans = 1.0
            # 贡献的初始值为 x
            x_contribute = x
            # 在对 N 进行二进制拆分的同时计算答案
            while N > 0:
                if N % 2 == 1:
                    # 如果 N 二进制表示的最低位为 1，那么需要计入贡献
                    ans *= x_contribute
                # 将贡献不断地平方
                x_contribute *= x_contribute
                # 舍弃 N 二进制表示的最低位，这样我们每次只要判断最低位即可
                N //= 2
            return ans
        
        return quickMul(n) if n >= 0 else 1.0 / quickMul(-n)

复杂度分析

• 时间复杂度：O(log⁡n)O(\log n)O(logn)，即为对 nnn 进行二进制拆分的时间复杂度。

• 空间复杂度：O(1)O(1)O(1)

链接：https://leetcode.cn/problems/powx-n/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。