Leetcode 排序の简单题训练集合（242 349 922 976 1030） python

快排

我之前都没有手写过快排，今天练了一下，但是快排其实本身还有很多优化的技巧，留作TODO吧
我是在1030题上训练的，发现结果和直接用python内置的sort()时间是一样快的（？？）

       def quick_sort(dis, start, end):
            if start < end:
                i = start
                j = end
                tmp = dis[i]
                while i < j:
                    while i < j:
                        if dis[j] < tmp: 
                            dis[i] = dis[j]
                            break
                        j -= 1
                    while i < j:
                        if dis[i] > tmp:
                            dis[j] = dis[i]
                            break
                        i += 1
                dis[i] = tmp
                quick_sort(dis, start, i-1)
                quick_sort(dis, i+1, end)
            return dis

        dis = quick_sort(dis, 0, len(dis) - 1)

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:

输入: s = “rat”, t = “car”
输出: false
说明: 你可以假设字符串只包含小写字母。

进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

题目意思就是看看这两个字符串里是不是每个字母个数都一样多，可以排序之后一个个对比
我用的建字典，这里主要是看了评论，觉得这个建字典方法真的很优雅很pythonic哇~~~

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        map_s, map_t = {}, {}
        for i in s:
            map_s[i] = map_s.get(i, 0) + 1
        for i in t:
            map_t[i] = map_t.get(i, 0) + 1
        return map_s == map_t  

349.两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]
示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]
说明:

输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。

对字典的get有点上瘾，然而还是和排序没有啥关系

class Solution(object):
    def intersection(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        map1 = {}
        res = []
        for i in nums1:
            map1[i] = map1.get(i, 0)
        for i in nums2:
            if i in map1:
                res.append(i)
        return set(res)
        ###只用一行的写法
        # return list(set(nums1) & set(nums2))

922. 按奇偶排序数组 II

给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。

对数组进行排序，以便当 A[i] 为奇数时，i 也是奇数；当 A[i] 为偶数时， i 也是偶数。

你可以返回任何满足上述条件的数组作为答案。

示例：

输入：[4,2,5,7]
输出：[4,5,2,7]
解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。

提示：

2 <= A.length <= 20000
A.length % 2 == 0
0 <= A[i] <= 1000

和排序并没有啥关系
思想就是用栈的方法，奇数栈和偶数栈，然后再依次pop出来

class Solution(object):
    def sortArrayByParityII(self, A):
        """
        :type A: List[int]
        :rtype: List[int]
        """
        map_odd, map_even = [], []
        for i in A:
            if i % 2 == 0:
                map_even.append(i)
            else:
                map_odd.append(i)
        res = []
        for i in range(0, len(A), 2):
            res.append(map_even.pop())
            res.append(map_odd.pop())
        return res

976. 三角形的最大周长

给定由一些正数（代表长度）组成的数组 A，返回由其中三个长度组成的、面积不为零的三角形的最大周长。

如果不能形成任何面积不为零的三角形，返回 0。

示例 1：

输入：[2,1,2]
输出：5
示例 2：

输入：[1,2,1]
输出：0
示例 3：

输入：[3,2,3,4]
输出：10
示例 4：

输入：[3,6,2,3]
输出：8

提示：

3 <= A.length <= 10000
1 <= A[i] <= 10^6

这里就是个数学证明题，对于一个由小到大排列的数组中的数[a,b,c] (a<b<c)来说，如果a+b<=c的话，小于a,b的数一定不可能和c组成三角形，且倒序搜索时，第一个能满足条件的三个数一定是周长最大的三角形
我下次一定好好考虑手撸排序算法1551，sort()害人……

class Solution(object):
    def largestPerimeter(self, A):
        """
        :type A: List[int]
        :rtype: int
        """
        A.sort()
        for i in range(len(A)-1, 1, -1):
            if A[i-2] + A[i-1] > A[i]: 
                return A[i-2] + A[i-1] + A[i]
        return 0 

1030. 距离顺序排列矩阵单元格

给出 R 行 C 列的矩阵，其中的单元格的整数坐标为 (r, c)，满足 0 <= r < R 且 0 <= c < C。

另外，我们在该矩阵中给出了一个坐标为 (r0, c0) 的单元格。

返回矩阵中的所有单元格的坐标，并按到 (r0, c0) 的距离从最小到最大的顺序排，其中，两单元格(r1, c1) 和 (r2, c2)之间的距离是曼哈顿距离，|r1 - r2| + |c1 - c2|。（你可以按任何满足此条件的顺序返回答案。）

示例 1：

输入：R = 1, C = 2, r0 = 0, c0 = 0
输出：[[0,0],[0,1]]
解释：从 (r0, c0)到其他单元格的距离为：[0,1]
示例 2：

输入：R = 2, C = 2, r0 = 0, c0 = 1
输出：[[0,1],[0,0],[1,1],[1,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2] [[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。
示例 3：

输入：R = 2, C = 3, r0 = 1, c0 = 2
输出：[[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
解释：从 (r0, c0)到其他单元格的距离为：[0,1,1,2,2,3] 其他满足题目要求的答案也会被视为正确，例如[[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]。

提示：

1 <= R <= 100
1 <= C <= 100
0 <= r0 < R
0 <= c0 < C

维护一个列表，记录距离
维护一个字典，记录同一个距离的点的坐标
然后遍历字典输出

class Solution(object):
    def allCellsDistOrder(self, R, C, r0, c0):
        """
        :type R: int
        :type C: int
        :type r0: int
        :type c0: int
        :rtype: List[List[int]]
        """
        dis = []
        dis_map = {}
        for i in range(R):
            for j in range(C):
                d = abs(i-r0) + abs(j-c0)
                if d not in dis_map: 
                    dis.append(d)
                    dis_map[d] = []
                dis_map[d].append([i, j])
        dis.sort()
        res = []
        for i in dis:
            p = dis_map[i]
            for item in p:
                res.append(item)
        return res