leetcode刷题 Day4

153. Find Minimum in Rotated Sorted Array
     今天这个二分以往有点差别，不是和target比较，而是和list开头比。
     takeaway：
     1.如果觉得情况多不知道怎么二分可以先把特殊情况解决掉，比如只有一个元素，序列本身就是排好序的
     2.更新up,down的时候加减一快一点
     3.LeetCode不会限时，用线性搜索也能过，不过用二分的话基本时间超过90%的人，写到最好能到97%-99%

class Solution(object):
    def findMin(self, nums):
        if len(nums)==1:
            return nums[0]
        a=0
        b=len(nums)-1
        if nums[0]<nums[b]:
            return nums[0]
        while a<=b:
            middle=int((a+b)/2)
            if nums[middle]<nums[middle-1]:
                return nums[middle]
            if nums[middle]>nums[middle+1]:
                return nums[middle+1]
            if nums[middle]<nums[0]:
                b-=1
            else:
                a+=1

33. Search in Rotated Sorted Array
    对于上述数列排序：
    思路：先用上一道题思路找到旋转点，然后对前后两个序列分别二分查找

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if len(nums)==0:
            return -1
        if len(nums)==1:
            if nums[0]==target:
                return 0
            else:
                return -1
        index=1
        if nums[0]<nums[len(nums)-1]:
            index=0
        up=len(nums)-1
        down=0
        while down<=up and index!=0:
            middle=int((up+down)/2)
            if nums[middle]>nums[middle+1]:
                index=middle+1
                break
            if nums[middle-1]>nums[middle]:
                index=middle
                break
            if nums[0]>nums[middle]:
                up-=1
            else:
                down+=1
        left1=bisect.bisect_left(nums[0:index],target)
        right1=bisect.bisect_right(nums[0:index],target)
        left2=bisect.bisect_left(nums[index:len(nums)],target)
        right2=bisect.bisect_right(nums[index:len(nums)],target)
        if left1==right1 and left2==right2:
            return -1
        else:
            if left1!=right1:
                return left1
            elif left2!= right2:
                return left2+index

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

后面是一段简单点的，但是不知道为什么时间空间复杂度没有第一个表现好。
奇怪的是为什么同一段代码在Python和Python3提交，和其他人的时间空间复杂度比较排名差那么多，在Python3里很靠前的在Python里很靠后，求解？

今天因为不想做助研中午做了一道题，晚上因为不想做助研闲鱼一晚上，和闺蜜、妈妈分别聊了半个多小时来缓解心里的烦躁，最后还是和他聊了半个小时，才直面问题。不如下次心乱直接聊吧，或者直接刷题。