task03 查找1

01 35. 搜索插入位置：

https://leetcode-cn.com/problems/search-insert-position/
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        if not nums:
            return None
        left = 0
        right = len(nums) - 1
        if nums[left] == target:
            return left
        if nums[right] == target:
            return right
        if nums[left] > target:
            return 0
        if nums[right] <target:
            return len(nums)
        while left < right-1:
            mid = (left + right) // 2
            if nums[mid] == target:
                return mid
            if nums[mid] < target:
                left = mid
            else:
                right = mid
        if nums[left] == target:
            return left
        else:
            return right

利用二分法查找，需要注意边界条件，循环开始前判断左右位置是否是target，或者nums[left] > target,或者nums[right] < target循环之后也需要判断一次

02 202. 快乐数

https://leetcode-cn.com/problems/happy-number
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为  1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。

class Solution:
    def isHappy(self, n: int) -> bool:
        past = n
        collect = [n]
        while True:
            nums = list(str(past))
            sums = 0
            for i in nums:
                sums += int(i)**2
            if sums == 1:
                return True
            if sums in collect:
                return False
            past = sums
            collect.append(sums)

需要注意的是跳出循环的条件，当得出的平方和在之前出现过，则说明将无限循环，因此需要用一个列表将之前得出的平方和都保存下来

03 205. 同构字符串

https://leetcode-cn.com/problems/isomorphic-strings
给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        def test(s,t):
            if len(s) != len(t):
                return False
            dic = dict()
            for i in range(len(s)):
                if s[i] not in dic.keys():
                    dic[s[i]] = t[i]
                elif dic[s[i]] != t[i]:
                    return False
            return True
        return test(s,t) and test(t,s)

做法是将两单词字母映射关系用字典存储，然后一次看对应单词是否符合条件，因为一开始只考虑了A到B的映射，所以再将其调换位置判断一次

04 242. 有效的字母异位词

https://leetcode-cn.com/problems/valid-anagram/
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if len(s)!= len(t):
            return False            
        def create_dic(s):
            dic=dict()
            for a in s:
                if a in dic.keys():
                    dic[a] = dic[a] + 1
                else:
                    dic[a] = 0
            return dic
        dic1 = create_dic(s)
        dic2 = create_dic(t)
        return dic1 == dic2

分别构造字母：个数字典，然后判断两字典是否相同

05 290. 单词规律

https://leetcode-cn.com/problems/word-pattern
给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

class Solution:
    def wordPattern(self, pattern: str, str: str) -> bool:
        pattern = list(pattern)
        str = str.split()
        if len(pattern) != len(str):
            return False
        dic = dict()
        words = []
        for p,s in zip(pattern,str):
            if p not in dic.keys():
                if s in words:
                    return False
                dic[p] = s
                words.append(s)
            elif dic[p] != s:
                return False
        return True

利用字典存储pattern和str之间的映射关系，通过循环来判断是否匹配对应的规律

06 349. 两个数组的交集

https://leetcode-cn.com/problems/intersection-of-two-arrays/
给定两个数组，编写一个函数来计算它们的交集。

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:        
        return list(set(nums1) & set(nums2))

将两数组先转为集合，然后再求交集

07 350. 两个数组的交集 II

https://leetcode-cn.com/problems/intersection-of-two-arrays-ii
给定两个数组，编写一个函数来计算它们的交集。
说明：
输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。
我们可以不考虑输出结果的顺序。

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        dic = {num:[0,0] for num in nums1+nums2}
        for i in nums1:
            dic[i][0] += 1
        for i in nums2:
            dic[i][1] += 1
        res = []
        for i in dic:
            res += [i]*min([dic[i][0],dic[i][1]])
        return res

分别统计两数组元素数量，将二者数量少的提取出来组成新的数组

08 410. 分割数组的最大值

https://leetcode-cn.com/problems/split-array-largest-sum
给定一个非负整数数组和一个整数 m，你需要将这个数组分成 m 个非空的连续子数组。设计一个算法使得这 m 个子数组各自和的最大值最小。

注意:
数组长度 n 满足以下条件:

1 ≤ n ≤ 1000
1 ≤ m ≤ min(50, n)

方法一：动态规划
思路与算法

「将数组分割为 mm 段，求……」是动态规划题目常见的问法。

本题中，我们可以令 f[i][j] 表示将数组的前 i个数分割为 j段所能得到的最大连续子数组和的最小值。在进行状态转移时，我们可以考虑第 j段的具体范围，即我们可以枚举 k，其中前 k个数被分割为 j-1 段，而第 k+1到第 i 个数为第 j段。此时，这 j 段子数组中和的最大值，就等于 f[k][j-1] 与sub(k+1,i) 中的较大值，其中sub(i,j) 表示数组 nums 中下标落在区间 [i,j] 内的数的和。

由于我们要使得子数组中和的最大值最小，因此可以列出如下的状态转移方程：

f[i][j] = \min_{k=0}^{i-1} \Big{ \max(f[k][j-1], \textit{sub}(k+1,i)) \Big}
f[i][j]=
k=0
min
i−1
​
{max(f[k][j−1],sub(k+1,i))}

