letcode每日一题

学一点算法基础

title：无重复字符的最长子串

desc:给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

detail:滑动窗口+双指针

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        temp = 1	#初始长度
        res = 0		#结果
        _s = set()	#空字典存储
        for i in range(len(s)):
            _s.add(s[i])
            j = i + 1
            for k in range(j, len(s)):
                if s[k] in _s:
                    break
                _s.add(s[k])
                temp += 1 
            # print(temp, _s)
            res = temp if temp > res else res
            temp = 1
            _s.clear()
        return res        

title：字符串的排列

desc:换句话说，第一个字符串的排列之一是第二个字符串的子串。

detail:双指针+额为空间<我真垃圾、不想写了>

code：

class Solution:
    def checkInclusion(self, s1: str, s2: str) -> bool:
        l = len(s1)
        for i in range(len(s2) - l + 1):
            j = l + i
            a = list(s1)
            b = list(s2[i:j])
            b.sort()
            a.sort()
            if a == b:
                return True
        return False

title:字符串相乘

desc:给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

detail:别人是算法，我的是解法

class Solution:
    def multiply(self, num1: str, num2: str) -> str:
        return str(int(num1)*int(num2))

title:翻转字符串里的单词

desc:给定一个字符串，逐个翻转字符串中的每个单词。

detail:

class Solution:
    def reverseWords(self, s: str) -> str:
        res = s.strip().split()
        res.reverse()
        return " ".join(res)

title：岛屿的最大面积

desc:

给定一个包含了一些 0 和 1 的非空二维数组 grid 。一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)

detail:
（DFS、BFS）+ 剪枝思想 <遍历的同时排除之前踩过的点>

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:

        width, height = len(grid[0]), len(grid)

        def bfs(grid, x, y):
            if 0<=x<width and 0<=y<height and grid[y][x]:
                grid[y][x] = 0
                return 1 + bfs(grid, x, y+1) + bfs(grid, x, y-1) + bfs(grid, x+1, y) + bfs(grid, x-1, y) 
            return 0 

        res = 0
        for x in range(width):
            for y in range(height):
                res = max(res, bfs(grid, x, y))
        return res



# class Solution:
#     def maxAreaOfIsland(self, grid: List[List[int]]) -> int:

#         m, n = len(grid), len(grid[0])

#         def dfs(gird, i, j):
#             if 0<=i<m and  0<=j<n and grid[i][j]:
#                 grid[i][j] = 0
#                 return 1 + dfs(grid, i+1,j) + dfs(grid, i-1, j) + dfs(grid, i, j+1) + dfs(grid, i, j-1)
#             return 0

#         result = 0
#         for x in range(m):
#             for y in range(n):
#                 result = max(result, dfs(grid, x, y))
#         return result

title:最长连续递增序列

desc:

给定一个未经排序的整数数组，找到最长且连续的的递增序列，并返回该序列的长度。

detail:

很简单的解法

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        l = len(nums)
        if l < 2:
            return l
        res = 1
        result = 0
        for i in range(1, l):
            if nums[i] > nums[i-1]:
                res += 1
                result = max(result, res)                
            else:
                res = 1
        result = max(result, res)                                
        return result

title:数组中的第K个最大元素

desc:

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

detail:

• 冒泡排序 ----》 超时

  

• 调用内置函数 ----》 AC

  • Timsort是结合了合并排序（merge sort）和插入排序（insertion sort）而得出的排序算法，它在现实中有很好的效率
  • 最坏时间复杂度为：O（n log n）
  • 空间复杂度为：O（n）
    

• 手撕快排 ----》 AC（比内置慢了好多）

  

```python
class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        def sub_sort(l,low,high):
            x = l[low]  # 基准
            while low < high:
                # 如果后边的数比x大high向前走
                while l[high] > x and high > low:
                    high -= 1
                l[low] = l[high]  # 比x小的往前甩
                # 如果前面的数比x小则low往后走
                while l[low] <= x and low < high:
                    low += 1
                l[high] = l[low]  # 比x大的往后甩
            l[low] = x  # 将x插入最终位置
            return low  #  每一轮最终基准数确定的位置


        # low : 第一个元素索引号,high: 最后一个元素索引号
        """
        该写法表示希望low传一个整形,high传一个整形,返回值为None类型
        但是没有强制要求必须这样做
        """
        def quick(l:list,low:int,high:int)->None:
            if low < high:
                key = sub_sort(l,low,high)
                quick(l,low,key-1)
                quick(l,key+1,high)
                
        quick(nums, 0, len(nums)-1)
        print(nums)
        return nums[-k]

title:最长连续序列

desc:

给定一个未排序的整数数组，找出最长连续序列的长度。

要求算法的时间复杂度为 O(n)。

detail:

时间复杂度要求O（n）所以用辅助空间解题

class Solution:
    def longestConsecutive(self, nums):
        res = 0
        num_set = set(nums)

        for num in num_set:
            if num - 1 not in num_set:
                cur_num = num
                cur_res = 1
                while cur_num + 1 in num_set:
                    cur_num += 1
                    cur_res += 1
                res = max(res, cur_res)8/
                
        return res

title:两数相加

desc:

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

detail:

简单AC，效率低

>

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        s1 = s2 = str()
        res_0 = res = ListNode(0)
        while l1:
            s1 += str(l1.val)            
            l1 = l1.next
        while l2:
            s2 += str(l2.val)            
            l2 = l2.next
        sum = int(s1[::-1]) + int(s2[::-1])
        for i in str(sum)[::-1]:
            res.next = ListNode(int(i))    
            res = res.next
        return res_0.next