Leetcode-D40-数组-34. 在排序数组中查找元素的第一个和最后一个位置&36. 有效的数独

一、复习

33、 搜索旋转排序数组
今天的思路顺利多了，就是还有一些小纰漏。刚开始判断的是mid落在哪个区间，是nums[mid]在和端点作比较，而不是target；在后来判断target区间的时候，要严格加上左右边界，不然不严谨。

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        n = len(nums)
        l=0
        r=n-1
        while(l<=r):
            mid = (l+r)//2
            if nums[mid] == target:
                return mid
            else:
                if nums[0]<=nums[mid]:
                    if nums[0]<=target<nums[mid]:
                        r = mid-1
                    else:
                        l= mid+1
                else:
                    if nums[mid]<target<=nums[n-1]:
                        l=mid+1
                    else:
                        r = mid-1
        return -1

二、34. 在排序数组中查找元素的第一个和最后一个位置

1、我肯定可以通过二分法找到这个数，但是不能确定找到的是第几个。那如果可以确定找到第一个或者最后一个，问题就简单了。
不会啊
2、复制一下
//求左边界：向下取整，等号归右，左加一
//求右边界：向上取整，等号归左，右减一
//总是右侧为所求

帅呆了，酷毙了，简直不可理喻了。

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
    #      //求左边界：向下取整，等号归右，左加一
    # //求右边界：向上取整，等号归左，右减一
    # //总是右侧为所求
        n = len(nums)
        if n==0:
            return [-1,-1]
        if n==1:
            if nums[0]==target:
                return [0,0]
            else:
                return [-1,-1]
        l=0
        r=n-1
        while(l<r):
            mid = (l+r)//2
            if target<=nums[mid]:
                r =mid
            else:
                l = mid+1
        if nums[r]== target:
            l_index = r
        else:
            l_index = -1
        
        l=0
        r=n-1
        while(l<r):
            mid=(l+r)//2+1
            if nums[mid]<=target:
                l = mid
            else:
                r = mid-1
        if nums[r]==target:
            r_index = r
        else:
            r_index= -1

        return [l_index,r_index]

3、背一下
求左边界：
向下取证，等号归右，左加1；
求右边界：
向上取等，等号归左，右减1；

最后取右

改良版：
求左边界：
向下取整；target在左，右得mid；左加1；
求右边界：
向上取整；target在右，左得mid；右减1；

【明天再写一遍】

三、36. 有效的数独

1、取出来，再排序，再判断相邻。做三次（三条规则），时间复杂度是O（n2）。看看有什么其他好的解法没有。

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:
        col = [[0]*10 for _ in range(9)]
        row = [[0]*10 for _ in range(9)]
        box = [[0]*10 for _ in range(9)]

        for i in range(9):
            for j in range(9):
                if board[i][j] =='.':
                    continue
                curNum = int(board[i][j])
                if col[j][curNum]!=0 or row[i][curNum]!=0 or box[(i//3)*3+j//3][curNum]!=0:
                    return False
                col[j][curNum],row[i][curNum],box[(i//3)*3+j//3][curNum]=1,1,1
        return True

大概写了一下，哈希表还是一个好东西：当某些需要判断是否出现或者记录出现次数的数或字母的数量固定的时候，可以记录这些东西是否出现过，或者出现的次数。

【明天复习的时候再看下之前做的哈希表的题】

标签：target,nums,curNum,36,int,取整,数组,D40,边界
来源： https://blog.csdn.net/weixin_45252975/article/details/122768176