leetcode刷题(3)

时间仓促只写了代码和简单注释，后续会补充。

# 35 搜索插入位置 二分查找
# 找到target相同值返回索引 如果不存在返回插入位置
class Solution():
    def searchInsert(self,nums,target):
        n = len(nums)
        left = 0
        right = n-1
        ans = n
        while (left<=right):
            mid = ((right-left)>>1)+left
            if (target<=nums[mid]):
                ans = mid
                right = mid-1
            else:
                left = mid +1
        return ans

"""
202
1. 最终会得到 11。
2. 最终会进入循环。
3. 值会越来越大，最后接近无穷大。
"""
def isHappy(self, n: int):

    def get_next(n):
        total_sum = 0
        while n > 0:
            n, digit = divmod(n, 10)
            total_sum += digit ** 2
        return total_sum

    seen = set()
    while n != 1 and n not in seen:
        seen.add(n)
        n = get_next(n)

    return n == 1

class Solution3:
    def isIsomorphic(self, s: str, t: str) -> bool:
        for i in range(len(s)):
            if s.index(s[i]) != t.index(t[i]):
                return False
        return True

# 205哈希查找
class Solution4:
    def isIsomorphic(self, s, t):
        dct = {}
        for i in range(len(s)):
            if s[i] not in dct:
                if t[i] in dct.values():
                    return False
                dct[s[i]] = t[i]
            else:
                if dct[s[i]] != t[i]:
                    return False
        return True

# 242. 有效的字母异位词
"""
用哈希表统计第一个字符串中的字符数量；
再统计第二个字符串时，若字符在哈希表中，计数减一，否则返回false
最后判断哈希表中值是否都为0。
"""
class Solution5(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        if len(s) != len(t):
            return False
        count = {}
        for char in s:
            if char in count:
                count[char] += 1
            else:
                count[char] = 1
        for char in t:
            if char in count:
                count[char] -= 1
            else:
                return False
        for value in count.values():
            if value != 0:
                return False
        return True

# 290. 单词规律
class Solution6:
    def wordPattern(self, pattern, str):
        t = str.split()
        if len(pattern) != len(t):
            return False
        dct = {}
        s_lst = []
        new = 1
        for i in pattern:
            if i in dct:
                s_lst.append(dct[i])
            else:
                dct[i] = new
                s_lst.append(new)
                new += 1

        dct = {}
        t_lst = []
        new = 1
        for i in t:
            if i in dct:
                t_lst.append(dct[i])
            else:
                dct[i] = new
                t_lst.append(new)
                new += 1

        return s_lst == t_lst

# 349. 两个数组的交集
class Solution7:
    def set_intersection(self, set1, set2):
        return [x for x in set1 if x in set2]

    def intersection(self, nums1, nums2):

        set1 = set(nums1)
        set2 = set(nums2)

        if len(set1) < len(set2):
            return self.set_intersection(set1, set2)
        else:
            return self.set_intersection(set2, set1)

# 350. 两个数组的交集2
"""

"""
from collections import defaultdict
class Solution8:
    def intersect(self, nums1, nums2):
        dct1 = defaultdict(int)
        for i in nums1:
            dct1[i] += 1
        dct2 = defaultdict(int)
        for i in nums2:
            dct2[i] += 1
        dct3 = {i: min(dct1[i], dct2[i]) for i in set(dct1)&set(dct2)}
        return sum([[key]*val for key, val in dct3.items()], [])


# 410. 分割数组的最大值
"""
给定一个非负整数数组和一个整数 m，你需要将这个数组分成 m 个非
空的连续子数组。设计一个算法使得这 m 个子数组各自和的最大值最小。"""
class Solution9:
    def splitArray(self, nums, m: 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]

# 根据字符出现频率排序 大顶堆
import collections
import heapq
class Solution10:
    def frequencySort(self, s: str) -> str:
        # 大顶堆
        countFrequency = collections.defaultdict(int)
        for i in s:
            countFrequency[i] += 1
        lst = []
        heapq.heapify(lst)
        for i in countFrequency:
            for j in range(countFrequency[i]):
                heapq.heappush(lst, (-countFrequency[i], i))

        return ''.join([heapq.heappop(lst)[1] for _ in range(len(s))])


# 540. 有序数组中的单一元素遍历
def singleNonDuplicate(self, nums):
    for i in range(0, len(nums) - 2, 2):
        if nums[i] != nums[i + 1]:
            return nums[i]
    return nums[-1]