Python 在排序列表中存储元素的最佳方式

你按照敌人难度的递减顺序维护一个敌人列表的数组，也就是说，最困难的bug将是数组的第一个元素。最初，代码中没有bug。您被赋予N个任务

输入格式：

def get_index(a, v):
    lo = 0
    hi = len(a)
    if not a:
        return 0
    else:
        while lo < hi:
            mid = (lo+hi)//2
            if a[mid] > v:
                lo = mid+1 
            else: 
                hi = mid                
        return hi

t = int(input())

arr = []
for _ in range(t):
    op = input().split()
    if len(op) == 2:
        index = get_index(arr, int(op[1]))
        arr.insert(index, int(op[1]))
    elif len(arr) < 3:
        print("Not enough enemies")
    else:
        print(arr[(len(arr)//3)-1])

第一行包含一个整数N，表示任务数

接下来的N行包含下面提到的两种类型的操作之一

1 p：在数组a中添加一个难度为p的bug

2：按降序排序数组，并打印排序数组中

（n/3）th

错误的难度，其中n是数组A的大小。如果错误数小于3，则打印的数量不足

代码：

def get_index(a, v):
    lo = 0
    hi = len(a)
    if not a:
        return 0
    else:
        while lo < hi:
            mid = (lo+hi)//2
            if a[mid] > v:
                lo = mid+1 
            else: 
                hi = mid                
        return hi

t = int(input())

arr = []
for _ in range(t):
    op = input().split()
    if len(op) == 2:
        index = get_index(arr, int(op[1]))
        arr.insert(index, int(op[1]))
    elif len(arr) < 3:
        print("Not enough enemies")
    else:
        print(arr[(len(arr)//3)-1])

def get_索引（a，v）：
lo=0
hi=len（a）
如果不是：
返回0
其他：
当lov：
lo=mid+1
其他：
高=中
回电
t=int（输入（））
arr=[]
对于范围（t）内的uu：
op=input（）.split（）
如果len（op）==2：
索引=获取索引（arr，int（op[1]））
arr.insert（索引，int（op[1]））
elif len（arr）<3：
打印（“没有足够的敌人”）
其他：
打印（arr[（len（arr）//3）-1]）

限制条件：

为#输入17获取超过时间限制的错误（可能是一个大输入）。来自哈克瑞斯

---

如何为大输入优化代码？

针对一些算法改进，如惰性排序或。

针对一些算法改进，如惰性排序或。

似乎是使用Python标准库在添加到列表时保持排序顺序而不需要额外代码的理想情况

查看源问题，提问者：

需要澄清的是，如果句号是要在结尾处打印的，那就不够了。。。绳子

需要提到整数除法，即Python中的/，而不是/

代码 我决定不使用stdin，这是留给您的练习，但是下面的代码给出了预期的输出。（不过，您可能需要进一步测试它）

他们不会说是否允许他们偷偷摸摸，在初始输入行数之外添加额外的输入行。我决定只读规定的行数-多余的被忽略

#-*-编码：utf-8-*-
"""
https://stackoverflow.com/questions/66525537/optimal-way-to-store-an-element-in-a-sorted-list/66527881#66527881
https://www.hackerearth.com/practice/algorithms/searching/binary-search/practice-problems/algorithm/victory-over-power-4a0cb459/
https://docs.python.org/3/library/heapq.html
创建于2021年3月8日星期一10:20:29
@作者：Paddy3118
"""
从heapq导入heapify、heappush、heappop、NLAGEST、nsmallest
inp=“”10
1 1
1 7
2.
1 9
1 21
1 8
1 5
2.
1 9
2“.strip（）.split（“\n”）
inp_gen=（inp中的行的line.strip（））
行计数=int（下一个（inp\u gen））
h=[]
希皮菲（h）
对于范围内的n（行计数）：#忽略额外行
行=下一行（inp\U gen）
field=[int（n）表示行中的n.split（）]
如果字段[0]==1：
heappush（h，字段[1]）
其他：
如果（lh:=len（h））<3：
打印（'没有足够的敌人'）
其他：
打印（最大（左侧//3，h）[-1]）

似乎是使用Python标准库在添加到列表时保持排序顺序的理想情况，而不需要额外的代码

查看源问题，提问者：

需要澄清的是，如果句号是要在结尾处打印的，那就不够了。。。绳子

需要提到整数除法，即Python中的/，而不是/

代码 我决定不使用stdin，这是留给您的练习，但是下面的代码给出了预期的输出。（不过，您可能需要进一步测试它）

他们不会说是否允许他们偷偷摸摸，在初始输入行数之外添加额外的输入行。我决定只读规定的行数-多余的被忽略

#-*-编码：utf-8-*-
"""
https://stackoverflow.com/questions/66525537/optimal-way-to-store-an-element-in-a-sorted-list/66527881#66527881
https://www.hackerearth.com/practice/algorithms/searching/binary-search/practice-problems/algorithm/victory-over-power-4a0cb459/
https://docs.python.org/3/library/heapq.html
创建于2021年3月8日星期一10:20:29
@作者：Paddy3118
"""
从heapq导入heapify、heappush、heappop、NLAGEST、nsmallest
inp=“”10
1 1
1 7
2.
1 9
1 21
1 8
1 5
2.
1 9
2“.strip（）.split（“\n”）
inp_gen=（inp中的行的line.strip（））
行计数=int（下一个（inp\u gen））
h=[]
希皮菲（h）
对于范围内的n（行计数）：#忽略额外行
行=下一行（inp\U gen）
field=[int（n）表示行中的n.split（）]
如果字段[0]==1：
heappush（h，字段[1]）
其他：
如果（lh:=len（h））<3：
打印（'没有足够的敌人'）
其他：
打印（最大（左侧//3，h）[-1]）

此问题最简单有效的解决方案使用两个堆：最高n/3个元素的最小堆，其余（较低）元素的最大堆

添加项时，需要将其与高堆中的min元素进行比较。如果较大，则将其放入高堆，如果较小，则将其放入低堆

然后，如有必要，在堆之间移动一个元素，以使n/3个元素保持在高堆中

add操作需要O（logn）时间，并且N/3元素始终作为高堆中的最小元素立即可用。

此问题的最简单有效解决方案使用两个堆：最高N/3元素的最小堆，其余（较低）元素的最大堆

添加项时，需要将其与高堆中的min元素进行比较。如果较大，则将其放入高堆，如果较小，则将其放入低堆

然后，移动