Проблема с оптимизацией кода

def qwer():
    Q=list(map(int, input().split()))
    A=list(map(int, input().split()))
    N=Q[0]
    K=Q[1]
    maxv=0
    for i in range(N):
        for j in range(N):
            if i+j>=K:
                if maxv<A[i]+A[j] and i>j:
                    maxv=A[i]+A[j]
                    q=i+1
                    w=j+1
    print(str(min(q,w))+' '+str(max(q,w)))
    
qwer()

  for i in range(N):
        for j in range(i+k+1,N):

if i-j>=K:

def task(n: int, k: int, cells: list) -> (int, int):
    result, price = [0, 0], 0
    for i in range(n):
        for j in range(i + k + 1, n):
            if cells[i] + cells[j] > price:
                result, price = [i + 1, j + 1], cells[i] + cells[j]
    return result

n, k = map(int, input().split())
*a, = map(int, input().split())
m1 = i1 = 0
m2 = i2 = 0
k += 1
for i in range(k, n):
    #m1 = max(m1 , a[i-k])
    if a[i-k] > m1:  # строго больше чтобы левее
        m1 = a[i-k]
        i1 = i-k
    #m2 = max(m2, m1 + a[i])
    if m1 + a[i] > m2:  # строго больше чтобы левее
        m2 = m1 + a[i]
        i2 = i
print(m2)
print(i1+1, i2+1)

def argsort(seq, descending=False):
    return sorted(range(len(seq)), key=seq.__getitem__,reverse=descending)
 
 
def rob(arr:list, k:int) -> (int,int):
    len_a = len(arr)
    # список отсортированных индексов
    index = argsort(arr, descending=True)
   
    i,j = 0,1
    first = index[i] # очевидно, что здесь индекс самой дорогой ячейки
    while j < len_a-1:
        # смотрим направо пока не встретим ближайшую 
        # разрешенную ячейку; она и будет вторым нашим максимумом
        if abs(index[i] - index[j]) > k:
            second = index[j]
            break
        j += 1
            
    if first > second:
        first, second = second, first
    
    return  first + 1, second + 1

arr = [random.randint(1,100000) for _ in range(1000)]

idx = rob3(arr,2)
print(idx)
print(arr[idx[0]], arr[idx[1]])

idx = rob(arr,2)
print(idx)
print(arr[idx[0]], arr[idx[1]])

max(arr)

list(enumerate(arr[260:281], 260))

a = sorted(arr,reverse=True)
a[0],a[1]

first = index[i] # индекс самой дорогой ячейки
second = index[j] # индекс второй по ценности ячейки

def rob(n,k):
    
    a = [0]  * n
    p = [0]  * n
    s = [0]  * n
    
    i, j = 0, 0
    # здесь у чувака происходит ввод списка ячеек и какая-то дополнительная магия
    for i in range(n):
        a[i] = int(input('>>'))
        if (a[i] > a[j]):
            p[i] = i
            j = i
        else: 
            p[i] = p[j]
        
    
    i = n-1
    j = n-1
    
    #print(a)
    #print(p)
    
    while i >= 0:
        if (a[i] >= a[j]):
            s[i] = i 
            j = i
        else:
            s[i] = s[j]
        i -= 1    
    
    m = 0 
    l = 0 
    r = k + 1
    i = l
    j = r
    while j < n:
        t = a[p[i]] + a[s[j]]
        
        if (t > m):
            l = p[i]
            r = s[j] 
            m = t
        i += 1
        j += 1
    return l+1, r+1

def rob_1(a, k):
    n = len(a)
    p = [0] * n
    s = [0] * n
    
    i, j = 0, 0
    
    for i in range(n):
        if (a[i] > a[j]):
            p[i] = i
            j = i
        else: 
            p[i] = p[j]
        
    
    j = n - 1
    for i in range(n - 1, -1, -1):
        if (a[i] >= a[j]):
                s[i] = i
                j = i
        else:
            s[i] = s[j]     
       
    m, l, r = 0, 0, k + 1
    i = l
    
    for j in range(r, n):
        t = a[p[i]] + a[s[j]]
        if t > m:
            l = p[i]
            r = s[j]
            m = t
        i += 1
 
    return l, r   # +1 к индексам добавьте сами если нужно