update

Author: lemon8888

Diff for: 0001-two-sum/0001-two-sum.py

@@ -1,11 +1,11 @@
-#利用哈希表，空间换时间
+# 利用哈希表，空间换时间
 class Solution:
     def twoSum(self, nums: List[int], target: int) -> List[int]:
-        n=len(nums)
-        mapper={}
+        n = len(nums)
+        mapper = {}
         for i in range(n):
-            if (target-nums[i] in mapper):
-                return [mapper[target-nums[i]],i]
+            if (target - nums[i] in mapper):
+                return [mapper[target - nums[i]], i]
             else:
-                mapper[nums[i]]=i
-        return []
+                mapper[nums[i]] = i
+        return []

Diff for: 0005-longest-palindromic-substring.py

@@ -0,0 +1,23 @@
+# 以每个字母或相邻两个字母为中心计算回文字符串长度，再比较
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        n = len(s)
+        if n == 0:
+            return ""
+        res = s[0]
+
+        def func(s: str, i: int, j: int):
+            while (i >= 0 and j < len(s) and s[i] == s[j]):
+                i -= 1
+                j += 1
+            return s[i + 1:j]
+
+        for i in range(n - 1):
+            s1 = func(s, i, i)
+            s2 = func(s, i, i + 1)
+            if (max(len(s1), len(s2)) > len(res)):
+                if (len(s1) > len(s2)):
+                    res = s1
+                else:
+                    res = s2
+        return res

Diff for: 0006-zigzag-conversion.py