对于状态 f[i][j]，由于我们不能分出空的子数组，因此合法的状态必须有 i \geq ji≥j。对于不合法（i < ji<j）的状态，由于我们的目标是求出最小值，因此可以将这些状态全部初始化为一个很大的数。在上述的状态转移方程中，一旦我们尝试从不合法的状态 f[k][j-1] 进行转移，那么max(⋯) 将会是一个很大的数，就不会对最外层的 \min{\cdots}min{⋯} 产生任何影响。

此外，我们还需要将 f[0][0] 的值初始化为 00。在上述的状态转移方程中，当 j=1j=1 时，唯一的可能性就是前 ii 个数被分成了一段。如果枚举的 k=0k=0，那么就代表着这种情况；如果 k \neq 0k

​
=0，对应的状态 f[k][0] 是一个不合法的状态，无法进行转移。因此我们需要令 f[0][0] = 0。

最终的答案即为 f[n][m]。

class Solution:
    def splitArray(self, nums: List[int], m: int) -> int:
        n = len(nums)
        f = [[10**18] * (m + 1) for _ in range(n + 1)]
        sub = [0]
        for elem in nums:
            sub.append(sub[-1] + elem)
        
        f[0][0] = 0
        for i in range(1, n + 1):
            for j in range(1, min(i, m) + 1):
                for k in range(i):
                    f[i][j] = min(f[i][j], max(f[k][j - 1], sub[i] - sub[k]))
        
        return f[n][m]

复杂度分析

时间复杂度：O(n^2 × m)，其中 n是数组的长度，m 是分成的非空的连续子数组的个数。总状态数为 O(n×m)，状态转移时间复杂度 O(n)，所以总时间复杂度为 O(n^2×m)。

空间复杂度：O(n×m)，为动态规划数组的开销。

方法二：二分查找 + 贪心
思路及算法

「使……最大值尽可能小」是二分搜索题目常见的问法。

本题中，我们注意到：当我们选定一个值 xx，我们可以线性地验证是否存在一种分割方案，满足其最大分割子数组和不超过 xx。策略如下：

贪心地模拟分割的过程，从前到后遍历数组，用 sum 表示当前分割子数组的和，cnt 表示已经分割出的子数组的数量（包括当前子数组），那么每当 sum加上当前值超过了 x，我们就把当前取的值作为新的一段分割子数组的开头，并将 cnt 加 1。遍历结束后验证是否cnt 不超过 m。

这样我们可以用二分查找来解决。二分的上界为数组nums 中所有元素的和，下界为数组 nums 中所有元素的最大值。通过二分查找，我们可以得到最小的最大分割子数组和，这样就可以得到最终的答案了。

class Solution:
    def splitArray(self, nums: List[int], m: int) -> int:
        def check(x: int) -> bool:
            total, cnt = 0, 1
            for num in nums:
                if total + num > x:
                    cnt += 1
                    total = num
                else:
                    total += num
            return cnt <= m


        left = max(nums)
        right = sum(nums)
        while left < right:
            mid = (left + right) // 2
            if check(mid):
                right = mid
            else:
                left = mid + 1

        return left

复杂度分析

时间复杂度：O(n×log(sum−maxn))，其中 sum 表示数组nums 中所有元素的和，maxn 表示数组所有元素的最大值。每次二分查找时，需要对数组进行一次遍历，时间复杂度为O(n)，因此总时间复杂度是 O(n×log(sum−maxn))。

空间复杂度：O(1)。

09 451. 根据字符出现频率排序

https://leetcode-cn.com/problems/sort-characters-by-frequency/
给定一个字符串，请将字符串里的字符按照出现的频率降序排列。

class Solution:
    def frequencySort(self, s: str) -> str:
        if not s:
            return ''
        dic = dict()
        for i in s:
            if i not in dic.keys():
                dic[i] = 1
            else:
                dic[i] += 1
        dic = [(k,dic[k]) for k in dic]
        dic.sort(key=lambda x:x[1],reverse=True)
        res = ''
        for i in dic:
            res += i[0]*i[1]
        return res

利用字典统计词频，然后将字典转换成tuple列表，按照字母次数降序排列并生成最终字符串

10 540. 有序数组中的单一元素

https://leetcode-cn.com/problems/single-element-in-a-sorted-array
给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

示例 1:

输入: [1,1,2,3,3,4,4,8,8]
输出: 2
示例 2:

输入: [3,3,7,7,10,11,11]
输出: 10
注意: 您的方案应该在 O(log n)时间复杂度和 O(1)空间复杂度中运行。

class Solution:
    def singleNonDuplicate(self, nums: List[int]) -> int:
        if len(nums) == 1:
            return nums[0]
        left = 0
        right = len(nums) - 2
        while left < right - 1:
            if nums[left] != nums[left+1]:
                return nums[left]
            if nums[right] != nums[right+1]:
                return nums[right+1]
            mid = (left + right) // 2
            if nums[mid] != nums[mid+1]:
                if nums[mid+1] ==nums[mid+2]:
                    mid += 1
                else:
                    return nums[mid+1]
            if (right - mid) % 2 == 0:
                right = mid
            else:
                left = mid
            # print(left,right)
        if nums[left] !=nums[left+1]:
            return nums[left]
        else:
            return nums[right+1]

利用二分法进行查找，每次取左右索引的中间值，指向两相同数字的第一个索引，并判断left、mid、right是否为单个数字。当单个数字在后半部分时，这部分长度为奇数，需要将left更新为mid，否则就将right更新为mid