python

1.根据身高，体重，编号从小到大排序

eg：

编号：[1,2,3,4]

身高：[100,90,110,100]

体重：[30,35,50,30]

输出：2 1 4 3

def sort_student(h,w):
    dict_ = {}
    l = len(h)
    for i in range(l):
        t = (h[i],w[i])
        dict_[t]=dict_.get(t,[])+[i]
    ret = []
    for k in sorted(dict_.keys()):
        ret.extend(sorted(dict_[k]))
    return ret
    

2.435. 无重叠区间

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        l = len(intervals)
        if l == 0:
            return 0
        intervals = sorted(intervals,key=lambda x:x[1])
        ret = l
        c = 1
        right = intervals[0][1]
        for i in range(1,l):
            if intervals[i][0] >= right:
                c+=1
                right = intervals[i][1]
        return ret - c

备注:区间元素排序示例全集

# 1.数组第一个元素升序，第二个元素也升序（sort/sorted默认行为）
arr = [[1,2],[1,1],[2,2],[2,5],[-1,3],[-2,5]]
arr.sort()
print(arr)
'''
[[-2, 5], [-1, 3], [1, 1], [1, 2], [2, 2], [2, 5]]
'''
arr = [[1,2],[1,1],[2,2],[2,5],[-1,3],[-2,5]]
arr = sorted(arr)
print(arr)
'''
[[-2, 5], [-1, 3], [1, 1], [1, 2], [2, 2], [2, 5]]
'''


# 2.reverse正好相反
arr = [[1,2],[1,1],[2,2],[2,5],[-1,3],[-2,5]]
arr = sorted(arr, reverse=True)
print(arr)
'''
[[2, 5], [2, 2], [1, 2], [1, 1], [-1, 3], [-2, 5]]
'''


# 3.数组第一个元素升序，第二个元素降序
arr = [[-52, 31], [-73, -26], [66, 97], [-65, -11], [-31, 49], [66, 98], [-63, 2]]
arr.sort(key=lambda x: (x[0], -x[1]))
print(arr)
'''
[[-73, -26], [-65, -11], [-63, 2], [-52, 31], [-31, 49], [66, 98], [66, 97]]
'''

arr = [[-52, 31], [-73, -26], [66, 97], [-65, -11], [-31, 49], [66, 98], [-63, 2]]
arr = sorted(arr, key=lambda x: (x[0], -x[1]))
print(arr)
'''
[[-73, -26], [-65, -11], [-63, 2], [-52, 31], [-31, 49], [66, 98], [66, 97]]
'''


# 4.数组第二个元素升序
arr = [[-52, 31], [-73, -26], [82, 97], [-65, -11], [-31, 49], [66, 98], [-63, 2]]
arr.sort(key=lambda x: x[1])
print(arr)
'''
[[-73, -26], [-65, -11], [-63, 2], [-52, 31], [-31, 49], [82, 97], [66, 98]]
'''

arr = [[-52, 31], [-73, -26], [82, 97], [-65, -11], [-31, 49], [66, 98], [-63, 2]]
arr = sorted(arr, key=lambda x: x[1])
print(arr)
'''
[[-73, -26], [-65, -11], [-63, 2], [-52, 31], [-31, 49], [82, 97], [66, 98]]
'''


# 5.数组第二个元素降序
arr = [[-52, 31], [-73, -26], [82, 97], [-65, -11], [-31, 49], [66, 98], [-63, 2]]
arr.sort(key=lambda x: -x[1])
print(arr)
'''
[[66, 98], [82, 97], [-31, 49], [-52, 31], [-63, 2], [-65, -11], [-73, -26]]
'''

arr = [[-52, 31], [-73, -26], [82, 97], [-65, -11], [-31, 49], [66, 98], [-63, 2]]
arr = sorted(arr, key=lambda x: -x[1])
print(arr)
'''
[[66, 98], [82, 97], [-31, 49], [-52, 31], [-63, 2], [-65, -11], [-73, -26]]
'''

3.452. 用最少数量的箭引爆气球

与435相似，使用第二个元素升序排序，只要第一个元素<=right，则必有重合，反之则无重合。

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
        l = len(points)
        if l<=1:
            return l
        points = sorted(points, key=lambda x:x[1])
        ret = 1
        right = points[0][1]
        for i in range(1,l):
            if points[i][0] > right:
                right = points[i][1]
                ret+=1
        return ret

4.56. 合并区间

备注：主要还是确定排序规则和l.r的更新规则

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        l = len(intervals)
        if l <= 1:
            return intervals
        ret = []
        intervals = sorted(intervals)
        left = intervals[0][0]
        right = intervals[0][1]
        for i in range(1,l):
            if intervals[i][0] > right:
                ret.append([left,right])
                left = intervals[i][0]
                right = intervals[i][1]
            else:
                left = min(left,intervals[i][0])
                right = max(right,intervals[i][1])
        ret.append([left,right])
        return ret