@@ -0,0 +1,16 @@
+# 压缩矩阵排列,并以2n-2为周期
+class Solution:
+    def convert(self, s: str, numRows: int) -> str:
+        l = len(s)
+        if numRows == 1 or numRows >= l:
+            return s
+        res = [['' for i in range(2 * (l // (2 * numRows - 2) + 1))] for j in range(numRows)]
+
+        for i in range(l):
+            a = 2 * (i // (2 * numRows - 2))
+            b = i % (2 * numRows - 2)
+            if (b >= numRows):
+                a += 1
+                b = (2 * numRows - 2 - b)
+            res[b][a] = s[i]
+        return ''.join(ch for row in res for ch in row if ch)

Diff for: 0009-palindrome-number.c renamed to 0009-palindrome-number/0009-palindrome-number.c

@@ -0,0 +1,13 @@
+# 反转数之后比较
+class Solution:
+    def isPalindrome(self, x: int) -> bool:
+        if x < 0:
+            return False
+        if x == 0:
+            return True
+        x1 = x
+        num = 0
+        while x > 0:
+            num = num * 10 + (x % 10)
+            x = x // 10
+        return x1 == num

Diff for: 0009-palindrome-number/0009-palindrome-number.py

@@ -0,0 +1,26 @@
+#排序之后双指针
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        res = []
+        n = len(nums)
+
+        for i in range(n - 2):
+            if (i > 0 and nums[i] == nums[i - 1]):     #去重
+                continue
+            left = i + 1
+            right = n - 1
+            while (left < right):
+                if (nums[i] + nums[left] + nums[right] < 0):
+                    left += 1
+                elif (nums[i] + nums[left] + nums[right] > 0):
+                    right -= 1
+                else:
+                    res.append([nums[i], nums[left], nums[right]])
+                    while (left < right and nums[left] == nums[left + 1]):         #去重
+                        left += 1
+                    while (left < right and nums[right] == nums[right - 1]):
+                        right -= 1
+                    left += 1
+                    right -= 1
+        return (res)

Diff for: 0015-3sum.py

@@ -0,0 +1,24 @@
+#固定一个数，利用双指针计算。比较绝对值
+class Solution:
+    def threeSumClosest(self, nums: List[int], target: int) -> int:
+        nums.sort()
+        res = nums[0] + nums[1] + nums[2]
+        n = len(nums)
+        if (n < 3):
+            return
+        for i in range(n - 2):
+            if (i > 0 and nums[i] == nums[i - 1]):
+                continue
+            left = i + 1
+            right = n - 1
+            while (left < right):
+                s = nums[i] + nums[left] + nums[right]
+                if (s == target):
+                    return s
+                if (abs(s - target) < abs(res - target)):
+                    res = s
+                if (s < target):
+                    left += 1
+                elif (s > target):
+                    right -= 1
+        return res

Diff for: 0016-3sum-closest.py

@@ -0,0 +1,32 @@
+#通过递归将问题始终分解成两数和
+class Solution:
+    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+        nums.sort()
+        res = []
+        self.findnums(target, nums, 4, [], res)
+        return res
+
+    def findnums(self, target: int, nums: List[int], N: int, temp: List[int], res: List[List[int]]):
+        if N < 2 or len(nums) < N:
+            return
+        if N == 2:
+            left = 0
+            right = len(nums) - 1
+            while left < right:
+                if nums[left] + nums[right] < target:
+                    left += 1
+                elif nums[left] + nums[right] > target:
+                    right -= 1
+                else:
+                    res.append(temp + [nums[left], nums[right]])
+                    left += 1
+                    right -= 1
+                    while left < right and nums[left] == nums[left - 1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right + 1]:
+                        right -= 1
+        else:
+            for i in range(len(nums)):
+                if i == 0 or i > 0 and nums[i - 1] != nums[i]:
+                    self.findnums(target - nums[i], nums[i + 1:], N - 1, temp + [nums[i]], res)
+        return

Diff for: 0018-4sum.py

@@ -1,4 +1,4 @@
-//栈
+//?
 typedef struct stack {
     char* top;
     char* base;

Diff for: 0020-valid-parentheses.c

@@ -0,0 +1,16 @@
+# 遍历生成
+class Solution:
+    def countAndSay(self, n: int) -> str:
+        ret = "1"
+        for i in range(n - 1):
+            cur = ""
+            pos = 0
+            start = 0
+
+            while pos < len(ret):
+                while pos < len(ret) and ret[pos] == ret[start]:
+                    pos += 1
+                cur += str(pos - start) + ret[start]
+                start = pos
+            ret = cur
+        return ret

Diff for: 0038-count-and-say.py

@@ -0,0 +1,9 @@
+# 动态规划，计算nums[list,i-1]的和，与nums[i]比较。如果小于则不加，如果大于则加
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        n = len(nums)
+        max_temp = max_sum = nums[0]
+        for i in range(1, n):
+            max_sum = max(max_sum + nums[i], nums[i])
+            max_temp = max(max_sum, max_temp)
+        return max_temp

Diff for: 0053-maximum-subarray.py

@@ -0,0 +1,29 @@
+# 取符号、取整数、取小数
+class Solution:
+    def fractionToDecimal(self, numerator: int, denominator: int) -> str:
+        if numerator == 0 or denominator == 0:
+            return "0"
+        nums = []
+        temp = []
+        if (numerator < 0) != (denominator < 0):  # 取符号
+            nums.append('-')
+            temp.append('-')
+
+        num = abs(numerator)
+        den = abs(denominator)
+        a = num // den  # 取整数
+        b = num % den
+        nums.append(str(a))
+        if b != 0:
+            nums.append('.')
+        while b != 0:  # 取小数
+            if b not in temp:
+                temp.append(b)
+                nums.append(str(b * 10 // den))
+            else:
+                nums.insert(temp.index(b) + 2, '(')
+                nums.append(')')
+                break
+            b = b * 10 % den
+
+        return ''.join(nums)

Diff for: 0166-fraction-to-recurring-decimal.py

@@ -0,0 +1,15 @@
+# 通过字符串求和比较大小排序
+class Solution:
+    def largestNumber(self, nums: List[int]) -> str:
+        s = [str(i) for i in nums]
+
+        def com(a, b):
+            if (a + b) > (b + a):
+                return 1
+            if (a + b) < (b + a):
+                return -1
+            return 0
+
+        s.sort(reverse=True, key=functools.cmp_to_key(com))
+        max_num = str(int("".join(s)))  # int()处理第一位为0的情况
+        return max_num

Diff for: 0179-largest-number.py

@@ -0,0 +1,14 @@
+# set() 函数创建一个无序不重复元素集
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        return not len(set(nums)) == len(nums)
+
+
+# 排序后相邻比较
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        nums.sort()
+        for i in range(len(nums) - 1):
+            if nums[i] == nums[i + 1]:
+                return True
+        return False

Diff for: 0217-contains-duplicate.py

@@ -0,0 +1,19 @@
+# 双指针
+class Solution:
+    def isPalindrome(self, head: ListNode) -> bool:
+        fast = right = head
+        left = None
+        while (fast and fast.next):
+            fast = fast.next.next
+            temp = right.next
+            right.next = left
+            left = right
+            right = temp
+        if fast:
+            right = right.next
+        while left:
+            if (left.val != right.val):
+                return False
+            left = left.next
+            right = right.next
+        return True

Diff for: 0234-palindrome-linked-list.c renamed to 0234-palindrome-linked-list/0234-palindrome-linked-list.c

@@ -1,4 +1,4 @@
-//移动快慢指针，剩下的补0（类似027）
+//移动快慢指针，剩下的补0（类似27）
 void moveZeroes(int* nums, int numsSize) {
     int slow = 0;
     for(int fast = 0; fast < numsSize; fast++) {

Diff for: 0234-palindrome-linked-list/0234-palindrome-linked-list.py

@@ -0,0 +1,14 @@
+# 遍历
+class Solution:
+    def largestDivisibleSubset(self, nums: List[int]) -> List[int]:
+        s = {-1: set()}
+        nums.sort()
+        for i in nums:
+            temp = []
+            for j in s:
+                if (i % j) == 0:
+                    s[j].add(i)
+                    temp.append(s[j])
+                    s[j].remove(i)
+            s[i] = max(temp, key=len) | {i}
+        return list(max(s.values(), key=len))

Diff for: 0283-move-zeroes.c

@@ -0,0 +1,12 @@
+#两两求和
+class Solution:
+    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
+        mapper = {}
+        res = 0
+        for i in nums1:
+            for j in nums2:
+                mapper[i + j] = mapper.get(i + j, 0) + 1
+        for i in nums3:
+            for j in nums4:
+                res += mapper.get(-1 * (i + j), 0)
+        return res

Diff for: 0368-largest-divisible-subset.py

@@ -1,4 +1,3 @@
-//动态规划
 //自底向上
 int fib(int N) {
     if(N <= 1) {

Diff for: 0454-4sum-ii.py

@@ -0,0 +1,17 @@
+# 动态规划，设n行n列的数组，dp[i][j]表示s[i:j+1]中的最大回文长度
+# 如果i==j,则为1
+# 如果s[i]==[j],则在原基础上加2
+# 如果扩展时两边不相等，无法扩展，则取dp[i+1][j]和dp[i][j-1]中最大值
+class Solution:
+    def longestPalindromeSubseq(self, s: str) -> int:
+        n = len(s)
+        dp = [[0] * n for i in range(n)]
+        for i in reversed(range(n)):
+            for j in range(i, n):
+                if i == j:
+                    dp[i][j] = 1
+                elif s[i] == s[j]:
+                    dp[i][j] = dp[i + 1][j - 1] + 2
+                else:
+                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])
+        return dp[0][n - 1]

Diff for: 0509-fibonacci-number.c

@@ -0,0 +1,21 @@
+#利用双指针
+class Solution:
+    def validPalindrome(self, s: str) -> bool:
+        n = len(s)
+
+        def func(s: str, l: int, r: int):
+            while (l < r):
+                if s[l] != s[r]:
+                    return False
+                l += 1
+                r -= 1
+            return True
+
+        l = 0
+        r = n - 1
+        while (l < r):
+            if s[l] != s[r]:
+                return func(s, l + 1, r) or func(s, l, r - 1)
+            l += 1
+            r -= 1
+        return True

Diff for: 0516-longest-palindromic-subsequence.py

@@ -0,0 +1,23 @@
+# 利用对称，前半部分与上一行相同，后半部分与上一行相反
+class Solution:
+    def kthGrammar(self, n: int, k: int) -> int:
+        if n == 1:
+            return 0
+        if k <= (1 << (n - 2)):
+            return self.kthGrammar(n - 1, k)
+        else:
+            return self.kthGrammar(n - 1, k - (1 << (n - 2))) ^ 1
+
+
+# 每个2i位置都与上行i相同，每个2i+1位置都与上行i反转，每一次k除2判断奇偶可以知道是否取反，多次k除2判断奇偶性可以等价于二进制中1的数量
+class Solution:
+    def kthGrammar(self, n: int, k: int) -> int:
+        return (k - 1).bit_count() & 1
+
+
+# 递归
+class Solution:
+    def kthGrammar(self, n: int, k: int) -> int:
+        if n == 1:
+            return 0
+        return (k & 1) ^ 1 ^ self.kthGrammar(n - 1, (k + 1) // 2)

Diff for: 0680-valid-palindrome-ii.py

@@ -0,0 +1,13 @@
+# 利用单调栈，通过比较大小更新跨度值
+class StockSpanner:
+
+    def __init__(self):
+        self.stack = [(-1, inf)]
+        self.index = -1
+
+    def next(self, price: int) -> int:
+        self.index += 1
+        while price >= self.stack[-1][1]:
+            self.stack.pop()
+        self.stack.append((self.index, price))
+        return self.index - self.stack[-2][0]