2019-05-25

Author: JiayangWu

0015.三数之和/0015-三数之和.py

@@ -0,0 +1,32 @@
+class Solution(object):
+    def threeSum(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """
+        #固定a,用双指针在排序数组里找两数之和为-a
+        nums.sort()
+        l = len(nums)
+        res = []
+        for i, a in enumerate(nums):
+            if i == 0 or nums[i] > nums[i - 1]:
+            #开始双指针
+                left, right = i + 1, len(nums) - 1
+                while(left < right):
+                    s = a +  nums[left] + nums[right]
+                    if s == 0:
+                        tmp = [a, nums[left], nums[right]]
+                        res.append(tmp)
+                        left += 1
+                        right -= 1
+                        while left < right and nums[left] == nums[left - 1]:
+                            left += 1
+                        while right > left and nums[right] == nums[right + 1]:
+                            right -= 1
+                    elif s < 0:
+                        left += 1
+                    elif s > 0:
+                        right -= 1
+        return res
+                
+            

0018.四数之和/0018-四数之和.py

@@ -0,0 +1,46 @@
+class Solution(object):
+    def fourSum(self, n, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[List[int]]
+        """
+        self.res = []
+        n.sort()
+        # print n
+        def threeSum(nums,t, d):
+            """
+            :type nums: List[int]
+            :rtype: List[List[int]]
+            """
+            #固定a,用双指针在排序数组里找两数之和为-a
+            l = len(nums)
+            res = []
+            for i, a in enumerate(nums):
+                if i == 0 or nums[i] > nums[i - 1]:
+                #开始双指针
+                    left, right = i + 1, len(nums) - 1
+                    while(left < right):
+                        s = a +  nums[left] + nums[right]
+                        # print d, a, nums[left], nums[right]
+                        if s == t:
+                            tmp = [d,a, nums[left], nums[right]]
+                            self.res.append(tmp)
+                            left += 1
+                            right -= 1
+                            while left < right and nums[left] == nums[left - 1]:
+                                left += 1
+                            while right > left and nums[right] == nums[right + 1]:
+                                right -= 1
+                        elif s < t:
+                            left += 1
+                        elif s > t:
+                            right -= 1
+        
+        for i in range(len(n) - 3):
+            if i == 0 or n[i] > n[i - 1]:
+                # print n[i]
+                threeSum(n[i + 1:], target - n[i], n[i])
+                
+                
+        return self.res

0043.字符串相乘/0043-字符串相乘.py

@@ -0,0 +1,69 @@
+class Solution(object):
+    def multiply(self, num1, num2):
+        """
+        :type num1: str
+        :type num2: str
+        :rtype: str
+        """
+        if len(num1) < len(num2):
+            num1, num2 = num2, num1
+        if num1 == "0" or num2 == "0":
+            return "0"
+        
+        num2 = num2[::-1]
+        tmp, res = [],[]
+        for i, char in enumerate(num2):
+            tmp = self.stringMultiDigit(num1, int(char)) + "0" * i #计算当前位乘法的结果，注意末尾添0
+            res = self.stringPlusString(res, tmp) #加上当前位结果
+            
+        return "".join(res)
+    
+    def stringMultiDigit(self,s, n): #计算一个字符串和一个数字的乘积， 返回字符串
+        s = s[::-1]
+        l = []
+        for char in s:
+            l.append(int(char))
+            
+        for i, char in enumerate(l):
+            l[i] *= n
+            
+        for i, char in enumerate(l):
+            while(l[i] > 9):
+                tmp = l[i] // 10
+                l[i] -= tmp * 10
+                if i == len(l) - 1:
+                    l.append(0)
+                l[i + 1] +=  tmp
+                
+        return "".join(str(char) for char in l[::-1])
+            
+        
+    def stringPlusString(self,s1, s2): #字符串加法，返回字符串
+        # print s1, s2
+        s1, s2 = s1[::-1], s2[::-1]
+        l1, l2 = [], []
+        for char in s1:
+            l1.append(int(char))
+        for char in s2:
+            l2.append(int(char))
+        # tmp = []
+        if len(l1) < len(l2):
+            l1, l2 = l2, l1
+        i = 0
+        for i in range(len(l2)):
+            l1[i] += l2[i]
+            if l1[i] > 9:
+                l1[i] -= 10
+                if i == len(l1) - 1:
+                    l1.append(0)
+                l1[i + 1] += 1
+        i += 1
+        if i < len(l1) - 1: #处理最后一位可能的进位
+            if l1[i] > 9:
+                l1[i] -= 10
+                if i == len(l1) - 1:
+                    l1.append(0)
+                l1[i + 1] += 1
+
+        return "".join(str(char) for char in l1[::-1])
+    

0081.搜索旋转排序数组II/0081-搜索旋转排序数组II.py

@@ -0,0 +1,114 @@
+class Solution(object):
+    def search(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: bool
+        """
+        #如果第一个数和最后一个数不相等，那么跟上一题没有区别
+        #如果第一个数和最后一个数相等，而且等于target，return true
+        #如果第一个数和最后一个数相等，但是不等于target，在最坏的情况下就需要遍历两个升序数组的某一个，已确定target有可能落在哪一段，极端情况时间复杂度会降低到0(N)
+        if not nums:
+            return False
+        if nums[0] != nums[-1]:
+            return self.search1(nums, target)
+        if nums[0] == nums[-1]:
+            if nums[0] == target:
+                return True
+            else:
+                # for num in nums: #偷懒就可以这么写……直接上O(N)的算法
+                #     if num == target:
+                #         return True
+                # return False
+                return self.search2(nums, target)
+        
+    def search1(self, nums, target): #上一题的解答，两次二分查找分别找旋转点和结果
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        if not nums:
+            return -1
+        if len(nums) == 1:
+            return True if nums[0] == target else False
+        
+        lo, hi = 0, len(nums) - 1
+        while(lo <= hi):
+            mid = (lo + hi) // 2
+            if mid + 1 < len(nums) and nums[mid] > nums[mid +1]: #旋转点为mid
+                break
+            if nums[mid] <= nums[-1]:
+                hi = mid - 1
+            elif nums[mid] >= nums[0]:
+                lo = mid + 1
+                
+        if lo > hi:#没有旋转
+            lo, hi = 0, len(nums) - 1
+        else:
+            if target >= nums[0]:
+                lo, hi = 0, mid
+            else:
+                lo, hi = mid + 1, len(nums) - 1
+
+        while(lo <= hi):
+            mid = (lo + hi) // 2
+            if nums[mid] == target:
+                return True
+            elif nums[mid] > target:
+                hi = mid - 1
+            else:
+                lo = mid + 1
+        
+        return False
+    
+    def search2(self, nums, target):#这种情况下nums[0] == nums[-1]
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        if not nums:
+            return -1
+        if len(nums) == 1:
+            return True if nums[0] == target else False
+        
+        lo, hi = 0, len(nums) - 1
+        while(lo <= hi):
+            mid = (lo + hi) // 2
+            if mid + 1 < len(nums) and nums[mid] > nums[mid +1]:
+                break
+            if nums[mid] == nums[0]: #无法确定mid落在哪一段
+                i = mid
+                while(i < len(nums) - 1 and nums[i] == nums[i + 1]):
+                    i += 1
+                if i == len(nums) - 1:#整个右段都找完了，全部跟nums[0]一样，所以target肯定落在左侧，也就是0 ~ mid这一段
+                    hi = mid - 1
+                else:
+                    lo = mid + 1
+                
+            if nums[mid] < nums[-1]:
+                hi = mid - 1
+            elif nums[mid] > nums[0]:
+                lo = mid + 1    
+
+        if target > nums[mid]:
+            return False #因为mid一定是最大的那个数
+        elif target == nums[mid]: #找到了就直接返回
+            return True
+        elif target < nums[mid]: #还需要二分查找，现在要确认找左侧还是找右侧
+            if target > nums[0]: #在左侧找
+                lo, hi = 0, mid - 1
+            else: #在右侧找
+                lo, hi = mid + 1, len(nums) - 1
+            
+        while(lo <= hi):
+            mid = (lo + hi) // 2
+            if nums[mid] == target:
+                return True
+            elif nums[mid] > target:
+                hi = mid - 1
+            else:
+                lo = mid + 1
+        
+        return False

0089.格雷编码/0089-格雷编码.py

@@ -0,0 +1,11 @@
+class Solution(object):
+    def grayCode(self, n):
+        """
+        :type n: int
+        :rtype: List[int]
+        """
+        # G(i) = i ^ (i /2)
+        dp = [0 for _  in range(2 ** n)]
+        for i in range(1, 2 ** n):
+            dp[i] = i ^ (i /2)
+        return dp