message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES | instruction | 0 | 89,406 | 12 | 178,812 |
Tags: dfs and similar, sortings
Correct Solution:
```
#### Using DSU..... best time complexity
def find(x):
while(x != link[x]):
link[x] = link[link[x]]
x = link[x]
return x
def union(x, y):
x = find(x)
y = find(y)
if x != y:
if size[x] > size[y]:
size[x] += size[y]
link[y] = x
else:
size[y] += size[x]
link[x] = y
for _ in range(int(input())):
n,m = list(map(int, input().split()))
array = list(map(int, input().split()))
piss = list(map(int, input().split()))
for i in range(n):
array[i] = (array[i], i)
array.sort()
link = list(range(n))
size = [1]*n
for i in piss:
union(i-1, i)
flag = True
for i in range(n):
if find(i) != find(array[i][1]):
flag = False
break
if flag:
print('YES')
else:
print('NO')
``` | output | 1 | 89,406 | 12 | 178,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES | instruction | 0 | 89,407 | 12 | 178,814 |
Tags: dfs and similar, sortings
Correct Solution:
```
# import sys
# sys.stdin = open("input.in","r")
# sys.stdout = open("output.out","w")
from collections import defaultdict
t = int(input())
for i in range(t):
n,m = map(int,input().split())
a = list(map(int,input().split()))
p = list(map(int,input().split()))
p = [p[j]-1 for j in range(m)]
r = sorted(a)
d = set()
for j in p:
d.add(j)
flag = 0
for j in range(n):
z = a[j:].index(r[j])
z = z + j
if z > j:
for k in range(z,j,-1):
if k-1 in d:
a[k-1],a[k] = a[k],a[k-1]
else:
flag = 1
break
else:
for k in range(j,z,-1):
if k-1 in d:
a[k-1],a[k] = a[k],a[k-1]
else:
flag = 1
break
if flag == 1:
break
if flag == 1:
print("NO")
else:
print("YES")
``` | output | 1 | 89,407 | 12 | 178,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES | instruction | 0 | 89,408 | 12 | 178,816 |
Tags: dfs and similar, sortings
Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
t=II()
for _ in range(t):
n,m=MI()
aa=LI()
pp=LI1()
bb=[]
cur=[]
for p in sorted(pp):
if not cur:
if p>0:bb+=aa[:p]
cur=[p]
elif p==cur[-1]+1:
cur.append(p)
else:
bb+=sorted(aa[cur[0]:cur[-1]+2])
bb+=aa[cur[-1]+2:p]
cur=[p]
bb+=sorted(aa[cur[0]:cur[-1]+2])
bb+=aa[cur[-1]+2:]
aa.sort()
if aa==bb:print("YES")
else:print("NO")
main()
``` | output | 1 | 89,408 | 12 | 178,817 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES | instruction | 0 | 89,409 | 12 | 178,818 |
Tags: dfs and similar, sortings
Correct Solution:
```
from collections import defaultdict
t = int(input().strip())
class Graph:
def __init__(self, V):
self.V = V+1
self.edges = defaultdict(list)
def addEdge(self, u, v):
if v not in self.edges[u]:
self.edges[u].append(v)
def DFS(self, source, destination):
visited = [False]*self.V
stack = []
stack.append(source)
while (len(stack)):
s = stack.pop()
if s == destination:
return True
if (not visited[s]):
visited[s] = True
for node in self.edges[s]:
if (not visited[node]):
stack.append(node)
return False
for _ in range(t):
n, m = list(map(int, input().strip().split()))
arr_n = list(map(int, input().strip().split()))
arr = list(zip(arr_n, range(1, n+1)))
arr.sort()
arr_m = list(map(int, input().strip().split()))
arr_m.sort()
g = Graph(n)
for i in range(m):
j = arr_m[i]
g.addEdge(j,j+1)
g.addEdge(j+1,j)
# print(g.edges)
for i in range(n):
if not g.DFS(i+1,arr[i][1]):
print("NO")
break
else:
print("YES")
``` | output | 1 | 89,409 | 12 | 178,819 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES | instruction | 0 | 89,410 | 12 | 178,820 |
Tags: dfs and similar, sortings
Correct Solution:
```
for i in range(int(input())):
n,m = map(int,input().split())
arr1 = list(map(int,input().split()))
arr2 = list(map(int,input().split()))
sorted(arr2)
for k in range(n):
for j in arr2:
if arr1[j-1]>arr1[j]:
arr1[j-1],arr1[j]=arr1[j],arr1[j-1]
if arr1 ==sorted(arr1):
print("YES")
else:
print("NO")
``` | output | 1 | 89,410 | 12 | 178,821 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES | instruction | 0 | 89,411 | 12 | 178,822 |
Tags: dfs and similar, sortings
Correct Solution:
```
t = int(input())
for _ in range(t):
n, m = [int(i) for i in input().split()]
arr = [int(i) for i in input().split()]
p = [int(i) for i in input().split()]
p.sort()
i = 0
while i < m:
temp = p[i]
k = i+1
while k < m:
if p[k] != temp+1:
break
else:
temp = p[k]
k += 1
arr[p[i]-1:p[k-1]+1] = sorted(arr[p[i]-1:p[k-1]+1])
i = k
if arr == sorted(arr):
print("YES")
else:
print("NO")
``` | output | 1 | 89,411 | 12 | 178,823 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES | instruction | 0 | 89,412 | 12 | 178,824 |
Tags: dfs and similar, sortings
Correct Solution:
```
# import sys
# sys.stdin=open('input.txt', 'r')
# sys.stdout=open('output.txt', 'w')
n=int(input())
for i in range(n):
n, m=[int(k) for k in input().split()]
a=[int(k) for k in input().split()]
p=[int(k)-1 for k in input().split()]
sor=sorted(a)
can=None
ori=list(a)
ant=list(a)
while a!=sor:
for j in range(len(p)):
if a[p[j]]>a[p[j]+1]:
aux=a[p[j]]
a[p[j]]=a[p[j]+1]
a[p[j]+1]=aux
if a==sor: break
if a==sor:
can=True
break
if a==ori:
can=False
break
if ant==a:
can=False
break
else: ant=list(a)
if a==sor: can=True
if can: print('YES')
else: print('NO')
``` | output | 1 | 89,412 | 12 | 178,825 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES | instruction | 0 | 89,413 | 12 | 178,826 |
Tags: dfs and similar, sortings
Correct Solution:
```
for t in range(int(input())):
n,m=map(int,input().split())
a=list(map(int,input().split()))
p=list(map(int,input().split()))
mark=True
for i in range(n):
for j in range(n-i-1):
if a[j]>a[j+1]:
if j+1 in p:
a[j],a[j+1]=a[j+1],a[j]
else:
mark=False
break
if mark==False:
print("NO")
else:
print("YES")
``` | output | 1 | 89,413 | 12 | 178,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES
Submitted Solution:
```
t = int(input())
for i in range(t):
n, m = map(int,input().split())
a = list(map(int,input().split()))
p = list(map(int,input().split()))
b = sorted(a)
f = 0
for k in range(n):
for j in range(n-k-1):
if (a[j] > a[j+1] and (j+1) in p):
tmp = a[j]
a[j] = a[j+1]
a[j+1] = tmp
if(b == a):
print('YES')
else:
print('NO')
``` | instruction | 0 | 89,414 | 12 | 178,828 |
Yes | output | 1 | 89,414 | 12 | 178,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES
Submitted Solution:
```
te = int(input())
while te > 0:
te -= 1
x, y = list(map(int, input().split()))
numbers = list(map(int, input().split()))
positions = list(map(int, input().split()))
pos = [0]*x
for i in positions:
pos[i-1] = 1
# print(pos)
while True:
ok = False
for j in range(x-1):
if pos[j] == 1 and numbers[j] > numbers[j+1]:
ok = True
a = numbers[j]
numbers[j] = numbers[j+1]
numbers[j+1] = a
if not ok:
break
# print(numbers)
ok = True
for i in range(x-1):
ok &= numbers[i] <= numbers[i+1]
if ok:
print('Yes')
else:
print('No')
``` | instruction | 0 | 89,415 | 12 | 178,830 |
Yes | output | 1 | 89,415 | 12 | 178,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES
Submitted Solution:
```
def go():
n, m = map(int, input().split())
a = list(map(int, input().split()))
p = sorted(map(int, input().split()))
sa = sorted(a)
i = 0
pp = 0
while i < n:
j = i
while j < n and pp < m and p[pp] - 1 == j:
j += 1
pp += 1
if sorted(a[i:j + 1]) != sa[i:j + 1]:
return 'NO'
i = j + 1
return 'YES'
t = int(input())
ans = []
for _ in range(t):
ans.append(str(go()))
print('\n'.join(ans))
``` | instruction | 0 | 89,416 | 12 | 178,832 |
Yes | output | 1 | 89,416 | 12 | 178,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES
Submitted Solution:
```
for _ in range(int(input())):
n, m = map(int ,input().split())
a = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
for i in range(n):
for j in p:
if (a[j-1] > a[j]):
a[j-1], a[j] = a[j], a[j-1]
if a != sorted(a):
print("NO")
else:
print("YES")
``` | instruction | 0 | 89,417 | 12 | 178,834 |
Yes | output | 1 | 89,417 | 12 | 178,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES
Submitted Solution:
```
def main():
t = int(input())
for query in range(t):
N, M = (int(i) for i in input().split())
par = [i for i in range(105)]
rank = [0 for i in range(105)]
def find_root(x):
if par[x] == x:
return x
else:
par[x] = find_root(par[x])
return par[x]
def is_same_group(x, y):
return find_root(x) == find_root(y)
def unite(x, y):
x = find_root(x)
y = find_root(y)
if x == y:
return
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
A = [int(i) for i in input().split()]
P = [int(i) for i in input().split()]
for p in P:
unite(p, p+1)
pre = A[0]
for i, a in enumerate(A):
if is_same_group(i+1, a) or pre <= a:
pre = a
continue
else:
print("NO")
break
else:
print("YES")
if __name__ == '__main__':
main()
``` | instruction | 0 | 89,418 | 12 | 178,836 |
No | output | 1 | 89,418 | 12 | 178,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES
Submitted Solution:
```
for _ in range(int(input())):
n,m = map(int,input().split())
a = list(map(int,input().split()))
p = list(map(int,input().split()))
d = {}
for i in range(len(a)):
x = i+1
if x in p:
d[i] = i+1
else:
d[i] = i
o = a.copy()
o.sort()
o = o[::-1]
i = 0
c = len(a)-1
w = 0
while(i < len(o)):
x = o[i]
ei = a.index(x)
#print(ei)
f = 0
while(ei != c and f == 0):
z = d[ei]
if z >= c:
ei = c
break
if (ei == z):
f = 1
else:
ei = z
if ei == c:
#print("Y")
c = c-1
else:
w = 1
break
i = i+1
if w == 1:
print("NO")
else:
print("YES")
``` | instruction | 0 | 89,419 | 12 | 178,838 |
No | output | 1 | 89,419 | 12 | 178,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES
Submitted Solution:
```
t=int(input())
for _ in range(t):
n,m=[int(x) for x in input().split()]
a=[int(x) for x in input().split()]
b=[int(x) for x in input().split()]
j=0
while(j<(n-1)):
if(a[j]>a[j+1]):
if(j+1 in b):
temp=a[j+1]
a[j+1]=a[j]
a[j]=temp
else:
break
j+=1
if(j==len(a)-1):
print('YES')
else:
print('NO')
``` | instruction | 0 | 89,420 | 12 | 178,840 |
No | output | 1 | 89,420 | 12 | 178,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n.
You are also given a set of distinct positions p_1, p_2, ..., p_m, where 1 ≤ p_i < n. The position p_i means that you can swap elements a[p_i] and a[p_i + 1]. You can apply this operation any number of times for each of the given positions.
Your task is to determine if it is possible to sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps.
For example, if a = [3, 2, 1] and p = [1, 2], then we can first swap elements a[2] and a[3] (because position 2 is contained in the given set p). We get the array a = [3, 1, 2]. Then we swap a[1] and a[2] (position 1 is also contained in p). We get the array a = [1, 3, 2]. Finally, we swap a[2] and a[3] again and get the array a = [1, 2, 3], sorted in non-decreasing order.
You can see that if a = [4, 1, 2, 3] and p = [3, 2] then you cannot sort the array.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Then t test cases follow. The first line of each test case contains two integers n and m (1 ≤ m < n ≤ 100) — the number of elements in a and the number of elements in p. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). The third line of the test case contains m integers p_1, p_2, ..., p_m (1 ≤ p_i < n, all p_i are distinct) — the set of positions described in the problem statement.
Output
For each test case, print the answer — "YES" (without quotes) if you can sort the initial array in non-decreasing order (a_1 ≤ a_2 ≤ ... ≤ a_n) using only allowed swaps. Otherwise, print "NO".
Example
Input
6
3 2
3 2 1
1 2
4 2
4 1 2 3
3 2
5 1
1 2 3 4 5
1
4 2
2 1 4 3
1 3
4 2
4 3 2 1
1 3
5 2
2 1 2 3 3
1 4
Output
YES
NO
YES
YES
NO
YES
Submitted Solution:
```
t=int(input())
while(t!=0):
t-=1
n,m=map(int,input().split())
a=list(map(int,input().split()))
p=list(map(int,input().split()))
v=[]
for i in range(n-1):
if a[i+1]<a[i]:
v.append(i+1)
ans=True
for i in v:
if i not in p:
ans=False
break
if ans:
print("YES")
else:
print("NO")
``` | instruction | 0 | 89,421 | 12 | 178,842 |
No | output | 1 | 89,421 | 12 | 178,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}. | instruction | 0 | 89,471 | 12 | 178,942 |
Tags: brute force, math, number theory, sortings
Correct Solution:
```
import math as m
n = int(input())
x = list(map(int, input().split()))
x.sort()
a = m.floor(x[n-1]**(1/(n-1)))
b = 0
c = 0
for i in range(len(x)):
b += abs(x[i] - a**i)
for i in range(len(x)):
c += abs(x[i] - (a+1)**i)
print(min(c,b))
``` | output | 1 | 89,471 | 12 | 178,943 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}. | instruction | 0 | 89,472 | 12 | 178,944 |
Tags: brute force, math, number theory, sortings
Correct Solution:
```
import sys
import collections as cc
import random as rd
import math as mt
input = sys.stdin.readline
I = lambda : cc.deque(map(int,input().split()))
n,=I()
l=sorted(I())
if n==2:
print(l[0]-1)
sys.exit()
ans=sum(l)-n
for i in range(2,40000):
now=0
mul=1
for j in range(n):
now+=abs(mul-l[j])
if now >ans:
break
mul*=i
ans=min(now,ans)
print(ans)
``` | output | 1 | 89,472 | 12 | 178,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}. | instruction | 0 | 89,473 | 12 | 178,946 |
Tags: brute force, math, number theory, sortings
Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
a.sort()
inf = 10**18
if n <= 2:
print(a[0] - 1)
else:
ans = sum(a) - n
for x in range(1, 10**9):
curPow = 1
curCost = 0
for i in range(n):
curCost += abs(a[i] - curPow)
curPow *= x
if curPow > inf:
break
if curPow > inf:
break
# if curPow / x > ans + a[n - 1]:
# break
ans = min(ans, curCost)
print(ans)
``` | output | 1 | 89,473 | 12 | 178,947 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}. | instruction | 0 | 89,474 | 12 | 178,948 |
Tags: brute force, math, number theory, sortings
Correct Solution:
```
n = int(input())
A = [int(i) for i in input().split()]
A = sorted(A)
m=int(pow(A[-1],1/(n-1)))
_=0
x,y=0,0
for _ in range(n):
u=pow(m,_)
x+=abs(u-A[_])
for _ in range(n):
v=pow(m+1,_)
y+=abs(v-A[_])
print(min(x,y))
``` | output | 1 | 89,474 | 12 | 178,949 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}. | instruction | 0 | 89,475 | 12 | 178,950 |
Tags: brute force, math, number theory, sortings
Correct Solution:
```
import math
n=int(input())
a=list(map(int,input().split()))
a.sort()
max_r= int(math.ceil(pow(10,9/(n-1))))
lst=[]
for r in range(1,max_r+1):
cost=0
for i in range(n):
if a[i]!=pow(r,i):
cost+= abs(pow(r,i)-a[i])
lst.append(cost)
print(min(lst))
``` | output | 1 | 89,475 | 12 | 178,951 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}. | instruction | 0 | 89,476 | 12 | 178,952 |
Tags: brute force, math, number theory, sortings
Correct Solution:
```
import math
def calc(a,b):
s=0
for i in range(len(a)):
s+=abs(a[i]-b**i)
return s
n=int(input())
a=list(map(int,input().split()))
a.sort()
b=int(a[-1]**(1/(n-1)))
m=calc(a,b)
for i in range(1,10000):
mt=calc(a,b+i)
if mt<=m:
m=mt
else:
break
for i in range(b,0,-1):
mt=calc(a,i)
if mt<=m:
m=mt
else:
break
print(m)
``` | output | 1 | 89,476 | 12 | 178,953 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}. | instruction | 0 | 89,477 | 12 | 178,954 |
Tags: brute force, math, number theory, sortings
Correct Solution:
```
import sys
import time
# IO region
FIO = 10
def I(): return input()
def Iint(): return int(input())
def Ilist(): return list(map(int, input().split())) # int list
def Imap(): return map(int, input().split()) # int map
def Plist(li, s=' '): print(s.join(map(str, li))) # non string list
# /IO region
en = enumerate
def answer_debug(*args):
print('\033[31m', *args, '\033[0m', file=sys.stderr)
# answer(9)
def debug(*args):
print('\033[36m', *args, '\033[0m', file=sys.stderr)
if not FIO:
if __name__ == '__main__':
main()
exit()
else:
from io import BytesIO, IOBase
import os
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip("\r\n")
# endregion
def main():
n=int(input())
l=sorted(Ilist())
# l.sort()
ans=sum(l)-n
for i in range(2,10**5):
nn=0
for j in range(n):
nn+=abs(l[j]-i**j)
# print(l[j]-i**j)
if nn>=ans:
break
if nn<ans:
ans=nn
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 89,477 | 12 | 178,955 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}. | instruction | 0 | 89,478 | 12 | 178,956 |
Tags: brute force, math, number theory, sortings
Correct Solution:
```
from math import *
from collections import *
from random import *
from decimal import Decimal
from heapq import *
from bisect import *
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**5)
def lis():
return list(map(int,input().split()))
def ma():
return map(int,input().split())
def inp():
return int(input())
def st1():
return input().rstrip('\n')
t=1
def lo(n,x):
z=0
while(n):
n=n//x
z+=1
return z
while(t):
t-=1
n=inp()
a=lis()
a.sort()
co=1
ref=10**14
z=0
re=float('inf')
for i in range(1,100000):
#print(i)
if(i**n>ref):
break
z=0
co=1
#print(n)
for j in range(n):
z+=abs(co-a[j])
co=co*i
re=min(re,z)
print(re)
``` | output | 1 | 89,478 | 12 | 178,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}.
Submitted Solution:
```
import os
import heapq
import sys,threading
import math
import bisect
import operator
from collections import defaultdict
#sys.setrecursionlimit(10**5)
from io import BytesIO, IOBase
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
def power(x, p):
res = 1
while p:
if p & 1:
res = (res * x)
x = (x * x)
p >>= 1
return res
def inar():
return [int(k) for k in input().split()]
def lcm(num1,num2):
return (num1*num2)//gcd(num1,num2)
def main():
#t=int(input())
t=1
for _ in range(t):
n=int(input())
arr=inar()
arr.sort()
counter=0
cost=0
take=sum(arr)
for i in range(n):
cost+=abs(arr[i]-1)
# print(cost)
if n<=32:
c=0
for i in range(1,100000):
temp=0
c=0
for j in range(n):
if power(i,j)>10**10:
c=1
break
temp+=abs(arr[j]-power(i,j))
#print(temp)
if c==0:
cost=min(cost,temp)
print(cost)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
#threadin.Thread(target=main).start()
``` | instruction | 0 | 89,479 | 12 | 178,958 |
Yes | output | 1 | 89,479 | 12 | 178,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}.
Submitted Solution:
```
import math
n = int(input())
l = list(map(int,input().split()))
l.sort()
c1=math.ceil(l[-1]**(1/(n-1)))
c2=math.floor(l[-1]**(1/(n-1)))
dif1,dif2=0,0
for i in range(n):
dif1+=abs(c1**i-l[i])
for i in range(n):
dif2+=abs(c2**i-l[i])
print(min(dif1,dif2))
``` | instruction | 0 | 89,480 | 12 | 178,960 |
Yes | output | 1 | 89,480 | 12 | 178,961 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}.
Submitted Solution:
```
n=int(input())
arr=[int(i) for i in input().split()]
c=2
cutoff_cost=0
arr=sorted(arr)
for i in arr:
cutoff_cost+=abs(i-1)
ans=cutoff_cost
while c**(n-1) < cutoff_cost+arr[-1]:
tmpans=0
for j in range(n):
tmpans+=abs((c**j)-arr[j])
ans=min(ans,tmpans)
c+=1
print(ans)
``` | instruction | 0 | 89,481 | 12 | 178,962 |
Yes | output | 1 | 89,481 | 12 | 178,963 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}.
Submitted Solution:
```
n=int(input())
l = list(map(int, input().strip().split()))[:n]
l.sort()
f = sum(l) - n
cost = f
x = 2
while x**(n-1) < f + l[-1]:
currCost, p = 0, 1
for i in range(n):
currCost += abs(l[i] - p)
p*=x
cost = min(cost, currCost)
x += 1
print(cost)
``` | instruction | 0 | 89,482 | 12 | 178,964 |
Yes | output | 1 | 89,482 | 12 | 178,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}.
Submitted Solution:
```
import math
n=int(input())
a=list(map(int,input().split()))
a.sort()
last=a[-1]
first=a[0]
ans=9999999999999999
c1=math.ceil(math.exp(math.log(last)/(n-1)))
c2=math.ceil(math.exp(math.log(last)/(n-1)))
v1=0
v2=0
for i in range(len(a)):
v1+=abs(a[i]-c1**i)
v2+=abs(a[i]-c2**i)
print(min(v1,v2))
``` | instruction | 0 | 89,483 | 12 | 178,966 |
No | output | 1 | 89,483 | 12 | 178,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}.
Submitted Solution:
```
import sys
from math import ceil, floor
# Fast IO
def input():
a = sys.stdin.readline()
if a[-1] == "\n": a = a[:-1]
return a
def print(*argv):
n = len(argv)
for i in range(n):
if i == n-1: sys.stdout.write(str(argv[i]) + "\n")
else: sys.stdout.write(str(argv[i]) + " ")
def lcm(x, y):
from math import gcd
return (x * y) / (gcd(x, y))
def solve(n, lst):
lst = sorted(lst)
c = lst[-1] ** (1/(n-1))
if abs(ceil(c)**(n-1) - lst[-1]) <= abs(floor(c)**(n-1) - lst[-1]):
c = ceil(c)
else:
c = floor(c)
cnt = 0
for i in range(n):
cnt += abs(c**i - lst[i])
return cnt
n = int(input())
lst = list(map(int, input().split()))
print(solve(n, lst))
``` | instruction | 0 | 89,484 | 12 | 178,968 |
No | output | 1 | 89,484 | 12 | 178,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}.
Submitted Solution:
```
import os
import heapq
import sys,threading
import math
import operator
from collections import defaultdict,deque
from io import BytesIO, IOBase
sys.setrecursionlimit(10 ** 5)
threading.stack_size(2**27)
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
def pw(a,b):
result=1
while(b>0):
if(b%2==1): result*=a
a*=a
b//=2
return result
def inpt():
return [int(k) for k in input().split()]
def main():
n=int(input())
ar=inpt()
ar.sort()
sm=sum(ar)
tp=ar[0]-1
ans=10**26
p=1
lt=10**20
if(n>100):
ans=sm-n
print(ans)
else:
p=1
ans=2*lt
while(p<10**5+1):
val=pw(p,n-1)
temp =p
if(val>lt):
print(p)
break
val=p
mx=0
for i in range(1,n):
mx+=abs(val-ar[i])
val*=temp
ans=min(ans,mx)
p+=1
print(tp+ans)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
#threading.Thread(target=main).start()
``` | instruction | 0 | 89,485 | 12 | 178,970 |
No | output | 1 | 89,485 | 12 | 178,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a list of positive integers a_0, a_1, ..., a_{n-1} a power sequence if there is a positive integer c, so that for every 0 ≤ i ≤ n-1 then a_i = c^i.
Given a list of n positive integers a_0, a_1, ..., a_{n-1}, you are allowed to:
* Reorder the list (i.e. pick a permutation p of \{0,1,...,n - 1\} and change a_i to a_{p_i}), then
* Do the following operation any number of times: pick an index i and change a_i to a_i - 1 or a_i + 1 (i.e. increment or decrement a_i by 1) with a cost of 1.
Find the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Input
The first line contains an integer n (3 ≤ n ≤ 10^5).
The second line contains n integers a_0, a_1, ..., a_{n-1} (1 ≤ a_i ≤ 10^9).
Output
Print the minimum cost to transform a_0, a_1, ..., a_{n-1} into a power sequence.
Examples
Input
3
1 3 2
Output
1
Input
3
1000000000 1000000000 1000000000
Output
1999982505
Note
In the first example, we first reorder \{1, 3, 2\} into \{1, 2, 3\}, then increment a_2 to 4 with cost 1 to get a power sequence \{1, 2, 4\}.
Submitted Solution:
```
import math
from collections import deque
from sys import stdin, stdout
from string import ascii_letters
letters = ascii_letters
input = stdin.readline
#print = stdout.write
def calc(m):
bfres = 0
have = m
for i in range(1, n):
bfres += abs(have - arr[i])
have *= m
return bfres
n = int(input())
arr = sorted(map(int, input().split()))
res = arr[0] - 1
arr[0] = 1
right = int((1000000000**(1/(n - 1))))
rs = 99999999999999999
for i in range(1, right + 1):
rs = min(rs, calc(i))
print(res + rs)
``` | instruction | 0 | 89,486 | 12 | 178,972 |
No | output | 1 | 89,486 | 12 | 178,973 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11. | instruction | 0 | 89,487 | 12 | 178,974 |
Tags: data structures, divide and conquer, dp, greedy, implementation
Correct Solution:
```
import sys
import math
import collections
import bisect
import itertools
import decimal
import copy
import heapq
# import numpy as np
# sys.setrecursionlimit(10 ** 6)
INF = 10 **20
# MOD = 10 ** 9 + 7
MOD = 998244353
# ni = lambda: int(sys.stdin.readline().rstrip())
# ns = lambda: map(int, sys.stdin.readline().rstrip().split())
# na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
# na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))
# flush = lambda: sys.stdout.flush()
ni = lambda: int(sys.stdin.buffer.readline())
ns = lambda: map(int, sys.stdin.buffer.readline().split())
na = lambda: list(map(int, sys.stdin.buffer.readline().split()))
na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.buffer.readline().split()))
flush = lambda: sys.stdout.flush()
# ===CODE===
def main():
t = ni()
for _ in range(t):
n, q = ns()
a = [-INF] + na() + [-INF]
ans = 0
for i in range(1, n + 1):
if a[i - 1] < a[i] and a[i] > a[i + 1]:
ans += a[i]
elif a[i - 1] > a[i] and a[i] < a[i + 1]:
ans -= a[i]
print(ans)
for _ in range(q):
l, r = ns()
for li in range(l - 2, l + 3):
if 1 <= li <= n:
if a[li - 1] < a[li] and a[li] > a[li + 1]:
ans -= a[li]
elif a[li - 1] > a[li] and a[li] < a[li + 1]:
ans += a[li]
for ri in range(max(l + 3, r - 2), r + 3):
if 1 <= ri <= n:
if a[ri - 1] < a[ri] and a[ri] > a[ri + 1]:
ans -= a[ri]
elif a[ri - 1] > a[ri] and a[ri] < a[ri + 1]:
ans += a[ri]
a[l], a[r] = a[r], a[l]
for li in range(l - 2, l + 3):
if 1 <= li <= n:
if a[li - 1] < a[li] and a[li] > a[li + 1]:
ans += a[li]
elif a[li - 1] > a[li] and a[li] < a[li + 1]:
ans -= a[li]
for ri in range(max(l + 3, r - 2), r + 3):
if 1 <= ri <= n:
if a[ri - 1] < a[ri] and a[ri] > a[ri + 1]:
ans += a[ri]
elif a[ri - 1] > a[ri] and a[ri] < a[ri + 1]:
ans -= a[ri]
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 89,487 | 12 | 178,975 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11. | instruction | 0 | 89,488 | 12 | 178,976 |
Tags: data structures, divide and conquer, dp, greedy, implementation
Correct Solution:
```
import sys
import math
import collections
import bisect
import itertools
import decimal
import copy
import heapq
# import numpy as np
# sys.setrecursionlimit(10 ** 6)
INF = 10 **20
# MOD = 10 ** 9 + 7
MOD = 998244353
# ni = lambda: int(sys.stdin.readline().rstrip())
# ns = lambda: map(int, sys.stdin.readline().rstrip().split())
# na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
# na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))
# flush = lambda: sys.stdout.flush()
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().split()))
flush = lambda: sys.stdout.flush()
# ===CODE===
def main():
t = ni()
for _ in range(t):
n, q = ns()
a = [-INF] + na() + [-INF]
ans = 0
for i in range(1, n + 1):
if a[i - 1] < a[i] and a[i] > a[i + 1]:
ans += a[i]
elif a[i - 1] > a[i] and a[i] < a[i + 1]:
ans -= a[i]
print(ans)
for _ in range(q):
l, r = ns()
for li in range(l - 2, l + 3):
if 1 <= li <= n:
if a[li - 1] < a[li] and a[li] > a[li + 1]:
ans -= a[li]
elif a[li - 1] > a[li] and a[li] < a[li + 1]:
ans += a[li]
for ri in range(max(l + 3, r - 2), r + 3):
if 1 <= ri <= n:
if a[ri - 1] < a[ri] and a[ri] > a[ri + 1]:
ans -= a[ri]
elif a[ri - 1] > a[ri] and a[ri] < a[ri + 1]:
ans += a[ri]
a[l], a[r] = a[r], a[l]
for li in range(l - 2, l + 3):
if 1 <= li <= n:
if a[li - 1] < a[li] and a[li] > a[li + 1]:
ans += a[li]
elif a[li - 1] > a[li] and a[li] < a[li + 1]:
ans -= a[li]
for ri in range(max(l + 3, r - 2), r + 3):
if 1 <= ri <= n:
if a[ri - 1] < a[ri] and a[ri] > a[ri + 1]:
ans += a[ri]
elif a[ri - 1] > a[ri] and a[ri] < a[ri + 1]:
ans -= a[ri]
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 89,488 | 12 | 178,977 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11. | instruction | 0 | 89,489 | 12 | 178,978 |
Tags: data structures, divide and conquer, dp, greedy, implementation
Correct Solution:
```
import sys
import array
input=sys.stdin.readline
t=int(input())
for _ in range(t):
n,q=map(int,input().split())
a=array.array("i",[-1]+list(map(int,input().split()))+[-1])
def f(i):
if i<=0 or i>=n+1:
return 0
if a[i-1]<a[i]>a[i+1]:
return a[i]
if a[i-1]>a[i]<a[i+1]:
return -a[i]
return 0
ans=0
for i in range(n):
ans+=f(i+1)
print(ans)
for __ in range(q):
l,r=map(int,input().split())
u,v=a[l],a[r]
ans-=f(l-1)+f(l)+f(l+1)
a[l]=v
ans+=f(l-1)+f(l)+f(l+1)
ans-=f(r-1)+f(r)+f(r+1)
a[r]=u
ans+=f(r-1)+f(r)+f(r+1)
print(ans)
``` | output | 1 | 89,489 | 12 | 178,979 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11. | instruction | 0 | 89,490 | 12 | 178,980 |
Tags: data structures, divide and conquer, dp, greedy, implementation
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
# from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
data = [list(map(int,line.split())) for line in sys.stdin.readlines()]
line = 1
for _ in range(data[0][0]):
n,q = data[line]
a = [0]+data[line+1]+[0]
low,high = set(),set()
s = 0
for i in range(1,n+1):
if a[i]>a[i-1] and a[i]>a[i+1]:
high.add(a[i])
s+=a[i]
elif a[i]<a[i-1] and a[i]<a[i+1]:
low.add(a[i])
s-=a[i]
print(s)
for ii in range(line+2,line+q+2):
x,y = data[ii]
a[x],a[y] = a[y],a[x]
d = {a[x-1],a[x],a[x+1],a[y-1],a[y],a[y+1]}
t = low & d
s+=sum(t)
low-=t
t = high & d
s-=sum(t)
high-=t
d = {x-1,x,x+1,y-1,y,y+1}
for i in d:
if 0<i<=n:
if a[i]>a[i-1] and a[i]>a[i+1]:
high.add(a[i])
s+=a[i]
elif a[i]<a[i-1] and a[i]<a[i+1]:
low.add(a[i])
s-=a[i]
print(s)
line+=q+2
``` | output | 1 | 89,490 | 12 | 178,981 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11. | instruction | 0 | 89,491 | 12 | 178,982 |
Tags: data structures, divide and conquer, dp, greedy, implementation
Correct Solution:
```
from sys import stdin, stdout
input = stdin.readline
c = 0
a = []
b = []
def f(i):
if a[i] == 0:
return 0
if a[i - 1] < a[i] > a[i + 1]:
return 1
if a[i - 1] > a[i] < a[i + 1]:
return -1
return 0
def relax(i):
global c
c += (f(i) - b[i]) * a[i]
b[i] = f(i)
def relax1(i):
global c
c -= b[i] * a[i]
b[i] = 0
#print(a[i], a[i - 1] < i)
for _ in range(int(input())):
c = 0
n, q = map(int, input().split())
*a, = map(int, input().split())
a = [0] + a + [0]
b = [0] * (n + 2)
for i in range(1, n + 1):
relax(i)
print(c)
for i in range(q):
l, r = map(int, input().split())
relax1(l)
relax1(l - 1)
relax1(l + 1)
relax1(r)
relax1(r - 1)
relax1(r + 1)
a[l], a[r] = a[r], a[l]
relax(l)
relax(l - 1)
relax(l + 1)
relax(r)
relax(r - 1)
relax(r + 1)
print(c)
``` | output | 1 | 89,491 | 12 | 178,983 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11. | instruction | 0 | 89,492 | 12 | 178,984 |
Tags: data structures, divide and conquer, dp, greedy, implementation
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
# from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
for _ in range(N()):
n,q = RL()
a = [0]+RLL()+[0]
low,high = set(),set()
s = 0
for i in range(1,n+1):
if a[i]>a[i-1] and a[i]>a[i+1]:
high.add(a[i])
s+=a[i]
elif a[i]<a[i-1] and a[i]<a[i+1]:
low.add(a[i])
s-=a[i]
print(s)
for _ in range(q):
x,y = RL()
a[x],a[y] = a[y],a[x]
t = low & {a[x-1],a[x],a[x+1],a[y-1],a[y],a[y+1]}
s+=sum(t)
low-=t
t = high & {a[x-1],a[x],a[x+1],a[y-1],a[y],a[y+1]}
s-=sum(t)
high-=t
d = {x-1,x,x+1,y-1,y,y+1}
for i in d:
if 0<i<=n:
if a[i]>a[i-1] and a[i]>a[i+1]:
high.add(a[i])
s+=a[i]
elif a[i]<a[i-1] and a[i]<a[i+1]:
low.add(a[i])
s-=a[i]
print(s)
``` | output | 1 | 89,492 | 12 | 178,985 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11. | instruction | 0 | 89,493 | 12 | 178,986 |
Tags: data structures, divide and conquer, dp, greedy, implementation
Correct Solution:
```
# Author : -pratyay-
import sys
inp=sys.stdin.buffer.readline
inar=lambda: list(map(int,inp().split()))
inin=lambda: int(inp())
inst=lambda: inp().decode().strip()
def pr(*args,end='\n'):
for _arg in args:
sys.stdout.write(str(_arg)+' ')
sys.stdout.write(end)
from math import log2
_T_=inin()
for _t_ in range(_T_):
n,q=inar()
a=[0]+inar()+[0]
diff=[]
for i in range(n+1):
diff.append(max(0,a[i+1]-a[i]))
pr(sum(diff))
ans=sum(diff)
for qq in range(q):
l,r=inar();
#print("Before: ",a,diff,ans,"l=",l,"r=",r)
al=a[l]
ar=a[r]
#after changing a[l] to ar
a[l]=ar
ans-=diff[l-1]
ans-=diff[l]
diff[l-1]=max(0,a[l]-a[l-1])
diff[l]=max(0,a[l+1]-a[l])
ans+=diff[l-1]
ans+=diff[l]
#after changing a[r] to a[l]
a[r]=al
ans-=diff[r-1]
ans-=diff[r]
diff[r-1]=max(0,a[r]-a[r-1])
diff[r]=max(0,a[r+1]-a[r])
ans+=diff[r-1]
ans+=diff[r]
#print("After: ",a,diff,ans)
pr(ans)
``` | output | 1 | 89,493 | 12 | 178,987 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11. | instruction | 0 | 89,494 | 12 | 178,988 |
Tags: data structures, divide and conquer, dp, greedy, implementation
Correct Solution:
```
import sys;z=sys.stdin.readline;o=[];y=lambda a,b:a-b if a-b>0 else 0
for _ in range(int(z())):
n,q=map(int,z().split());p=[0]+[*map(int,z().split())];s=m=0
for i in p:
if i>m:s+=i-m
m=i
o.append(s)
for i in range(q):
a,b=map(int,z().split())
if a==b:o.append(s);continue
va,vb=p[a],p[b];va1=p[a-1];c=b<n
if c:vb1=p[b+1]
p[a],p[b]=vb,va;lv=nv=0
if b-a<2:
if vb>va:lv+=vb-va
if va>va1:lv+=va-va1
if c and vb1>vb:lv+=vb1-vb
if va>vb:nv+=va-vb
if vb>va1:nv+=vb-va1
if c and vb1>va:nv+=vb1-va
else:
va2,vb2=p[a+1],p[b-1]
if va2>va:lv+=va2-va
if va>va1:lv+=va-va1
if vb>vb2:lv+=vb-vb2
if c and vb1>vb:lv+=vb1-vb
if va2>vb:nv+=va2-vb
if vb>va1:nv+=vb-va1
if va>vb2:nv+=va-vb2
if c and vb1>va:nv+=vb1-va
s+=nv-lv;o.append(s)
print('\n'.join(map(str,o)))
``` | output | 1 | 89,494 | 12 | 178,989 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11.
Submitted Solution:
```
from sys import stdin
from math import log2
def readline():
return stdin.readline()
def findsum(a):
sm = 0
for i in range(len(a)):
if isMax(a, i):
sm += a[i]
elif isMin(a, i):
sm -= a[i]
return sm
def isMax(a, i):
return i != 0 and i != len(a) - 1 and a[i - 1] < a[i] > a[i + 1]
def isMin(a, i):
return i != 0 and i != len(a) - 1 and a[i - 1] > a[i] < a[i + 1]
def change(a, i1, i2, s):
used = set()
for j in [i1, i2]:
for i in range(j - 1, j + 2):
if i not in used:
if isMax(a, i):
s -= a[i]
used.add(i)
if isMin(a, i):
s += a[i]
used.add(i)
a[i1], a[i2] = a[i2], a[i1]
used = set()
for j in [i1, i2]:
for i in range(j - 1, j + 2):
if i not in used:
if isMax(a, i):
s += a[i]
used.add(i)
if isMin(a, i):
s -= a[i]
used.add(i)
return s
tests = int(readline())
for t in range(0, tests):
n, q = map(int, readline().split())
a = [0, *list(map(int, readline().rstrip("\n").split(' '))), 0]
s = findsum(a)
print(s)
for i in range(q):
i1, i2 = map(int, readline().split())
s = change(a, i1, i2, s)
print(s)
``` | instruction | 0 | 89,495 | 12 | 178,990 |
Yes | output | 1 | 89,495 | 12 | 178,991 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11.
Submitted Solution:
```
import io
import os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = int(input())
for _ in range(t):
n,q = list(map(int, input().split()))
arr = list(map(int, input().split()))
total = 0
last = 0
for i in range(n):
total += max(arr[i] - last, 0)
last = arr[i]
arr = [0] + arr + [arr[-1]]
print(total)
ans = []
for _ in range(q):
x,y = list(map(int, input().split()))
x_new, y_new = arr[y], arr[x]
j1, j2 = max(arr[x] - arr[x-1], 0), max(arr[x+1] - arr[x], 0)
arr[x] = x_new
arr[-1] = arr[-2]
n1, n2 = max(arr[x] - arr[x-1], 0), max(arr[x+1] - arr[x], 0)
total -= j1 + j2
total += n1 + n2
j1, j2 = max(arr[y] - arr[y-1], 0), max(arr[y+1] - arr[y], 0)
arr[y] = y_new
arr[-1] = arr[-2]
n1, n2 = max(arr[y] - arr[y-1], 0), max(arr[y+1] - arr[y], 0)
total -= j1 + j2
total += n1 + n2
ans.append(str(total))
print(*ans, sep='\n')
``` | instruction | 0 | 89,496 | 12 | 178,992 |
Yes | output | 1 | 89,496 | 12 | 178,993 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192
def str(x=b''):
return x if type(x) is bytes else _str(x).encode()
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
def inp():
return sys.stdin.readline()
def mpint():
return map(int, sys.stdin.readline().split(' '))
def itg():
return int(sys.stdin.readline())
# ############################## import
# ############################## main
def solve():
n, q = mpint()
arr = list(mpint()) + [0]
ans = 0
for i in range(n):
ans += max(0, arr[i] - arr[i - 1])
print(ans)
for _ in range(q):
lf, rg = mpint()
lf -= 1
rg -= 1
ans -= max(0, arr[rg + 1] - arr[rg])
ans -= max(0, arr[rg] - arr[rg - 1])
if rg != lf + 1:
ans -= max(0, arr[lf + 1] - arr[lf])
ans -= max(0, arr[lf] - arr[lf - 1])
arr[rg], arr[lf] = arr[lf], arr[rg]
ans += max(0, arr[rg + 1] - arr[rg])
ans += max(0, arr[rg] - arr[rg - 1])
if rg != lf + 1:
ans += max(0, arr[lf + 1] - arr[lf])
ans += max(0, arr[lf] - arr[lf - 1])
print(ans)
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
if __name__ == '__main__':
# print("YES" if solve() else "NO")
# print("yes" if solve() else "no")
# solve()
for _ in range(itg()):
# print(solve())
solve()
# Please check!
``` | instruction | 0 | 89,497 | 12 | 178,994 |
Yes | output | 1 | 89,497 | 12 | 178,995 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11.
Submitted Solution:
```
import sys
def solve(n, q, a, u):
z = []
def chk(i):
if a[i - 1] < a[i] > a[i + 1]: return a[i]
if a[i - 1] > a[i] < a[i + 1]: return -a[i]
return 0
if n == 1:
z.append(a[0])
for i in u:
z.append(a[0])
else:
a = [-1] + a + [-1]
c = 0
for i in range(1, n + 1):
c += chk(i)
z.append(c)
for l, r in u:
if l == r:
z.append(c)
else:
b = {
l, max(1, l - 1), min(n, l + 1),
r, max(1, r - 1), min(n, r + 1)
}
for j in b: c -= chk(j)
a[l], a[r] = a[r], a[l]
for j in b: c += chk(j)
z.append(c)
return z
def stdinWrapper():
while True:
yield sys.stdin.readline()
inputs = stdinWrapper()
def inputWrapper():
return next(inputs)
def getType(_type):
return _type(inputWrapper())
def getArray(_type):
return [_type(x) for x in inputWrapper().split()]
t = getType(int)
z = []
for _ in range(t):
n, q = getArray(int)
a = getArray(int)
u = [getArray(int) for _ in range(q)]
z += solve(n, q, a, u)
print('\n'.join(map(str, z)))
``` | instruction | 0 | 89,498 | 12 | 178,996 |
Yes | output | 1 | 89,498 | 12 | 178,997 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11.
Submitted Solution:
```
import sys
def get_diff(a, pos):
return a[pos] * (int(a[pos] > a[pos + 1]) + int(a[pos] > a[pos - 1]) - 1)
def main():
iter_data = map(int, sys.stdin.read().split())
t = next(iter_data)
for t_it in range(t):
n, q = next(iter_data), next(iter_data)
a = [0] + [next(iter_data) for _ in range(n)] + [0]
all_ans = [0] * (q + 1)
diff = [0] * (n + 1)
for i in range(1, n + 1):
diff[i] = int(a[i] > a[i + 1]) + int(a[i] > a[i - 1])
cur_ans = sum(val * (diff - 1) for val, diff in zip(a, diff))
all_ans[0] = cur_ans
for q_it in range(1, q + 1):
l, r = next(iter_data), next(iter_data)
if l != r and t_it <= 300:
mod_pos = [
x for x in set((l - 1, l, l + 1, r - 1, r + 1))
if 1 <= x <= n
]
cur_ans -= sum(diff[p] * a[p] for p in mod_pos)
a[l], a[r] = a[r], a[l]
for p in mod_pos:
diff[p] = int(a[p] > a[p + 1]) + int(a[p] > a[p - 1])
cur_ans += sum(diff[p] * a[p] for p in mod_pos)
all_ans[q_it] = cur_ans
print(*all_ans, sep='\n')
if __name__ == '__main__':
main()
``` | instruction | 0 | 89,499 | 12 | 178,998 |
No | output | 1 | 89,499 | 12 | 178,999 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11.
Submitted Solution:
```
import sys
import array
def get_diff(a, pos):
return a[pos] * (int(a[pos] > a[pos + 1]) + int(a[pos] > a[pos - 1]) - 1)
def main():
iter_data = map(int, sys.stdin.read().split())
t = next(iter_data)
for t_it in range(t):
n, q = next(iter_data), next(iter_data)
a = [0] + [next(iter_data) for _ in range(n)] + [0]
all_ans = [0] * (q + 1)
diff = [0] * (n + 1)
for i in range(1, n + 1):
diff[i] = a[i] * (int(a[i] > a[i + 1]) + int(a[i] > a[i - 1]))
cur_ans = sum(diff) - sum(a)
all_ans[0] = cur_ans
for q_it in range(1, q + 1):
l, r = next(iter_data), next(iter_data)
if l != r and t_it <= 300:
mod_pos = [
x for x in set((l - 1, l, l + 1, r - 1, r, r + 1))
if 1 <= x <= n
]
a[l], a[r] = a[r], a[l]
for p in mod_pos:
cur_ans -= diff[p]
diff[p] = a[p] * (int(a[p] > a[p + 1]) + int(a[p] > a[p - 1]))
cur_ans += diff[p]
all_ans[q_it] = cur_ans
print(*all_ans, sep='\n')
if __name__ == '__main__':
main()
``` | instruction | 0 | 89,500 | 12 | 179,000 |
No | output | 1 | 89,500 | 12 | 179,001 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192
def str(x=b''):
return x if type(x) is bytes else _str(x).encode()
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
def inp():
return sys.stdin.readline()
def mpint():
return map(int, sys.stdin.readline().split(' '))
def itg():
return int(sys.stdin.readline())
# ############################## import
# ############################## main
def solve():
n, q = mpint()
arr = list(mpint()) + [0]
ans = 0
for i in range(n):
ans += max(0, arr[i] - arr[i - 1])
print(ans)
for _ in range(q):
lf, rg = mpint()
# if lf == rg:
# print(ans)
# continue
lf -= 1
rg -= 1
for i in (lf, rg):
for j in range(max(0, i - 3), min(n, i + 2)):
ans -= max(0, arr[j] - arr[j - 1])
arr[lf], arr[rg] = arr[rg], arr[lf]
for i in (lf, rg):
for j in range(max(0, i - 3), min(n, i + 2)):
ans += max(0, arr[j] - arr[j - 1])
print(ans)
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
if __name__ == '__main__':
# print("YES" if solve() else "NO")
# print("yes" if solve() else "no")
# solve()
for _ in range(itg()):
# print(solve())
solve()
# Please check!
``` | instruction | 0 | 89,501 | 12 | 179,002 |
No | output | 1 | 89,501 | 12 | 179,003 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokémon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokémon! Pokémon trainer Andrew decided to help Pikachu to build a pokémon army to resist.
First, Andrew counted all the pokémon — there were exactly n pikachu. The strength of the i-th pokémon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 ≤ b_1 < b_2 < ... < b_k ≤ n, and his army will consist of pokémons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokémon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokémon.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokémon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokémon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) denoting the number of pokémon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) denoting the strengths of the pokémon.
i-th of the last q lines contains two positive integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) denoting the indices of pokémon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5, and the sum of q over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 1
1 3 2
1 2
2 2
1 2
1 2
1 2
7 5
1 2 5 4 3 6 7
1 2
6 7
3 4
1 2
2 3
Output
3
4
2
2
2
9
10
10
10
9
11
Note
Let's look at the third test case:
Initially we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5-3+7=9.
After first operation we can build an army in such way: [2 1 5 4 3 6 7], its strength will be 2-1+5-3+7=10.
After second operation we can build an army in such way: [2 1 5 4 3 7 6], its strength will be 2-1+5-3+7=10.
After third operation we can build an army in such way: [2 1 4 5 3 7 6], its strength will be 2-1+5-3+7=10.
After forth operation we can build an army in such way: [1 2 4 5 3 7 6], its strength will be 5-3+7=9.
After all operations we can build an army in such way: [1 4 2 5 3 7 6], its strength will be 4-2+5-3+7=11.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192
def str(x=b''):
return x if type(x) is bytes else _str(x).encode()
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
def inp():
return sys.stdin.readline()
def mpint():
return map(int, sys.stdin.readline().split(' '))
def itg():
return int(sys.stdin.readline())
# ############################## import
# ############################## main
def solve():
n, q = mpint()
arr = list(mpint()) + [0]
ans = 0
for i in range(n):
ans += max(0, arr[i] - arr[i - 1])
print(ans)
for _ in range(q):
lf, rg = mpint()
lf -= 1
rg -= 1
for i in (lf, rg):
for j in range(max(0, i - 7), min(n, i + 7)):
ans -= max(0, arr[j] - arr[j - 1])
arr[lf], arr[rg] = arr[rg], arr[lf]
for i in (lf, rg):
for j in range(max(0, i - 7), min(n, i + 7)):
ans += max(0, arr[j] - arr[j - 1])
print(ans)
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
if __name__ == '__main__':
# print("YES" if solve() else "NO")
# print("yes" if solve() else "no")
# solve()
for _ in range(itg()):
# print(solve())
solve()
# Please check!
``` | instruction | 0 | 89,502 | 12 | 179,004 |
No | output | 1 | 89,502 | 12 | 179,005 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One spring day on his way to university Lesha found an array A. Lesha likes to split arrays into several parts. This time Lesha decided to split the array A into several, possibly one, new arrays so that the sum of elements in each of the new arrays is not zero. One more condition is that if we place the new arrays one after another they will form the old array A.
Lesha is tired now so he asked you to split the array. Help Lesha!
Input
The first line contains single integer n (1 ≤ n ≤ 100) — the number of elements in the array A.
The next line contains n integers a1, a2, ..., an ( - 103 ≤ ai ≤ 103) — the elements of the array A.
Output
If it is not possible to split the array A and satisfy all the constraints, print single line containing "NO" (without quotes).
Otherwise in the first line print "YES" (without quotes). In the next line print single integer k — the number of new arrays. In each of the next k lines print two integers li and ri which denote the subarray A[li... ri] of the initial array A being the i-th new array. Integers li, ri should satisfy the following conditions:
* l1 = 1
* rk = n
* ri + 1 = li + 1 for each 1 ≤ i < k.
If there are multiple answers, print any of them.
Examples
Input
3
1 2 -3
Output
YES
2
1 2
3 3
Input
8
9 -12 3 4 -4 -10 7 3
Output
YES
2
1 2
3 8
Input
1
0
Output
NO
Input
4
1 2 3 -5
Output
YES
4
1 1
2 2
3 3
4 4 | instruction | 0 | 89,759 | 12 | 179,518 |
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
import io, os
import sys
from atexit import register
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
sys.stdout = io.BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
tokens = []
tokens_next = 0
def nextStr():
global tokens, tokens_next
while tokens_next >= len(tokens):
tokens = input().split()
tokens_next = 0
tokens_next += 1
return tokens[tokens_next - 1]
def nextInt():
return int(nextStr())
def nextIntArr(n):
return [nextInt() for i in range(n)]
def print(s, end='\n'):
sys.stdout.write((str(s) + end).encode())
def split(a):
accSum = a[0]
for j in range(1, len(a)):
if accSum == 0:
continue
cur = split(a[j:])
if cur:
return [a[:j]] + cur
return None
n = nextInt()
a = nextIntArr(n)
if sum(a) != 0:
print('YES')
print('1')
print(f'1 {len(a)}')
exit(0)
nonZero = next((i for i in range(len(a)) if a[i] != 0), len(a))
if nonZero == len(a):
print('NO')
exit(0)
print('YES')
print('2')
print(f'1 {nonZero + 1}')
print(f'{nonZero + 2} {len(a)}')
``` | output | 1 | 89,759 | 12 | 179,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One spring day on his way to university Lesha found an array A. Lesha likes to split arrays into several parts. This time Lesha decided to split the array A into several, possibly one, new arrays so that the sum of elements in each of the new arrays is not zero. One more condition is that if we place the new arrays one after another they will form the old array A.
Lesha is tired now so he asked you to split the array. Help Lesha!
Input
The first line contains single integer n (1 ≤ n ≤ 100) — the number of elements in the array A.
The next line contains n integers a1, a2, ..., an ( - 103 ≤ ai ≤ 103) — the elements of the array A.
Output
If it is not possible to split the array A and satisfy all the constraints, print single line containing "NO" (without quotes).
Otherwise in the first line print "YES" (without quotes). In the next line print single integer k — the number of new arrays. In each of the next k lines print two integers li and ri which denote the subarray A[li... ri] of the initial array A being the i-th new array. Integers li, ri should satisfy the following conditions:
* l1 = 1
* rk = n
* ri + 1 = li + 1 for each 1 ≤ i < k.
If there are multiple answers, print any of them.
Examples
Input
3
1 2 -3
Output
YES
2
1 2
3 3
Input
8
9 -12 3 4 -4 -10 7 3
Output
YES
2
1 2
3 8
Input
1
0
Output
NO
Input
4
1 2 3 -5
Output
YES
4
1 1
2 2
3 3
4 4 | instruction | 0 | 89,760 | 12 | 179,520 |
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
def main():
i=j=0
n = int(input())
ara = list(map(int, input().split()))
if any(ara):
print("YES")
if sum(ara)!=0:
print(1)
print(1, n)
else:
for i, j in enumerate(ara):
if j!=0:
print(2)
print(1, i+1)
print(i+2, n)
break
else:
print("NO")
if __name__ == '__main__':
main()
``` | output | 1 | 89,760 | 12 | 179,521 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.