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 of n integers a_1, a_2, ..., a_n, and a set b of k distinct integers from 1 to n.
In one operation, you may choose two integers i and x (1 β€ i β€ n, x can be any integer) and assign a_i := x. This operation can be done only if i does not belong to the set b.
Calculate the minimum number of operations you should perform so the array a is increasing (that is, a_1 < a_2 < a_3 < ... < a_n), or report that it is impossible.
Input
The first line contains two integers n and k (1 β€ n β€ 5 β
10^5, 0 β€ k β€ n) β the size of the array a and the set b, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Then, if k β 0, the third line follows, containing k integers b_1, b_2, ..., b_k (1 β€ b_1 < b_2 < ... < b_k β€ n). If k = 0, this line is skipped.
Output
If it is impossible to make the array a increasing using the given operations, print -1.
Otherwise, print one integer β the minimum number of operations you have to perform.
Examples
Input
7 2
1 2 1 1 3 5 1
3 5
Output
4
Input
3 3
1 3 2
1 2 3
Output
-1
Input
5 0
4 3 1 2 3
Output
2
Input
10 3
1 3 5 6 12 9 8 10 13 15
2 4 9
Output
3 | instruction | 0 | 102,240 | 12 | 204,480 |
Tags: binary search, constructive algorithms, data structures, dp, implementation
Correct Solution:
```
import bisect
def mat(arr):
n = len(arr)
a = []
arr = [(arr[i] - i) for i in range(n)]
for i in range(n):
if (arr[i] < arr[0] or arr[i] > arr[n - 1]):
continue
k = bisect.bisect_right(a, arr[i])
if k == len(a):
a.append(arr[i])
else:
a[k] = arr[i]
res = n - len(a)
return res
n, m = map(int, input().split())
num1 = list(map(int, input().split()))
if m == 0:
num2 = []
else:
num2 = list(map(int, input().split()))
num1 = [-10 ** 10] + num1 + [10 ** 10]
num2 = [0] + num2 + [n + 1]
sum = 0
ddd = 1
num = num1[0]
tmp = num2[0]
for i in num2[1:]:
if i - tmp > num1[i] - num:
ddd = 0
break
sum += mat(num1[tmp:i + 1])
num = num1[i]
tmp= i
if ddd:
print(sum)
else:
print(-1)
``` | output | 1 | 102,240 | 12 | 204,481 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of n integers a_1, a_2, ..., a_n, and a set b of k distinct integers from 1 to n.
In one operation, you may choose two integers i and x (1 β€ i β€ n, x can be any integer) and assign a_i := x. This operation can be done only if i does not belong to the set b.
Calculate the minimum number of operations you should perform so the array a is increasing (that is, a_1 < a_2 < a_3 < ... < a_n), or report that it is impossible.
Input
The first line contains two integers n and k (1 β€ n β€ 5 β
10^5, 0 β€ k β€ n) β the size of the array a and the set b, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Then, if k β 0, the third line follows, containing k integers b_1, b_2, ..., b_k (1 β€ b_1 < b_2 < ... < b_k β€ n). If k = 0, this line is skipped.
Output
If it is impossible to make the array a increasing using the given operations, print -1.
Otherwise, print one integer β the minimum number of operations you have to perform.
Examples
Input
7 2
1 2 1 1 3 5 1
3 5
Output
4
Input
3 3
1 3 2
1 2 3
Output
-1
Input
5 0
4 3 1 2 3
Output
2
Input
10 3
1 3 5 6 12 9 8 10 13 15
2 4 9
Output
3 | instruction | 0 | 102,241 | 12 | 204,482 |
Tags: binary search, constructive algorithms, data structures, dp, implementation
Correct Solution:
```
from bisect import bisect_right
INF = 10**9+1
n, k = map(int, input().split())
a = [-INF] + [ ai - i for i, ai in enumerate(map(int, input().split())) ] + [INF]
b = [0] + (list(map(int, input().split())) if k else list()) + [n+1]
ans = 0
for j in range(k+1):
l = b[j]
r = b[j+1]
if a[r] < a[l]:
print("-1")
exit()
lis = list()
for ai in a[l+1:r]:
if a[l] <= ai <= a[r]:
pos = bisect_right(lis, ai)
if pos == len(lis):
lis.append(ai)
else:
lis[pos] = ai
ans += r - l - 1 - len(lis)
print(ans)
``` | output | 1 | 102,241 | 12 | 204,483 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of n integers a_1, a_2, ..., a_n, and a set b of k distinct integers from 1 to n.
In one operation, you may choose two integers i and x (1 β€ i β€ n, x can be any integer) and assign a_i := x. This operation can be done only if i does not belong to the set b.
Calculate the minimum number of operations you should perform so the array a is increasing (that is, a_1 < a_2 < a_3 < ... < a_n), or report that it is impossible.
Input
The first line contains two integers n and k (1 β€ n β€ 5 β
10^5, 0 β€ k β€ n) β the size of the array a and the set b, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Then, if k β 0, the third line follows, containing k integers b_1, b_2, ..., b_k (1 β€ b_1 < b_2 < ... < b_k β€ n). If k = 0, this line is skipped.
Output
If it is impossible to make the array a increasing using the given operations, print -1.
Otherwise, print one integer β the minimum number of operations you have to perform.
Examples
Input
7 2
1 2 1 1 3 5 1
3 5
Output
4
Input
3 3
1 3 2
1 2 3
Output
-1
Input
5 0
4 3 1 2 3
Output
2
Input
10 3
1 3 5 6 12 9 8 10 13 15
2 4 9
Output
3 | instruction | 0 | 102,242 | 12 | 204,484 |
Tags: binary search, constructive algorithms, data structures, dp, implementation
Correct Solution:
```
import bisect
def fun(arr):
arr = [(arr[i] - i) for i in range(len(arr))]
a = []
for i in range(len(arr)):
if (arr[i] < arr[0] or arr[i] > arr[len(arr) - 1]):
continue
k = bisect.bisect_right(a, arr[i])
if k == len(a):
a.append(arr[i])
else:
a[k] = arr[i]
result = len(arr) - len(a)
return result
n, k = map(int, input().split())
a = list(map(int, input().split()))
if k == 0:
b = []
else:
b = list(map(int, input().split()))
a = [-10 ** 10] + a + [10 ** 10]
b = [0] + b + [n + 1]
result = 0
flag = True
t, temp = b[0], a[0]
for i in b[1:]:
if i - t > a[i] - temp:
flag = False
break
result += fun(a[t:i + 1])
t, temp = i, a[i]
if flag:
print(result)
else:
print(-1)
``` | output | 1 | 102,242 | 12 | 204,485 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of n integers a_1, a_2, ..., a_n, and a set b of k distinct integers from 1 to n.
In one operation, you may choose two integers i and x (1 β€ i β€ n, x can be any integer) and assign a_i := x. This operation can be done only if i does not belong to the set b.
Calculate the minimum number of operations you should perform so the array a is increasing (that is, a_1 < a_2 < a_3 < ... < a_n), or report that it is impossible.
Input
The first line contains two integers n and k (1 β€ n β€ 5 β
10^5, 0 β€ k β€ n) β the size of the array a and the set b, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Then, if k β 0, the third line follows, containing k integers b_1, b_2, ..., b_k (1 β€ b_1 < b_2 < ... < b_k β€ n). If k = 0, this line is skipped.
Output
If it is impossible to make the array a increasing using the given operations, print -1.
Otherwise, print one integer β the minimum number of operations you have to perform.
Examples
Input
7 2
1 2 1 1 3 5 1
3 5
Output
4
Input
3 3
1 3 2
1 2 3
Output
-1
Input
5 0
4 3 1 2 3
Output
2
Input
10 3
1 3 5 6 12 9 8 10 13 15
2 4 9
Output
3 | instruction | 0 | 102,243 | 12 | 204,486 |
Tags: binary search, constructive algorithms, data structures, dp, implementation
Correct Solution:
```
import bisect
def calculate(num):
aa=[]
bb=[]
n = len(num)
num = [(num[i] - i) for i in range(0,n)]
for i in range(0,n):
if (num[i] > num[n - 1] or num[i] < num[0] ):
continue
kk = bisect.bisect_right(aa, num[i])
if kk != len(aa):
aa[kk] = num[i]
else:
aa.append(num[i])
return (n - len(aa))
outt =1
n, k = map(int, input().split())
a1=[]
a1 = list(map(int, input().split()))
if k != 0:
a2 = list(map(int, input().split()))
else:
a2 = []
a1 = [-10**10] + a1 + [10**10]
a2 = [0]+ a2 + [n + 1]
aa1= a1[0]
aa2= a2[0]
outt=0
flag = True
for j in a2[1:]:
if (j + aa1 > a1[j]+ aa2):
flag = False
break
outt = outt+calculate(a1[aa2:j + 1])
aa1 =a1[j]
aa2=j
if (flag==False):
print(-1)
else:
print(outt)
``` | output | 1 | 102,243 | 12 | 204,487 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of n integers a_1, a_2, ..., a_n, and a set b of k distinct integers from 1 to n.
In one operation, you may choose two integers i and x (1 β€ i β€ n, x can be any integer) and assign a_i := x. This operation can be done only if i does not belong to the set b.
Calculate the minimum number of operations you should perform so the array a is increasing (that is, a_1 < a_2 < a_3 < ... < a_n), or report that it is impossible.
Input
The first line contains two integers n and k (1 β€ n β€ 5 β
10^5, 0 β€ k β€ n) β the size of the array a and the set b, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Then, if k β 0, the third line follows, containing k integers b_1, b_2, ..., b_k (1 β€ b_1 < b_2 < ... < b_k β€ n). If k = 0, this line is skipped.
Output
If it is impossible to make the array a increasing using the given operations, print -1.
Otherwise, print one integer β the minimum number of operations you have to perform.
Examples
Input
7 2
1 2 1 1 3 5 1
3 5
Output
4
Input
3 3
1 3 2
1 2 3
Output
-1
Input
5 0
4 3 1 2 3
Output
2
Input
10 3
1 3 5 6 12 9 8 10 13 15
2 4 9
Output
3 | instruction | 0 | 102,244 | 12 | 204,488 |
Tags: binary search, constructive algorithms, data structures, dp, implementation
Correct Solution:
```
import bisect
def TSort():
one=False
zero=False
flag=True
for i in range(0,n):
if i<n-1:
if a[i+1]<a[i]:
flag=False
if b[i]==0:
one=True
else:
zero=True
if flag or (one and zero):
print("Yes")
else:
print("No")
def snynb(arr):
n = len(arr)
a = []
arr = [(arr[i] - i) for i in range(n)]
for i in range(n):
if (arr[i] < arr[0] or arr[i] > arr[n - 1]):
continue
k = bisect.bisect_right(a, arr[i])
if k == len(a):
a.append(arr[i])
else:
a[k] = arr[i]
x = n - len(a)
return x
def okk(mid):
global n,shuzu,k,m
m=0
zonghe=0
cnt=0
for i in range (n):
if zonghe+shuzu[i]>=mid:
if zonghe>m:
m=zonghe
zonghe=shuzu[i]
cnt=cnt+1
else:
zonghe=zonghe+shuzu[i]
return cnt<k
n, m = map(int, input().split())
num1 = list(map(int, input().split()))
if m == 0:
num2 = []
else:
num2 = list(map(int, input().split()))
num1 = [-10 ** 10] + num1 + [10 ** 10]
num2 = [0] + num2 + [n + 1]
sum = 0
sny = 1
num = num1[0]
t = num2[0]
for i in num2[1:]:
if i - t > num1[i] - num:
sny = 0
break
sum += snynb(num1[t:i + 1])
num = num1[i]
t = i
if sny:
print(sum)
else:
print(-1)
``` | output | 1 | 102,244 | 12 | 204,489 |
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 of n integers a_1, a_2, ..., a_n, and a set b of k distinct integers from 1 to n.
In one operation, you may choose two integers i and x (1 β€ i β€ n, x can be any integer) and assign a_i := x. This operation can be done only if i does not belong to the set b.
Calculate the minimum number of operations you should perform so the array a is increasing (that is, a_1 < a_2 < a_3 < ... < a_n), or report that it is impossible.
Input
The first line contains two integers n and k (1 β€ n β€ 5 β
10^5, 0 β€ k β€ n) β the size of the array a and the set b, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Then, if k β 0, the third line follows, containing k integers b_1, b_2, ..., b_k (1 β€ b_1 < b_2 < ... < b_k β€ n). If k = 0, this line is skipped.
Output
If it is impossible to make the array a increasing using the given operations, print -1.
Otherwise, print one integer β the minimum number of operations you have to perform.
Examples
Input
7 2
1 2 1 1 3 5 1
3 5
Output
4
Input
3 3
1 3 2
1 2 3
Output
-1
Input
5 0
4 3 1 2 3
Output
2
Input
10 3
1 3 5 6 12 9 8 10 13 15
2 4 9
Output
3
Submitted Solution:
```
import sys
import math
from bisect import bisect_right
def II():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def MI():
return map(int, sys.stdin.readline().split())
def SI():
return sys.stdin.readline().strip()
n,k = MI()
a = LI()
a = [float('-inf')]+a+[float('inf')]
b = []
if k!=0:
b = LI()
b = [0]+b+[n+1]
ans = n-k
for i in range(k+1):
l = b[i]
r = b[i+1]
if a[l]-l>a[r]-r:
print(-1)
exit(0)
lis = []
for j in range(l+1,r):
if not a[l]-l<=a[j]-j<=a[r]-r:
continue
ind = bisect_right(lis,a[j]-j)
if ind == len(lis):
lis.append(a[j]-j)
else:
lis[ind] = a[j]-j
ans-=len(lis)
print(ans)
``` | instruction | 0 | 102,247 | 12 | 204,494 |
Yes | output | 1 | 102,247 | 12 | 204,495 |
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 of n integers a_1, a_2, ..., a_n, and a set b of k distinct integers from 1 to n.
In one operation, you may choose two integers i and x (1 β€ i β€ n, x can be any integer) and assign a_i := x. This operation can be done only if i does not belong to the set b.
Calculate the minimum number of operations you should perform so the array a is increasing (that is, a_1 < a_2 < a_3 < ... < a_n), or report that it is impossible.
Input
The first line contains two integers n and k (1 β€ n β€ 5 β
10^5, 0 β€ k β€ n) β the size of the array a and the set b, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Then, if k β 0, the third line follows, containing k integers b_1, b_2, ..., b_k (1 β€ b_1 < b_2 < ... < b_k β€ n). If k = 0, this line is skipped.
Output
If it is impossible to make the array a increasing using the given operations, print -1.
Otherwise, print one integer β the minimum number of operations you have to perform.
Examples
Input
7 2
1 2 1 1 3 5 1
3 5
Output
4
Input
3 3
1 3 2
1 2 3
Output
-1
Input
5 0
4 3 1 2 3
Output
2
Input
10 3
1 3 5 6 12 9 8 10 13 15
2 4 9
Output
3
Submitted Solution:
```
import bisect
def solve(numss):
n = len(numss)
a = []
numss = [(numss[i] - i) for i in range(n)]
for i in range(n):
if (numss[i] < numss[0] or numss[i] > numss[n - 1]):
continue
k = bisect.bisect_right(a, numss[i])
if k == len(a):
a.append(numss[i])
else:
a[k] = numss[i]
res = n - len(a)
return res
def main():
n, k = map(int, input().split())
a = list(map(int, input().split()))
if k == 0:
b = []
else:
b = list(map(int, input().split()))
a = [-10 ** 10] + a + [10 ** 10]
b = [0] + b + [n + 1]
res = 0
ok = True
t, tp = b[0], a[0]
for i in b[1:]:
if i - t > a[i] - tp:
ok = False
break
res += solve(a[t:i + 1])
t, tp = i, a[i]
if ok:
print(res)
else:
print(-1)
if __name__ == '__main__':
main()
``` | instruction | 0 | 102,248 | 12 | 204,496 |
Yes | output | 1 | 102,248 | 12 | 204,497 |
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 of n integers a_1, a_2, ..., a_n, and a set b of k distinct integers from 1 to n.
In one operation, you may choose two integers i and x (1 β€ i β€ n, x can be any integer) and assign a_i := x. This operation can be done only if i does not belong to the set b.
Calculate the minimum number of operations you should perform so the array a is increasing (that is, a_1 < a_2 < a_3 < ... < a_n), or report that it is impossible.
Input
The first line contains two integers n and k (1 β€ n β€ 5 β
10^5, 0 β€ k β€ n) β the size of the array a and the set b, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Then, if k β 0, the third line follows, containing k integers b_1, b_2, ..., b_k (1 β€ b_1 < b_2 < ... < b_k β€ n). If k = 0, this line is skipped.
Output
If it is impossible to make the array a increasing using the given operations, print -1.
Otherwise, print one integer β the minimum number of operations you have to perform.
Examples
Input
7 2
1 2 1 1 3 5 1
3 5
Output
4
Input
3 3
1 3 2
1 2 3
Output
-1
Input
5 0
4 3 1 2 3
Output
2
Input
10 3
1 3 5 6 12 9 8 10 13 15
2 4 9
Output
3
Submitted Solution:
```
import sys,os,io
input = sys.stdin.readline
from bisect import bisect_right
N, K = map(int, input().split())
A = [-float('inf')]+list(map(int, input().split()))+[float('inf')]
if K:
B = [0]+list(map(int, input().split()))+[N+1]
else:
B = [0,N+1]
ans = N-K
for k in range(K+1):
left, right = B[k], B[k+1]
if A[left]>=A[right]:
print(-1)
break
lis = []
for i in range(left+1,right):
if not A[left]-left<=A[i]-i<=A[right]-right:
continue
ind = bisect_right(lis,A[i]-i)
if ind == len(lis):
lis.append(A[i]-i)
else:
lis[ind] = A[i]-i
ans -= len(lis)
else:
print(ans)
``` | instruction | 0 | 102,249 | 12 | 204,498 |
No | output | 1 | 102,249 | 12 | 204,499 |
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 of n integers a_1, a_2, ..., a_n, and a set b of k distinct integers from 1 to n.
In one operation, you may choose two integers i and x (1 β€ i β€ n, x can be any integer) and assign a_i := x. This operation can be done only if i does not belong to the set b.
Calculate the minimum number of operations you should perform so the array a is increasing (that is, a_1 < a_2 < a_3 < ... < a_n), or report that it is impossible.
Input
The first line contains two integers n and k (1 β€ n β€ 5 β
10^5, 0 β€ k β€ n) β the size of the array a and the set b, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Then, if k β 0, the third line follows, containing k integers b_1, b_2, ..., b_k (1 β€ b_1 < b_2 < ... < b_k β€ n). If k = 0, this line is skipped.
Output
If it is impossible to make the array a increasing using the given operations, print -1.
Otherwise, print one integer β the minimum number of operations you have to perform.
Examples
Input
7 2
1 2 1 1 3 5 1
3 5
Output
4
Input
3 3
1 3 2
1 2 3
Output
-1
Input
5 0
4 3 1 2 3
Output
2
Input
10 3
1 3 5 6 12 9 8 10 13 15
2 4 9
Output
3
Submitted Solution:
```
import bisect
one, two = map(int, input().split())
arr = list(map(int, input().split()))
if two == 0:
second = list()
else:
second = list(map(int, input().split()))
res = 0
second = [0] + second + [one + 1]
count = second[0]
num = arr[0]
arr = [-10 ** 10] + arr + [10 ** 10]
flag = 1
def judge(num):
n = len(num)
ls = list()
num = [(num[i] - i) for i in range(n)]
for i in range(n):
if (num[i] < num[0] or num[i] > num[n - 1]):
continue
k = bisect.bisect_right(ls, num[i])
if k == len(ls):
ls.append(num[i])
else:
ls[k] = num[i]
ans = n - len(ls)
return ans
for j in second[1:]:
if j - count > arr[j] - num:
flag = 0
break
res += judge(arr[count:j + 1])
count, num = j, arr[j]
if flag:
print(res)
else:
print(-1)
``` | instruction | 0 | 102,251 | 12 | 204,502 |
No | output | 1 | 102,251 | 12 | 204,503 |
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 of n integers a_1, a_2, ..., a_n, and a set b of k distinct integers from 1 to n.
In one operation, you may choose two integers i and x (1 β€ i β€ n, x can be any integer) and assign a_i := x. This operation can be done only if i does not belong to the set b.
Calculate the minimum number of operations you should perform so the array a is increasing (that is, a_1 < a_2 < a_3 < ... < a_n), or report that it is impossible.
Input
The first line contains two integers n and k (1 β€ n β€ 5 β
10^5, 0 β€ k β€ n) β the size of the array a and the set b, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Then, if k β 0, the third line follows, containing k integers b_1, b_2, ..., b_k (1 β€ b_1 < b_2 < ... < b_k β€ n). If k = 0, this line is skipped.
Output
If it is impossible to make the array a increasing using the given operations, print -1.
Otherwise, print one integer β the minimum number of operations you have to perform.
Examples
Input
7 2
1 2 1 1 3 5 1
3 5
Output
4
Input
3 3
1 3 2
1 2 3
Output
-1
Input
5 0
4 3 1 2 3
Output
2
Input
10 3
1 3 5 6 12 9 8 10 13 15
2 4 9
Output
3
Submitted Solution:
```
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
#from decimal import Decimal
#from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = 10**9
mod = int(1e9)+7
def CeilIndex(A, l, r, key):
while (r - l > 1):
m = l + (r - l) // 2
if (A[m] >= key):
r = m
else:
l = m
return r
def LongestIncreasingSubsequenceLength(A, size, s, e):
tailTable = [0 for i in range(e-s+1)]
ind = [0 for i in range(e-s+1)]
len = 0
tailTable[0] = A[s]
ind[0] = s
len = 1
for i in range(s+1, e):
if A[s]+i-s<=A[i]<=A[e]+i-e :
if (A[i] > tailTable[len - 1]):
if i-ind[len-1]<=A[i]-tailTable[len - 1]:
tailTable[len] = A[i]
ind[len] = i
len += 1
else:
ind1=CeilIndex(tailTable, -1, len - 1, A[i])
if i-ind[ind1]<=A[i]-tailTable[ind1 - 1]:
tailTable[ind1] = A[i]
ind[ind1]=i
return len-1
n,k=mdata()
a=[-INF]+mdata()+[INF]
b=[0]
if k:
b+=sorted(mdata())
b+=[n+1]
for i in range(k+1):
if a[b[i+1]]-a[b[i]]<b[i+1]-b[i]:
out(-1)
exit()
ans=0
for i in range(k+1):
ans+=b[i+1]-b[i]-1-LongestIncreasingSubsequenceLength(a,n+2,b[i],b[i+1])
out(ans)
``` | instruction | 0 | 102,252 | 12 | 204,504 |
No | output | 1 | 102,252 | 12 | 204,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Jeff's friends know full well that the boy likes to get sequences and arrays for his birthday. Thus, Jeff got sequence p1, p2, ..., pn for his birthday.
Jeff hates inversions in sequences. An inversion in sequence a1, a2, ..., an is a pair of indexes i, j (1 β€ i < j β€ n), such that an inequality ai > aj holds.
Jeff can multiply some numbers of the sequence p by -1. At that, he wants the number of inversions in the sequence to be minimum. Help Jeff and find the minimum number of inversions he manages to get.
Input
The first line contains integer n (1 β€ n β€ 2000). The next line contains n integers β sequence p1, p2, ..., pn (|pi| β€ 105). The numbers are separated by spaces.
Output
In a single line print the answer to the problem β the minimum number of inversions Jeff can get.
Examples
Input
2
2 1
Output
0
Input
9
-2 0 -1 0 -1 2 1 0 -1
Output
6 | instruction | 0 | 102,399 | 12 | 204,798 |
Tags: greedy
Correct Solution:
```
n = int(input())
inp = input()
seq = inp.split(' ')
seq = [ abs(int(x)) for x in seq ]
Max = max(seq)
nxt = [0] * n
cnt = [0] * n
pos = [n] * (Max+1)
for i in range(n-1, -1, -1):
nxt[i] = pos[seq[i]]
pos[seq[i]] = i
for i in range(0, Max+1):
j = pos[i]
while(j<n):
front = sum(cnt[0:j])
back = sum(cnt[j+1:n])
if(front < back):
seq[j] = 0 - seq[j]
j = nxt[j]
j = pos[i]
while(j < n):
cnt[j] = 1
j = nxt[j]
#for i in range(0, n-1):
# print(seq[i], sep=' ')
#print(seq[n-1])
inv = 0
for i in range(len(seq)):
for j in range(i+1, len(seq)):
if(seq[i] > seq[j]):
inv += 1
print(inv)
``` | output | 1 | 102,399 | 12 | 204,799 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jeff's friends know full well that the boy likes to get sequences and arrays for his birthday. Thus, Jeff got sequence p1, p2, ..., pn for his birthday.
Jeff hates inversions in sequences. An inversion in sequence a1, a2, ..., an is a pair of indexes i, j (1 β€ i < j β€ n), such that an inequality ai > aj holds.
Jeff can multiply some numbers of the sequence p by -1. At that, he wants the number of inversions in the sequence to be minimum. Help Jeff and find the minimum number of inversions he manages to get.
Input
The first line contains integer n (1 β€ n β€ 2000). The next line contains n integers β sequence p1, p2, ..., pn (|pi| β€ 105). The numbers are separated by spaces.
Output
In a single line print the answer to the problem β the minimum number of inversions Jeff can get.
Examples
Input
2
2 1
Output
0
Input
9
-2 0 -1 0 -1 2 1 0 -1
Output
6
Submitted Solution:
```
print("QUE TE CACHEN PROBLEMA E(DIV1)")
print("By: GUillermo Montanez Sosa - Guillermo_0114")
``` | instruction | 0 | 102,400 | 12 | 204,800 |
No | output | 1 | 102,400 | 12 | 204,801 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Jeff's friends know full well that the boy likes to get sequences and arrays for his birthday. Thus, Jeff got sequence p1, p2, ..., pn for his birthday.
Jeff hates inversions in sequences. An inversion in sequence a1, a2, ..., an is a pair of indexes i, j (1 β€ i < j β€ n), such that an inequality ai > aj holds.
Jeff can multiply some numbers of the sequence p by -1. At that, he wants the number of inversions in the sequence to be minimum. Help Jeff and find the minimum number of inversions he manages to get.
Input
The first line contains integer n (1 β€ n β€ 2000). The next line contains n integers β sequence p1, p2, ..., pn (|pi| β€ 105). The numbers are separated by spaces.
Output
In a single line print the answer to the problem β the minimum number of inversions Jeff can get.
Examples
Input
2
2 1
Output
0
Input
9
-2 0 -1 0 -1 2 1 0 -1
Output
6
Submitted Solution:
```
n = int(input())
inp = input()
seq = inp.split(' ')
seq = [ abs(int(x)) for x in seq ]
Max = max(seq)
nxt = [0] * n
cnt = [0] * n
pos = [n] * (Max+1)
for i in range(n-1, -1, -1):
nxt[i] = pos[seq[i]]
pos[seq[i]] = i
for i in range(0, Max+1):
j = pos[i]
while(j<n):
front = sum(cnt[0:j])
back = sum(cnt[j+1:n])
if(front < back):
seq[j] = 0 - seq[j]
cnt[j] = 1
j = nxt[j]
#for i in range(0, n-1):
# print(seq[i], sep=' ')
#print(seq[n-1])
inv = 0
for i in range(len(seq)):
for j in range(i+1, len(seq)):
if(seq[i] > seq[j]):
inv += 1
print(inv)
``` | instruction | 0 | 102,401 | 12 | 204,802 |
No | output | 1 | 102,401 | 12 | 204,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174 | instruction | 0 | 102,522 | 12 | 205,044 |
Tags: combinatorics
Correct Solution:
```
p = 10**9+7
n, m = map(int, input().split())
print (n+1 if m == 1 else pow(m, n, p)*(1+(pow(2*m-1, n, p)*pow(m, p-1-n, p) - 1)*m*pow(m-1, p-2, p))%p)
``` | output | 1 | 102,522 | 12 | 205,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174 | instruction | 0 | 102,523 | 12 | 205,046 |
Tags: combinatorics
Correct Solution:
```
#### IMPORTANT LIBRARY ####
############################
### DO NOT USE import random --> 250ms to load the library
############################
### In case of extra libraries: https://github.com/cheran-senthil/PyRival
######################
####### IMPORT #######
######################
from functools import cmp_to_key
from collections import deque, Counter
from heapq import heappush, heappop
from math import log, ceil
######################
#### STANDARD I/O ####
######################
import sys
import os
from io import BytesIO, IOBase
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")
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def print(*args, **kwargs):
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
def inp():
return sys.stdin.readline().rstrip("\r\n") # for fast input
def ii():
return int(inp())
def si():
return str(inp())
def li(lag = 0):
l = list(map(int, inp().split()))
if lag != 0:
for i in range(len(l)):
l[i] += lag
return l
def mi(lag = 0):
matrix = list()
for i in range(n):
matrix.append(li(lag))
return matrix
def lsi(): #string list
return list(map(str, inp().split()))
def print_list(lista, space = " "):
print(space.join(map(str, lista)))
######################
### BISECT METHODS ###
######################
def bisect_left(a, x):
"""i tale che a[i] >= x e a[i-1] < x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] < x:
left = mid+1
else:
right = mid
return left
def bisect_right(a, x):
"""i tale che a[i] > x e a[i-1] <= x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] > x:
right = mid
else:
left = mid+1
return left
def bisect_elements(a, x):
"""elementi pari a x nell'Γ‘rray sortato"""
return bisect_right(a, x) - bisect_left(a, x)
######################
### MOD OPERATION ####
######################
MOD = 10**9 + 7
maxN = 5
FACT = [0] * maxN
INV_FACT = [0] * maxN
def add(x, y):
return (x+y) % MOD
def multiply(x, y):
return (x*y) % MOD
def power(x, y):
if y == 0:
return 1
elif y % 2:
return multiply(x, power(x, y-1))
else:
a = power(x, y//2)
return multiply(a, a)
def inverse(x):
return power(x, MOD-2)
def divide(x, y):
return multiply(x, inverse(y))
def allFactorials():
FACT[0] = 1
for i in range(1, maxN):
FACT[i] = multiply(i, FACT[i-1])
def inverseFactorials():
n = len(INV_FACT)
INV_FACT[n-1] = inverse(FACT[n-1])
for i in range(n-2, -1, -1):
INV_FACT[i] = multiply(INV_FACT[i+1], i+1)
def coeffBinom(n, k):
if n < k:
return 0
return multiply(FACT[n], multiply(INV_FACT[k], INV_FACT[n-k]))
######################
#### GRAPH ALGOS #####
######################
# ZERO BASED GRAPH
def create_graph(n, m, undirected = 1, unweighted = 1):
graph = [[] for i in range(n)]
if unweighted:
for i in range(m):
[x, y] = li(lag = -1)
graph[x].append(y)
if undirected:
graph[y].append(x)
else:
for i in range(m):
[x, y, w] = li(lag = -1)
w += 1
graph[x].append([y,w])
if undirected:
graph[y].append([x,w])
return graph
def create_tree(n, unweighted = 1):
children = [[] for i in range(n)]
if unweighted:
for i in range(n-1):
[x, y] = li(lag = -1)
children[x].append(y)
children[y].append(x)
else:
for i in range(n-1):
[x, y, w] = li(lag = -1)
w += 1
children[x].append([y, w])
children[y].append([x, w])
return children
def dist(tree, n, A, B = -1):
s = [[A, 0]]
massimo, massimo_nodo = 0, 0
distanza = -1
v = [-1] * n
while s:
el, dis = s.pop()
if dis > massimo:
massimo = dis
massimo_nodo = el
if el == B:
distanza = dis
for child in tree[el]:
if v[child] == -1:
v[child] = 1
s.append([child, dis+1])
return massimo, massimo_nodo, distanza
def diameter(tree):
_, foglia, _ = dist(tree, n, 0)
diam, _, _ = dist(tree, n, foglia)
return diam
def dfs(graph, n, A):
v = [-1] * n
s = [[A, 0]]
v[A] = 0
while s:
el, dis = s.pop()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
def bfs(graph, n, A):
v = [-1] * n
s = deque()
s.append([A, 0])
v[A] = 0
while s:
el, dis = s.popleft()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
#FROM A GIVEN ROOT, RECOVER THE STRUCTURE
def parents_children_root_unrooted_tree(tree, n, root = 0):
q = deque()
visited = [0] * n
parent = [-1] * n
children = [[] for i in range(n)]
q.append(root)
while q:
all_done = 1
visited[q[0]] = 1
for child in tree[q[0]]:
if not visited[child]:
all_done = 0
q.appendleft(child)
if all_done:
for child in tree[q[0]]:
if parent[child] == -1:
parent[q[0]] = child
children[child].append(q[0])
q.popleft()
return parent, children
# CALCULATING LONGEST PATH FOR ALL THE NODES
def all_longest_path_passing_from_node(parent, children, n):
q = deque()
visited = [len(children[i]) for i in range(n)]
downwards = [[0,0] for i in range(n)]
upward = [1] * n
longest_path = [1] * n
for i in range(n):
if not visited[i]:
q.append(i)
downwards[i] = [1,0]
while q:
node = q.popleft()
if parent[node] != -1:
visited[parent[node]] -= 1
if not visited[parent[node]]:
q.append(parent[node])
else:
root = node
for child in children[node]:
downwards[node] = sorted([downwards[node][0], downwards[node][1], downwards[child][0] + 1], reverse = True)[0:2]
s = [node]
while s:
node = s.pop()
if parent[node] != -1:
if downwards[parent[node]][0] == downwards[node][0] + 1:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][1])
else:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][0])
longest_path[node] = downwards[node][0] + downwards[node][1] + upward[node] - min([downwards[node][0], downwards[node][1], upward[node]]) - 1
for child in children[node]:
s.append(child)
return longest_path
### TBD SUCCESSOR GRAPH 7.5
### TBD TREE QUERIES 10.2 da 2 a 4
### TBD ADVANCED TREE 10.3
### TBD GRAPHS AND MATRICES 11.3.3 e 11.4.3 e 11.5.3 (ON GAMES)
######################
## END OF LIBRARIES ##
######################
n,m = li()
s = power(m, n)
A = [m]
B = [1]
for i in range(n-1):
A.append(multiply(A[-1], m))
B.append(multiply(B[-1], 2*m-1))
A.reverse()
for i in range(n):
k = multiply(A[i], B[i])
s = add(s, k)
print(s)
``` | output | 1 | 102,523 | 12 | 205,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174 | instruction | 0 | 102,524 | 12 | 205,048 |
Tags: combinatorics
Correct Solution:
```
import sys
from array import array
n, m = map(int, input().split())
dp = [array('i', [0])*(n+1) for _ in range(2)]
dp[0][0] = dp[1][0] = 1
mod = 10**9 + 7
for i in range(1, n+1):
dp[0][i] = (dp[0][i-1] * m + dp[0][i-1] * (m-1)) % mod
dp[1][i] = (dp[0][i-1] * m + dp[1][i-1] * m) % mod
print(dp[1][-1])
``` | output | 1 | 102,524 | 12 | 205,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174 | instruction | 0 | 102,525 | 12 | 205,050 |
Tags: combinatorics
Correct Solution:
```
n, m = map(int, input().split())
M = 1000000007
if m == 1:
print(n + 1)
else:
print((m * pow(2 * m - 1, n, M) - pow(m, n, M)) * pow(m - 1, M - 2, M) % M)
``` | output | 1 | 102,525 | 12 | 205,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174 | instruction | 0 | 102,526 | 12 | 205,052 |
Tags: combinatorics
Correct Solution:
```
n,m=map(int,input().split())
x,y,M=0,1,10**9+7
while n>0:
x,y,n=(2*m*x-x+y)%M,y*m%M,n-1
print((y+m*x)%M)
``` | output | 1 | 102,526 | 12 | 205,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174 | instruction | 0 | 102,527 | 12 | 205,054 |
Tags: combinatorics
Correct Solution:
```
n,m=map(int,input().split())
x,y,M=0,1,1000000007
for i in range(n):
x=((2*m-1)*x+y)%M;y=y*m%M
print((y+m*x)%M)
``` | output | 1 | 102,527 | 12 | 205,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174 | instruction | 0 | 102,528 | 12 | 205,056 |
Tags: combinatorics
Correct Solution:
```
P = 10**9 + 7
n, k = map(int, input().split())
print(n + 1 if k == 1 else (k * pow(2 * k - 1, n, P) - pow(k, n, P)) * pow(k - 1, P - 2, P) % P)
``` | output | 1 | 102,528 | 12 | 205,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174 | instruction | 0 | 102,529 | 12 | 205,058 |
Tags: combinatorics
Correct Solution:
```
import math
def euclid_algorithm(a, b):
t1, t2 = abs(a), abs(b)
#saving equalities:
#t1 == x1 * a + y1 * b,
#t2 == x2 * a + y2 * b.
x1, y1, x2, y2 = int(math.copysign(1, a)), 0, 0, int(math.copysign(1, b))
if t1 < t2:
t1, t2 = t2, t1
x1, y1, x2, y2 = x2, y2, x1, y1
while t2 > 0:
k = int(t1 // t2)
t1, t2 = t2, t1 % t2
#t1 - k * t2 == (x1 - k * x2) * a + (y1 - k * y2) * b
x1, y1, x2, y2 = x2, y2, x1 - k * x2, y1 - k * y2
return t1, x1, y1
def opposite_element(x, p):
gcd, k, l = euclid_algorithm(x, p)
if gcd != 1:
return -1
return k % p
def solve(n, m, p):
if (m-1) % p == 0:
return (n + 1) * pow(m, n, p) % p
else:
S = pow(m, n, p)
k = opposite_element(m, p)
l = (2*m - 1) * k % p
q = opposite_element(l - 1, p)
S += pow(m, n, p) * (pow(l, n, p) - 1) * q
S %= p
return S
p = 10 ** 9 + 7
n, m = [int(x) for x in input().split()]
print(solve(n, m, p))
``` | output | 1 | 102,529 | 12 | 205,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174
Submitted Solution:
```
import math
def euclid_algorithm(a, b):
t1, t2 = abs(a), abs(b)
#saving equalities:
#t1 == x1 * a + y1 * b,
#t2 == x2 * a + y2 * b.
x1, y1, x2, y2 = int(math.copysign(1, a)), 0, 0, int(math.copysign(1, b))
if t1 < t2:
t1, t2 = t2, t1
x1, y1, x2, y2 = x2, y2, x1, y1
while t2 > 0:
k = int(t1 // t2)
t1, t2 = t2, t1 % t2
#t1 - k * t2 == (x1 - k * x2) * a + (y1 - k * y2) * b
x1, y1, x2, y2 = x2, y2, x1 - k * x2, y1 - k * y2
return t1, x1, y1
def opposite_element(x, p):
gcd, k, l = euclid_algorithm(x, p)
if gcd != 1:
return -1
return k % p
p = 10 ** 9 + 7
n, m = [int(x) for x in input().split()]
S = pow(m, n, p)
k = opposite_element(m, p)
l = (2*m - 1) * k % p
q = opposite_element(l - 1, p)
S += pow(m, n, p) * (pow(l, n, p) - 1) * q
S %= p
print(S)
``` | instruction | 0 | 102,530 | 12 | 205,060 |
No | output | 1 | 102,530 | 12 | 205,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174
Submitted Solution:
```
L = input().split()
n = int(L[0])
m = int(L[1])
mod = 1000000007
powr, current = 1, 1
for i in range (0, n):
current = (2 * m * current - (current - powr)%mod)
powr *= m
print(current)
``` | instruction | 0 | 102,531 | 12 | 205,062 |
No | output | 1 | 102,531 | 12 | 205,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174
Submitted Solution:
```
import math
def euclid_algorithm(a, b):
t1, t2 = abs(a), abs(b)
#saving equalities:
#t1 == x1 * a + y1 * b,
#t2 == x2 * a + y2 * b.
x1, y1, x2, y2 = int(math.copysign(1, a)), 0, 0, int(math.copysign(1, b))
if t1 < t2:
t1, t2 = t2, t1
x1, y1, x2, y2 = x2, y2, x1, y1
while t2 > 0:
k = int(t1 // t2)
t1, t2 = t2, t1 % t2
#t1 - k * t2 == (x1 - k * x2) * a + (y1 - k * y2) * b
x1, y1, x2, y2 = x2, y2, x1 - k * x2, y1 - k * y2
return t1, x1, y1
def opposite_element(x, p):
gcd, k, l = euclid_algorithm(x, p)
if gcd != 1:
return -1
return k % p
p = 10 ** 9 + 7
n, m = [int(x) for x in input().split()]
S = pow(m, n, p)
k = opposite_element(m, p)
l = (2*m - 1) * k % p
q = opposite_element(l - 1, p)
if q != -1:
S += pow(m, n, p) * (pow(l, n, p) - 1) * q
S %= p
else:
S += pow(m, n, p) * k
S %= p
print(S)
``` | instruction | 0 | 102,532 | 12 | 205,064 |
No | output | 1 | 102,532 | 12 | 205,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a sequence a of n integers between 1 and m, inclusive, denote f(a) as the number of distinct subsequences of a (including the empty subsequence).
You are given two positive integers n and m. Let S be the set of all sequences of length n consisting of numbers from 1 to m. Compute the sum f(a) over all a in S modulo 109 + 7.
Input
The only line contains two integers n and m (1 β€ n, m β€ 106) β the number of elements in arrays and the upper bound for elements.
Output
Print the only integer c β the desired sum modulo 109 + 7.
Examples
Input
1 3
Output
6
Input
2 2
Output
14
Input
3 3
Output
174
Submitted Solution:
```
import math
def euclid_algorithm(a, b):
t1, t2 = abs(a), abs(b)
#saving equalities:
#t1 == x1 * a + y1 * b,
#t2 == x2 * a + y2 * b.
x1, y1, x2, y2 = int(math.copysign(1, a)), 0, 0, int(math.copysign(1, b))
if t1 < t2:
t1, t2 = t2, t1
x1, y1, x2, y2 = x2, y2, x1, y1
while t2 > 0:
k = int(t1 // t2)
t1, t2 = t2, t1 % t2
#t1 - k * t2 == (x1 - k * x2) * a + (y1 - k * y2) * b
x1, y1, x2, y2 = x2, y2, x1 - k * x2, y1 - k * y2
return t1, x1, y1
def opposite_element(x, p):
gcd, k, l = euclid_algorithm(x, p)
if gcd != 1:
return -1
return k % p
p = 10 ** 9 + 7
n, m = [int(x) for x in input().split()]
S = pow(m, n, p)
k = opposite_element(m, p)
l = (2*m - 1) * k % p
q = opposite_element(l - 1, p)
if q != -1:
S += pow(m, n, p) * (pow(l, n, p) - 1) * q
S %= p
else:
k1 = opposite_element(m, p)
S += pow(m-1, n, p) * k1
S %= p
print(S)
``` | instruction | 0 | 102,533 | 12 | 205,066 |
No | output | 1 | 102,533 | 12 | 205,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike has always been thinking about the harshness of social inequality. He's so obsessed with it that sometimes it even affects him while solving problems. At the moment, Mike has two sequences of positive integers A = [a1, a2, ..., an] and B = [b1, b2, ..., bn] of length n each which he uses to ask people some quite peculiar questions.
To test you on how good are you at spotting inequality in life, he wants you to find an "unfair" subset of the original sequence. To be more precise, he wants you to select k numbers P = [p1, p2, ..., pk] such that 1 β€ pi β€ n for 1 β€ i β€ k and elements in P are distinct. Sequence P will represent indices of elements that you'll select from both sequences. He calls such a subset P "unfair" if and only if the following conditions are satisfied: 2Β·(ap1 + ... + apk) is greater than the sum of all elements from sequence A, and 2Β·(bp1 + ... + bpk) is greater than the sum of all elements from the sequence B. Also, k should be smaller or equal to <image> because it will be to easy to find sequence P if he allowed you to select too many elements!
Mike guarantees you that a solution will always exist given the conditions described above, so please help him satisfy his curiosity!
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the sequences.
On the second line there are n space-separated integers a1, ..., an (1 β€ ai β€ 109) β elements of sequence A.
On the third line there are also n space-separated integers b1, ..., bn (1 β€ bi β€ 109) β elements of sequence B.
Output
On the first line output an integer k which represents the size of the found subset. k should be less or equal to <image>.
On the next line print k integers p1, p2, ..., pk (1 β€ pi β€ n) β the elements of sequence P. You can print the numbers in any order you want. Elements in sequence P should be distinct.
Example
Input
5
8 7 4 8 3
4 2 5 3 7
Output
3
1 4 5 | instruction | 0 | 102,566 | 12 | 205,132 |
Tags: constructive algorithms, sortings
Correct Solution:
```
n = int(input())
r = list(zip(map(int, input().split()), map(int, input().split()), [x for x in range(1, n + 1)]))
r.sort()
print("{}\n{}".format(n // 2 + 1, r[n - 1][2]), end=" ")
for i in range(n - 2, 0, -2):
print(r[i][1] < r[i - 1][1] and r[i - 1][2] or r[i][2], end=" ")
if (n & 1) == 0:
print(r[0][2])
``` | output | 1 | 102,566 | 12 | 205,133 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike has always been thinking about the harshness of social inequality. He's so obsessed with it that sometimes it even affects him while solving problems. At the moment, Mike has two sequences of positive integers A = [a1, a2, ..., an] and B = [b1, b2, ..., bn] of length n each which he uses to ask people some quite peculiar questions.
To test you on how good are you at spotting inequality in life, he wants you to find an "unfair" subset of the original sequence. To be more precise, he wants you to select k numbers P = [p1, p2, ..., pk] such that 1 β€ pi β€ n for 1 β€ i β€ k and elements in P are distinct. Sequence P will represent indices of elements that you'll select from both sequences. He calls such a subset P "unfair" if and only if the following conditions are satisfied: 2Β·(ap1 + ... + apk) is greater than the sum of all elements from sequence A, and 2Β·(bp1 + ... + bpk) is greater than the sum of all elements from the sequence B. Also, k should be smaller or equal to <image> because it will be to easy to find sequence P if he allowed you to select too many elements!
Mike guarantees you that a solution will always exist given the conditions described above, so please help him satisfy his curiosity!
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the sequences.
On the second line there are n space-separated integers a1, ..., an (1 β€ ai β€ 109) β elements of sequence A.
On the third line there are also n space-separated integers b1, ..., bn (1 β€ bi β€ 109) β elements of sequence B.
Output
On the first line output an integer k which represents the size of the found subset. k should be less or equal to <image>.
On the next line print k integers p1, p2, ..., pk (1 β€ pi β€ n) β the elements of sequence P. You can print the numbers in any order you want. Elements in sequence P should be distinct.
Example
Input
5
8 7 4 8 3
4 2 5 3 7
Output
3
1 4 5 | instruction | 0 | 102,567 | 12 | 205,134 |
Tags: constructive algorithms, sortings
Correct Solution:
```
n = int(input())
a= map(int, input().split())
b= map(int, input().split())
indice = sorted(zip(a, b, range(1, n + 1)),reverse=True)
rel=[]
rel.append(indice[0][2])
for i in range(1, n, 2):
tmp = indice[i][2]
if i < n-1 and indice[i+1][1] > indice[i][1]:
tmp = indice[i+1][2]
rel.append(tmp)
print(str(len(rel))+"\n")
print(*rel)
``` | output | 1 | 102,567 | 12 | 205,135 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike has always been thinking about the harshness of social inequality. He's so obsessed with it that sometimes it even affects him while solving problems. At the moment, Mike has two sequences of positive integers A = [a1, a2, ..., an] and B = [b1, b2, ..., bn] of length n each which he uses to ask people some quite peculiar questions.
To test you on how good are you at spotting inequality in life, he wants you to find an "unfair" subset of the original sequence. To be more precise, he wants you to select k numbers P = [p1, p2, ..., pk] such that 1 β€ pi β€ n for 1 β€ i β€ k and elements in P are distinct. Sequence P will represent indices of elements that you'll select from both sequences. He calls such a subset P "unfair" if and only if the following conditions are satisfied: 2Β·(ap1 + ... + apk) is greater than the sum of all elements from sequence A, and 2Β·(bp1 + ... + bpk) is greater than the sum of all elements from the sequence B. Also, k should be smaller or equal to <image> because it will be to easy to find sequence P if he allowed you to select too many elements!
Mike guarantees you that a solution will always exist given the conditions described above, so please help him satisfy his curiosity!
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the sequences.
On the second line there are n space-separated integers a1, ..., an (1 β€ ai β€ 109) β elements of sequence A.
On the third line there are also n space-separated integers b1, ..., bn (1 β€ bi β€ 109) β elements of sequence B.
Output
On the first line output an integer k which represents the size of the found subset. k should be less or equal to <image>.
On the next line print k integers p1, p2, ..., pk (1 β€ pi β€ n) β the elements of sequence P. You can print the numbers in any order you want. Elements in sequence P should be distinct.
Example
Input
5
8 7 4 8 3
4 2 5 3 7
Output
3
1 4 5 | instruction | 0 | 102,568 | 12 | 205,136 |
Tags: constructive algorithms, sortings
Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
c = list(range(n))
c = sorted(c, key=lambda x: -a[x])
print(n//2 + 1)
i = 0
while i < (n + 1) % 2 + 1:
print(c[i] + 1, end=' ')
i += 1
while i < n:
if b[c[i]] > b[c[i + 1]]:
print(c[i] + 1, end=' ')
else:
print(c[i + 1] + 1, end=' ')
i += 2
``` | output | 1 | 102,568 | 12 | 205,137 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike has always been thinking about the harshness of social inequality. He's so obsessed with it that sometimes it even affects him while solving problems. At the moment, Mike has two sequences of positive integers A = [a1, a2, ..., an] and B = [b1, b2, ..., bn] of length n each which he uses to ask people some quite peculiar questions.
To test you on how good are you at spotting inequality in life, he wants you to find an "unfair" subset of the original sequence. To be more precise, he wants you to select k numbers P = [p1, p2, ..., pk] such that 1 β€ pi β€ n for 1 β€ i β€ k and elements in P are distinct. Sequence P will represent indices of elements that you'll select from both sequences. He calls such a subset P "unfair" if and only if the following conditions are satisfied: 2Β·(ap1 + ... + apk) is greater than the sum of all elements from sequence A, and 2Β·(bp1 + ... + bpk) is greater than the sum of all elements from the sequence B. Also, k should be smaller or equal to <image> because it will be to easy to find sequence P if he allowed you to select too many elements!
Mike guarantees you that a solution will always exist given the conditions described above, so please help him satisfy his curiosity!
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the sequences.
On the second line there are n space-separated integers a1, ..., an (1 β€ ai β€ 109) β elements of sequence A.
On the third line there are also n space-separated integers b1, ..., bn (1 β€ bi β€ 109) β elements of sequence B.
Output
On the first line output an integer k which represents the size of the found subset. k should be less or equal to <image>.
On the next line print k integers p1, p2, ..., pk (1 β€ pi β€ n) β the elements of sequence P. You can print the numbers in any order you want. Elements in sequence P should be distinct.
Example
Input
5
8 7 4 8 3
4 2 5 3 7
Output
3
1 4 5 | instruction | 0 | 102,569 | 12 | 205,138 |
Tags: constructive algorithms, sortings
Correct Solution:
```
n = int(input())
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
idAB = zip(range(n), A, B)
idAB = sorted(idAB, key=lambda x: x[1], reverse=True)
ans = [idAB[0][0] + 1]
i = 1
while i < n:
try:
choice = max(idAB[i], idAB[i + 1], key=lambda x: x[2])
ans.append(choice[0] + 1)
i += 2
except IndexError:
ans.append(idAB[-1][0] + 1)
i += 1
ans = sorted(ans)
print(len(ans))
print(*ans)
``` | output | 1 | 102,569 | 12 | 205,139 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike has always been thinking about the harshness of social inequality. He's so obsessed with it that sometimes it even affects him while solving problems. At the moment, Mike has two sequences of positive integers A = [a1, a2, ..., an] and B = [b1, b2, ..., bn] of length n each which he uses to ask people some quite peculiar questions.
To test you on how good are you at spotting inequality in life, he wants you to find an "unfair" subset of the original sequence. To be more precise, he wants you to select k numbers P = [p1, p2, ..., pk] such that 1 β€ pi β€ n for 1 β€ i β€ k and elements in P are distinct. Sequence P will represent indices of elements that you'll select from both sequences. He calls such a subset P "unfair" if and only if the following conditions are satisfied: 2Β·(ap1 + ... + apk) is greater than the sum of all elements from sequence A, and 2Β·(bp1 + ... + bpk) is greater than the sum of all elements from the sequence B. Also, k should be smaller or equal to <image> because it will be to easy to find sequence P if he allowed you to select too many elements!
Mike guarantees you that a solution will always exist given the conditions described above, so please help him satisfy his curiosity!
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the sequences.
On the second line there are n space-separated integers a1, ..., an (1 β€ ai β€ 109) β elements of sequence A.
On the third line there are also n space-separated integers b1, ..., bn (1 β€ bi β€ 109) β elements of sequence B.
Output
On the first line output an integer k which represents the size of the found subset. k should be less or equal to <image>.
On the next line print k integers p1, p2, ..., pk (1 β€ pi β€ n) β the elements of sequence P. You can print the numbers in any order you want. Elements in sequence P should be distinct.
Example
Input
5
8 7 4 8 3
4 2 5 3 7
Output
3
1 4 5 | instruction | 0 | 102,570 | 12 | 205,140 |
Tags: constructive algorithms, sortings
Correct Solution:
```
n=int(input())
a=[[] for i in range(1,n+2)]
b=[[]for i in range(1,n+2)]
cnt=0
for i in input().split():
cnt+=1
a[cnt]=[-int(i),cnt]
cnt=0
for i in input().split():
cnt+=1
b[cnt]=[-int(i),cnt]
node=[]
use=[0 for i in range(1,n+3)]
if n%2==0:
a.sort()
for i in range(1,n+1,2):
if -b[a[i][1]][0]>-b[a[i+1][1]][0]:
node.append(a[i][1])
use[a[i][1]]=1
else:
node.append(a[i+1][1])
use[a[i+1][1]]=1
for i in range(1,n+1):
if use[a[i][1]]==0:
node.append(a[i][1])
break
if n%2==1:
a.sort()
use[a[1][1]]=1
node.append(a[1][1])
for i in range(2,n+1,2):
if -b[a[i][1]][0]>-b[a[i+1][1]][0]:
node.append(a[i][1])
use[a[i][1]]=1
else:
node.append(a[i+1][1])
use[a[i+1][1]]=1
print(len(node))
for i in range(len(node)):
print(int(node[i]),end=" ")
``` | output | 1 | 102,570 | 12 | 205,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike has always been thinking about the harshness of social inequality. He's so obsessed with it that sometimes it even affects him while solving problems. At the moment, Mike has two sequences of positive integers A = [a1, a2, ..., an] and B = [b1, b2, ..., bn] of length n each which he uses to ask people some quite peculiar questions.
To test you on how good are you at spotting inequality in life, he wants you to find an "unfair" subset of the original sequence. To be more precise, he wants you to select k numbers P = [p1, p2, ..., pk] such that 1 β€ pi β€ n for 1 β€ i β€ k and elements in P are distinct. Sequence P will represent indices of elements that you'll select from both sequences. He calls such a subset P "unfair" if and only if the following conditions are satisfied: 2Β·(ap1 + ... + apk) is greater than the sum of all elements from sequence A, and 2Β·(bp1 + ... + bpk) is greater than the sum of all elements from the sequence B. Also, k should be smaller or equal to <image> because it will be to easy to find sequence P if he allowed you to select too many elements!
Mike guarantees you that a solution will always exist given the conditions described above, so please help him satisfy his curiosity!
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the sequences.
On the second line there are n space-separated integers a1, ..., an (1 β€ ai β€ 109) β elements of sequence A.
On the third line there are also n space-separated integers b1, ..., bn (1 β€ bi β€ 109) β elements of sequence B.
Output
On the first line output an integer k which represents the size of the found subset. k should be less or equal to <image>.
On the next line print k integers p1, p2, ..., pk (1 β€ pi β€ n) β the elements of sequence P. You can print the numbers in any order you want. Elements in sequence P should be distinct.
Example
Input
5
8 7 4 8 3
4 2 5 3 7
Output
3
1 4 5 | instruction | 0 | 102,571 | 12 | 205,142 |
Tags: constructive algorithms, sortings
Correct Solution:
```
n=int(input());
a=list(map(int,input().split()));
b=list(map(int,input().split()));
p=sorted(zip(range(1,n+1),a,b),key=lambda x:-x[1]);
ans=[p[0][0]];
for i in range(1,n,2): ans.append(max(p[i:i+2],key=lambda x:x[2])[0]);
ans=sorted(ans);
print(len(ans));
print(*ans);
``` | output | 1 | 102,571 | 12 | 205,143 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike has always been thinking about the harshness of social inequality. He's so obsessed with it that sometimes it even affects him while solving problems. At the moment, Mike has two sequences of positive integers A = [a1, a2, ..., an] and B = [b1, b2, ..., bn] of length n each which he uses to ask people some quite peculiar questions.
To test you on how good are you at spotting inequality in life, he wants you to find an "unfair" subset of the original sequence. To be more precise, he wants you to select k numbers P = [p1, p2, ..., pk] such that 1 β€ pi β€ n for 1 β€ i β€ k and elements in P are distinct. Sequence P will represent indices of elements that you'll select from both sequences. He calls such a subset P "unfair" if and only if the following conditions are satisfied: 2Β·(ap1 + ... + apk) is greater than the sum of all elements from sequence A, and 2Β·(bp1 + ... + bpk) is greater than the sum of all elements from the sequence B. Also, k should be smaller or equal to <image> because it will be to easy to find sequence P if he allowed you to select too many elements!
Mike guarantees you that a solution will always exist given the conditions described above, so please help him satisfy his curiosity!
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the sequences.
On the second line there are n space-separated integers a1, ..., an (1 β€ ai β€ 109) β elements of sequence A.
On the third line there are also n space-separated integers b1, ..., bn (1 β€ bi β€ 109) β elements of sequence B.
Output
On the first line output an integer k which represents the size of the found subset. k should be less or equal to <image>.
On the next line print k integers p1, p2, ..., pk (1 β€ pi β€ n) β the elements of sequence P. You can print the numbers in any order you want. Elements in sequence P should be distinct.
Example
Input
5
8 7 4 8 3
4 2 5 3 7
Output
3
1 4 5 | instruction | 0 | 102,572 | 12 | 205,144 |
Tags: constructive algorithms, sortings
Correct Solution:
```
n = int(input())
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
idAB = zip(range(n), A, B)
idAB = sorted(idAB, key=lambda x: x[1], reverse=True)
ans = [idAB[0][0] + 1]
i = 1
while i < n:
choice = max(idAB[i:i + 2], key=lambda x: x[2])
ans.append(choice[0] + 1)
i += 2
ans = sorted(ans)
print(len(ans))
print(*ans)
``` | output | 1 | 102,572 | 12 | 205,145 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mike has always been thinking about the harshness of social inequality. He's so obsessed with it that sometimes it even affects him while solving problems. At the moment, Mike has two sequences of positive integers A = [a1, a2, ..., an] and B = [b1, b2, ..., bn] of length n each which he uses to ask people some quite peculiar questions.
To test you on how good are you at spotting inequality in life, he wants you to find an "unfair" subset of the original sequence. To be more precise, he wants you to select k numbers P = [p1, p2, ..., pk] such that 1 β€ pi β€ n for 1 β€ i β€ k and elements in P are distinct. Sequence P will represent indices of elements that you'll select from both sequences. He calls such a subset P "unfair" if and only if the following conditions are satisfied: 2Β·(ap1 + ... + apk) is greater than the sum of all elements from sequence A, and 2Β·(bp1 + ... + bpk) is greater than the sum of all elements from the sequence B. Also, k should be smaller or equal to <image> because it will be to easy to find sequence P if he allowed you to select too many elements!
Mike guarantees you that a solution will always exist given the conditions described above, so please help him satisfy his curiosity!
Input
The first line contains integer n (1 β€ n β€ 105) β the number of elements in the sequences.
On the second line there are n space-separated integers a1, ..., an (1 β€ ai β€ 109) β elements of sequence A.
On the third line there are also n space-separated integers b1, ..., bn (1 β€ bi β€ 109) β elements of sequence B.
Output
On the first line output an integer k which represents the size of the found subset. k should be less or equal to <image>.
On the next line print k integers p1, p2, ..., pk (1 β€ pi β€ n) β the elements of sequence P. You can print the numbers in any order you want. Elements in sequence P should be distinct.
Example
Input
5
8 7 4 8 3
4 2 5 3 7
Output
3
1 4 5 | instruction | 0 | 102,573 | 12 | 205,146 |
Tags: constructive algorithms, sortings
Correct Solution:
```
from functools import cmp_to_key
N = int( input() )
A = list( map( int, input().split() ) )
B = list( map( int, input().split() ) )
ord = sorted( list( i for i in range( N ) ), key = cmp_to_key( lambda x, y: A[ y ] - A[ x ] ) )
ans = [ ord[ 0 ] ]
for i in range( 1, N, 2 ):
if i + 1 == N:
ans.append( ord[ i ] )
else:
if B[ ord[ i ] ] >= B[ ord[ i + 1 ] ]:
ans.append( ord[ i ] )
else:
ans.append( ord[ i + 1 ] )
print( len( ans ) )
print( *list( map( lambda x: x + 1, ans ) ) )
``` | output | 1 | 102,573 | 12 | 205,147 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 β€ x < y < z β€ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (β n/3 β + 12) operations. Here β q β denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 1) β the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 β€ m β€ (β n/3 β + 12)) β the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations β the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed β 5/3 β + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero. | instruction | 0 | 102,901 | 12 | 205,802 |
Tags: constructive algorithms
Correct Solution:
```
l = [((1 << i) | (1 << (i + j)) | (1 << (i + j * 2)), i, j) for i in range(6) for j in range(1, 6) if i + j * 2 < 11]
six = [None] * (1 << 6)
for i in range(len(l)):
for j in range(i + 1, len(l)):
six[(l[i][0] ^ l[j][0]) & 0b111111] = (l[i][1:], l[j][1:])
n = int(input())
s = input().split()
cur = 0
ans = []
while len(s) - cur > 11:
part = int(''.join(s[cur:cur + 6])[::-1], 2)
if not part:
cur += 6
continue
(i, j), (u, v) = six[part]
ans.append((cur + i, cur + i + j, cur + i + j * 2))
ans.append((cur + u, cur + u + v, cur + u + v * 2))
for i in ans[-2:]:
for j in i:
try:
s[j] = {'0': '1', '1': '0'}[s[j]]
except:
print(s[j])
exit()
cur += 6
cur = max(0, min(cur, len(s) - 8))
l = [((1 << i) | (1 << (i + j)) | (1 << (i + j * 2)), i, j) for i in range(len(s) - cur) for j in (1, 3) if i + j * 2 < len(s) - cur]
lt = {1 << i: i for i in range(len(l))}
bit = [[] for _ in range(1 << len(l))]
for i in range(1, 1 << len(l)):
bit[i] = bit[i - (i & -i)][:]
bit[i].append(l[lt[i & -i]])
eight = {}
for b in bit:
res, a = 0, []
for i in b:
res ^= i[0]
a.append(i[1:])
if res in eight and len(eight[res]) <= len(a):
continue
eight[res] = a
part = int(''.join(s[cur:])[::-1], 2)
if part not in eight:
print('NO')
exit()
for u, v in eight[part]:
ans.append((cur + u, cur + u + v, cur + u + v * 2))
for j in ans[-1]:
s[j] = {'0': '1', '1': '0'}[s[j]]
print('YES')
print(len(ans))
for i in ans:
print(*map(lambda x: x + 1, i))
``` | output | 1 | 102,901 | 12 | 205,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 β€ x < y < z β€ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (β n/3 β + 12) operations. Here β q β denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 1) β the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 β€ m β€ (β n/3 β + 12)) β the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations β the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed β 5/3 β + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero. | instruction | 0 | 102,902 | 12 | 205,804 |
Tags: constructive algorithms
Correct Solution:
```
def solve(a):
l = len(a)
d = sum(a[i] * 2 ** i for i in range(l))
if d == 0:
return []
usable = []
if l >= 3:
for i in range(l - 2):
usable.append(0b111 << i)
if l >= 5:
for i in range(l - 4):
usable.append(0b10101 << i)
if l >= 7:
for i in range(l - 6):
usable.append(0b1001001 << i)
ul = len(usable)
best_answer = None
for mask in range(1 << ul):
start = 0
clone = mask
cnt = 0
while clone:
if clone % 2 == 1:
start ^= usable[cnt]
clone //= 2
cnt += 1
if start == d:
answer = []
clone = mask
cnt = 0
while clone:
if clone % 2 == 1:
answer.append([])
used = usable[cnt]
cnt2 = 1
while used:
if used % 2 == 1:
answer[-1].append(cnt2)
cnt2 += 1
used //= 2
clone //= 2
cnt += 1
if best_answer is None or len(best_answer) > len(answer):
best_answer = answer
return best_answer
if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))
if len(a) <= 10:
sol = solve(a)
if sol is None:
print("NO")
exit(0)
print("YES")
print(len(sol))
for t in sol:
print(' '.join(map(str, t)))
exit(0)
operations = []
while len(a) > 10:
l = len(a)
last = a[-3:]
if last == [1, 1, 1]:
operations.append([l - 2, l - 1, l])
elif last == [1, 1, 0]:
operations.append([l - 3, l - 2, l - 1])
a[-4] ^= 1
elif last == [1, 0, 1]:
operations.append([l - 4, l - 2, l])
a[-5] ^= 1
elif last == [0, 1, 1]:
nxt = a[-6:-3]
if nxt == [1, 1, 1]:
operations.append([l - 8, l - 4, l])
operations.append([l - 5, l - 3, l - 1])
a[-9] ^= 1
elif nxt == [1, 1, 0]:
operations.append([l - 8, l - 4, l])
operations.append([l - 9, l - 5, l - 1])
a[-9] ^= 1
a[-10] ^= 1
elif nxt == [1, 0, 1]:
operations.append([l - 6, l - 3, l])
operations.append([l - 9, l - 5, l - 1])
a[-7] ^= 1
a[-10] ^= 1
elif nxt == [0, 1, 1]:
operations.append([l - 6, l - 3, l])
operations.append([l - 7, l - 4, l - 1])
a[-7] ^= 1
a[-8] ^= 1
elif nxt == [1, 0, 0]:
operations.append([l - 2, l - 1, l])
operations.append([l - 8, l - 5, l - 2])
a[-9] ^= 1
elif nxt == [0, 1, 0]:
operations.append([l - 2, l - 1, l])
operations.append([l - 6, l - 4, l - 2])
a[-7] ^= 1
elif nxt == [0, 0, 1]:
operations.append([l - 10, l - 5, l])
operations.append([l - 5, l - 3, l - 1])
a[-11] ^= 1
elif nxt == [0, 0, 0]:
operations.append([l - 8, l - 4, l])
operations.append([l - 7, l - 4, l - 1])
a[-9] ^= 1
a[-8] ^= 1
a.pop()
a.pop()
a.pop()
elif last == [1, 0, 0]:
operations.append([l - 4, l - 3, l - 2])
a[-5] ^= 1
a[-4] ^= 1
elif last == [0, 1, 0]:
operations.append([l - 5, l - 3, l - 1])
a[-6] ^= 1
a[-4] ^= 1
elif last == [0, 0, 1]:
operations.append([l - 6, l - 3, l])
a[-7] ^= 1
a[-4] ^= 1
a.pop()
a.pop()
a.pop()
while len(a) < 8:
a.append(0)
sol = solve(a)
print("YES")
sol = operations + sol
print(len(sol))
for t in sol:
print(' '.join(map(str, t)))
``` | output | 1 | 102,902 | 12 | 205,805 |
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 that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 β€ x < y < z β€ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (β n/3 β + 12) operations. Here β q β denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 1) β the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 β€ m β€ (β n/3 β + 12)) β the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations β the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed β 5/3 β + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero.
Submitted Solution:
```
n=int(input())
a=input().split()
if n>3:
print("YES")
print(2)
print(1,3,5)
print(2,3,4)
else:
print("NO")
``` | instruction | 0 | 102,903 | 12 | 205,806 |
No | output | 1 | 102,903 | 12 | 205,807 |
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 that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 β€ x < y < z β€ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (β n/3 β + 12) operations. Here β q β denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 1) β the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 β€ m β€ (β n/3 β + 12)) β the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations β the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed β 5/3 β + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero.
Submitted Solution:
```
n = int(input())
k = list(map(int, input().split()))
mem=[]
count=0
for x in range(1,n):
for y in range(x+1,n):
for z in range(y+1,n):
if y - x == z - y:
if k[x] == 1:
k[x] = 0
else:
k[x] = 1
if k[y] == 1:
k[y] = 0
else:
k[z] = 1
if k[x] == 1:
k[z] = 0
else:
k[z] = 1
mem.append([x,y,z])
count+=1
if k.count(0) == n:
break
if count == 0:
print("NO")
else:
print("YES")
print(count)
for l in range(0,count):
print(mem[l])
``` | instruction | 0 | 102,904 | 12 | 205,808 |
No | output | 1 | 102,904 | 12 | 205,809 |
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 that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 β€ x < y < z β€ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (β n/3 β + 12) operations. Here β q β denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 1) β the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 β€ m β€ (β n/3 β + 12)) β the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations β the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed β 5/3 β + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero.
Submitted Solution:
```
def solve(a):
l = len(a)
d = sum(a[i] * 2 ** i for i in range(l))
if d == 0:
return []
usable = []
if l >= 3:
for i in range(l - 2):
usable.append(0b111 << i)
if l >= 5:
for i in range(l - 4):
usable.append(0b10101 << i)
if l >= 7:
for i in range(l - 6):
usable.append(0b1001001 << i)
ul = len(usable)
for mask in range(1 << ul):
start = 0
clone = mask
cnt = 0
while clone:
if clone % 2 == 1:
start ^= usable[cnt]
clone //= 2
cnt += 1
if start == d:
answer = []
clone = mask
cnt = 0
while clone:
if clone % 2 == 1:
answer.append([])
used = usable[cnt]
cnt2 = 1
while used:
if used % 2 == 1:
answer[-1].append(cnt2)
cnt2 += 1
used //= 2
clone //= 2
cnt += 1
return answer
if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))
if len(a) <= 10:
sol = solve(a)
if sol is None:
print("NO")
exit(0)
print("YES")
print(len(sol))
for t in sol:
print(' '.join(map(str, t)))
exit(0)
operations = []
while len(a) > 10:
l = len(a)
last = a[-3:]
if last == [1, 1, 1]:
operations.append([l - 2, l - 1, l])
elif last == [1, 1, 0]:
operations.append([l - 3, l - 2, l - 1])
a[-4] ^= 1
elif last == [1, 0, 1]:
operations.append([l - 4, l - 2, l])
a[-5] ^= 1
elif last == [0, 1, 1]:
nxt = a[-6:-3]
if nxt == [1, 1, 1]:
operations.append([l - 8, l - 4, l])
operations.append([l - 5, l - 3, l - 1])
a[-9] ^= 1
elif nxt == [1, 1, 0]:
operations.append([l - 8, l - 4, l])
operations.append([l - 9, l - 5, l - 1])
a[-9] ^= 1
a[-10] ^= 1
elif nxt == [1, 0, 1]:
operations.append([l - 6, l - 3, l])
operations.append([l - 9, l - 5, l - 1])
a[-7] ^= 1
a[-10] ^= 1
elif nxt == [0, 1, 1]:
operations.append([l - 6, l - 3, l])
operations.append([l - 7, l - 4, l - 1])
a[-7] ^= 1
a[-8] ^= 1
elif nxt == [1, 0, 0]:
operations.append([l - 2, l - 1, l])
operations.append([l - 8, l - 5, l - 2])
a[-9] ^= 1
elif nxt == [0, 1, 0]:
operations.append([l - 2, l - 1, l])
operations.append([l - 6, l - 4, l - 2])
a[-7] ^= 1
elif nxt == [0, 0, 1]:
operations.append([l - 10, l - 5, l])
operations.append([l - 5, l - 3, l - 1])
a[-11] ^= 1
elif nxt == [0, 0, 0]:
operations.append([l - 8, l - 4, l])
operations.append([l - 7, l - 4, l - 1])
a[-9] ^= 1
a[-10] ^= 1
a.pop()
a.pop()
a.pop()
elif last == [1, 0, 0]:
operations.append([l - 4, l - 3, l - 2])
a[-5] ^= 1
a[-4] ^= 1
elif last == [0, 1, 0]:
operations.append([l - 5, l - 3, l - 1])
a[-6] ^= 1
a[-4] ^= 1
elif last == [0, 0, 1]:
operations.append([l - 6, l - 3, l])
a[-7] ^= 1
a[-4] ^= 1
a.pop()
a.pop()
a.pop()
while len(a) < 8:
a.append(0)
sol = solve(a)
print("YES")
sol = operations + sol
print(len(sol))
for t in sol:
print(' '.join(map(str, t)))
``` | instruction | 0 | 102,905 | 12 | 205,810 |
No | output | 1 | 102,905 | 12 | 205,811 |
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 that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 β€ x < y < z β€ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (β n/3 β + 12) operations. Here β q β denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 1) β the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 β€ m β€ (β n/3 β + 12)) β the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations β the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed β 5/3 β + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero.
Submitted Solution:
```
l = [((1 << i) | (1 << (i + j)) | (1 << (i + j * 2)), i, j) for i in range(6) for j in range(1, 6) if i + j * 2 < 11]
six = [None] * (1 << 6)
for i in range(len(l)):
for j in range(i + 1, len(l)):
six[(l[i][0] ^ l[j][0]) & 0b111111] = (l[i][1:], l[j][1:])
n = int(input())
s = input().split()
cur = 0
ans = []
while len(s) - cur > 8:
part = int(''.join(s[cur:cur + 6])[::-1], 2)
(i, j), (u, v) = six[part]
ans.append((cur + i, cur + i + j, cur + i + j * 2))
ans.append((cur + u, cur + u + v, cur + u + v * 2))
for i in ans[-2:]:
for j in i:
s[j] = {'0': '1', '1': '0'}[s[j]]
cur += 6
l = [((1 << i) | (1 << (i + j)) | (1 << (i + j * 2)), i, j) for i in range(len(s) - cur) for j in (1, 3) if i + j * 2 < len(s) - cur]
lt = {1 << i: i for i in range(len(l))}
bit = [[] for _ in range(1 << len(l))]
for i in range(1, 1 << len(l)):
bit[i] = bit[i - (i & -i)][:]
bit[i].append(l[lt[i & -i]])
eight = {}
for b in bit:
res, a = 0, []
for i in b:
res ^= i[0]
a.append(i[1:])
if res in eight and len(eight[res]) <= len(a):
continue
eight[res] = a
part = int(''.join(s[cur:])[::-1], 2)
if part not in eight:
print('NO')
exit()
for u, v in eight[part]:
ans.append((cur + u, cur + u + v, cur + u + v * 2))
for j in ans[-1]:
s[j] = {'0': '1', '1': '0'}[s[j]]
print('YES')
print(len(ans))
for i in ans:
print(*map(lambda x: x + 1, i))
``` | instruction | 0 | 102,906 | 12 | 205,812 |
No | output | 1 | 102,906 | 12 | 205,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One Saturday afternoon Egor was playing his favorite RPG game. While discovering new lands and territories, he came across the following sign:
<image>
Egor is a passionate player, but he is an algorithmician as well. That's why he instantly spotted four common letters in two words on the sign above β if we permute the letters "R", "E", "G", "O" from the first word, we can obtain the letters "O", "G", "R", "E". Egor got inspired by the sign and right away he came up with a problem about permutations.
You are given a permutation of length n. You have to split it into some non-empty subsequences so that each element of the permutation belongs to exactly one subsequence. Each subsequence must be monotonic β that is, either increasing or decreasing.
Sequence is called to be a subsequence if it can be derived from permutation by deleting some (possibly none) elements without changing the order of the remaining elements.
The number of subsequences should be small enough β let f(n) be the minimum integer k such that every permutation of length n can be partitioned into at most k monotonic subsequences.
You need to split the permutation into at most f(n) monotonic subsequences.
Input
The first line contains one integer t (1 β€ t β€ 10^5) β the number of test cases.
You can only use t = 1 in hacks.
Next, descriptions of t test cases come, each of them in the following format.
The first line of a single test case contains one integer n (1 β€ n β€ 10^5) β the length of the permutation. The second line contains n distinct integers a_i (1 β€ a_i β€ n) β the permutation itself.
The sum of the values of n over all test cases doesn't exceed 10^5.
Output
For each test case print the answer in the following format:
In the first line print k (1 β€ k β€ f(n)) β the number of the subsequences in the partition. In the next k lines, print the descriptions of found subsequences. Each description should start with a number l_i (1 β€ l_i β€ n) β the length of the corresponding subsequence, followed by l_i integers β the values of this subsequence in the order in which they occur in the permutation.
Each subsequence you output must be either increasing or decreasing.
In case there are multiple possible answers, print any of them.
Example
Input
3
4
4 3 1 2
6
4 5 6 1 3 2
10
1 2 3 4 5 6 7 8 9 10
Output
2
3 4 3 1
1 2
3
2 4 1
2 5 6
2 3 2
1
10 1 2 3 4 5 6 7 8 9 10
Note
In the example, we can split:
* [4, 3, 1, 2] into [4, 3, 1], [2]
* [4, 5, 6, 1, 3, 2] into [4, 1], [5, 6] and [3, 2]
* [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] into [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Surely, there are many more answers possible.
Submitted Solution:
```
def longest_increasing_subsequence(X):
"""Returns the Longest Increasing Subsequence in the Given List/Array"""
N = len(X)
P = [0] * N
M = [0] * (N+1)
L = 0
for i in range(N):
lo = 1
hi = L
while lo <= hi:
mid = (lo+hi)//2
if (X[M[mid]] < X[i]):
lo = mid+1
else:
hi = mid-1
newL = lo
P[i] = M[newL-1]
M[newL] = i
if (newL > L):
L = newL
S = []
k = M[L]
for i in range(L-1, -1, -1):
S.append(X[k])
k = P[k]
return S[::-1]
def nos(lis):
flag = 0
count = 0
terms = []
while(len(lis) != 0):
forw = longest_increasing_subsequence(lis)
back = longest_increasing_subsequence(lis[::-1])
if(len(forw) >= len(back)):
for i in forw:
lis.remove(i)
terms.append(forw)
count += 1
elif(len(back) > len(forw)):
for i in back:
lis.remove(i)
terms.append(back)
count += 1
else:
lisf = lis.copy()
lisb = lis.copy()
for i in forw:
lisf.remove(i)
for i in back:
lisb.remove(i)
a, x = nos(lisf)
b, y = nos(lisb)
if( a <= b):
lis = []
terms = terms + x
count += a
else:
lis = []
terms = terms + y
count += b
return(count, terms)
cases = int(input())
for case in range(cases):
n = int(input())
perm = [int(x) for x in input().split()]
k, terms = nos(perm)
print(k)
for j in terms:
print(len(j), " ".join([str(x) for x in j]))
``` | instruction | 0 | 102,920 | 12 | 205,840 |
No | output | 1 | 102,920 | 12 | 205,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One Saturday afternoon Egor was playing his favorite RPG game. While discovering new lands and territories, he came across the following sign:
<image>
Egor is a passionate player, but he is an algorithmician as well. That's why he instantly spotted four common letters in two words on the sign above β if we permute the letters "R", "E", "G", "O" from the first word, we can obtain the letters "O", "G", "R", "E". Egor got inspired by the sign and right away he came up with a problem about permutations.
You are given a permutation of length n. You have to split it into some non-empty subsequences so that each element of the permutation belongs to exactly one subsequence. Each subsequence must be monotonic β that is, either increasing or decreasing.
Sequence is called to be a subsequence if it can be derived from permutation by deleting some (possibly none) elements without changing the order of the remaining elements.
The number of subsequences should be small enough β let f(n) be the minimum integer k such that every permutation of length n can be partitioned into at most k monotonic subsequences.
You need to split the permutation into at most f(n) monotonic subsequences.
Input
The first line contains one integer t (1 β€ t β€ 10^5) β the number of test cases.
You can only use t = 1 in hacks.
Next, descriptions of t test cases come, each of them in the following format.
The first line of a single test case contains one integer n (1 β€ n β€ 10^5) β the length of the permutation. The second line contains n distinct integers a_i (1 β€ a_i β€ n) β the permutation itself.
The sum of the values of n over all test cases doesn't exceed 10^5.
Output
For each test case print the answer in the following format:
In the first line print k (1 β€ k β€ f(n)) β the number of the subsequences in the partition. In the next k lines, print the descriptions of found subsequences. Each description should start with a number l_i (1 β€ l_i β€ n) β the length of the corresponding subsequence, followed by l_i integers β the values of this subsequence in the order in which they occur in the permutation.
Each subsequence you output must be either increasing or decreasing.
In case there are multiple possible answers, print any of them.
Example
Input
3
4
4 3 1 2
6
4 5 6 1 3 2
10
1 2 3 4 5 6 7 8 9 10
Output
2
3 4 3 1
1 2
3
2 4 1
2 5 6
2 3 2
1
10 1 2 3 4 5 6 7 8 9 10
Note
In the example, we can split:
* [4, 3, 1, 2] into [4, 3, 1], [2]
* [4, 5, 6, 1, 3, 2] into [4, 1], [5, 6] and [3, 2]
* [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] into [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Surely, there are many more answers possible.
Submitted Solution:
```
print("114")
``` | instruction | 0 | 102,921 | 12 | 205,842 |
No | output | 1 | 102,921 | 12 | 205,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One Saturday afternoon Egor was playing his favorite RPG game. While discovering new lands and territories, he came across the following sign:
<image>
Egor is a passionate player, but he is an algorithmician as well. That's why he instantly spotted four common letters in two words on the sign above β if we permute the letters "R", "E", "G", "O" from the first word, we can obtain the letters "O", "G", "R", "E". Egor got inspired by the sign and right away he came up with a problem about permutations.
You are given a permutation of length n. You have to split it into some non-empty subsequences so that each element of the permutation belongs to exactly one subsequence. Each subsequence must be monotonic β that is, either increasing or decreasing.
Sequence is called to be a subsequence if it can be derived from permutation by deleting some (possibly none) elements without changing the order of the remaining elements.
The number of subsequences should be small enough β let f(n) be the minimum integer k such that every permutation of length n can be partitioned into at most k monotonic subsequences.
You need to split the permutation into at most f(n) monotonic subsequences.
Input
The first line contains one integer t (1 β€ t β€ 10^5) β the number of test cases.
You can only use t = 1 in hacks.
Next, descriptions of t test cases come, each of them in the following format.
The first line of a single test case contains one integer n (1 β€ n β€ 10^5) β the length of the permutation. The second line contains n distinct integers a_i (1 β€ a_i β€ n) β the permutation itself.
The sum of the values of n over all test cases doesn't exceed 10^5.
Output
For each test case print the answer in the following format:
In the first line print k (1 β€ k β€ f(n)) β the number of the subsequences in the partition. In the next k lines, print the descriptions of found subsequences. Each description should start with a number l_i (1 β€ l_i β€ n) β the length of the corresponding subsequence, followed by l_i integers β the values of this subsequence in the order in which they occur in the permutation.
Each subsequence you output must be either increasing or decreasing.
In case there are multiple possible answers, print any of them.
Example
Input
3
4
4 3 1 2
6
4 5 6 1 3 2
10
1 2 3 4 5 6 7 8 9 10
Output
2
3 4 3 1
1 2
3
2 4 1
2 5 6
2 3 2
1
10 1 2 3 4 5 6 7 8 9 10
Note
In the example, we can split:
* [4, 3, 1, 2] into [4, 3, 1], [2]
* [4, 5, 6, 1, 3, 2] into [4, 1], [5, 6] and [3, 2]
* [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] into [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Surely, there are many more answers possible.
Submitted Solution:
```
def longest_increasing_subsequence(X):
"""Returns the Longest Increasing Subsequence in the Given List/Array"""
N = len(X)
P = [0] * N
M = [0] * (N+1)
L = 0
for i in range(N):
lo = 1
hi = L
while lo <= hi:
mid = (lo+hi)//2
if (X[M[mid]] < X[i]):
lo = mid+1
else:
hi = mid-1
newL = lo
P[i] = M[newL-1]
M[newL] = i
if (newL > L):
L = newL
S = []
k = M[L]
for i in range(L-1, -1, -1):
S.append(X[k])
k = P[k]
return S[::-1]
def nos(lis):
flag = 0
count = 0
terms = []
while(len(lis) != 0):
forw = longest_increasing_subsequence(lis)
back = longest_increasing_subsequence(lis[::-1])
if(len(forw) >= len(back)):
for i in forw:
lis.remove(i)
terms.append(forw)
count += 1
elif(len(back) > len(forw)):
for i in back:
lis.remove(i)
terms.append(back)
count += 1
else:
lisf = lis.copy()
lisb = lis.copy()
for i in forw:
lisf.remove(i)
for i in back:
lisb.remove(i)
a, x = nos(lisf)
b, y = nos(lisb)
if( a <= b):
lis = []
terms = terms + x
count += a
else:
lis = []
terms = terms + y
count += b
return(count, terms)
cases = int(input())
for case in range(cases):
n = int(input())
perm = [int(x) for x in input().split()]
k, terms = nos(perm)
print(k)
for j in terms:
print(" ".join([str(x) for x in j]))
``` | instruction | 0 | 102,922 | 12 | 205,844 |
No | output | 1 | 102,922 | 12 | 205,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One Saturday afternoon Egor was playing his favorite RPG game. While discovering new lands and territories, he came across the following sign:
<image>
Egor is a passionate player, but he is an algorithmician as well. That's why he instantly spotted four common letters in two words on the sign above β if we permute the letters "R", "E", "G", "O" from the first word, we can obtain the letters "O", "G", "R", "E". Egor got inspired by the sign and right away he came up with a problem about permutations.
You are given a permutation of length n. You have to split it into some non-empty subsequences so that each element of the permutation belongs to exactly one subsequence. Each subsequence must be monotonic β that is, either increasing or decreasing.
Sequence is called to be a subsequence if it can be derived from permutation by deleting some (possibly none) elements without changing the order of the remaining elements.
The number of subsequences should be small enough β let f(n) be the minimum integer k such that every permutation of length n can be partitioned into at most k monotonic subsequences.
You need to split the permutation into at most f(n) monotonic subsequences.
Input
The first line contains one integer t (1 β€ t β€ 10^5) β the number of test cases.
You can only use t = 1 in hacks.
Next, descriptions of t test cases come, each of them in the following format.
The first line of a single test case contains one integer n (1 β€ n β€ 10^5) β the length of the permutation. The second line contains n distinct integers a_i (1 β€ a_i β€ n) β the permutation itself.
The sum of the values of n over all test cases doesn't exceed 10^5.
Output
For each test case print the answer in the following format:
In the first line print k (1 β€ k β€ f(n)) β the number of the subsequences in the partition. In the next k lines, print the descriptions of found subsequences. Each description should start with a number l_i (1 β€ l_i β€ n) β the length of the corresponding subsequence, followed by l_i integers β the values of this subsequence in the order in which they occur in the permutation.
Each subsequence you output must be either increasing or decreasing.
In case there are multiple possible answers, print any of them.
Example
Input
3
4
4 3 1 2
6
4 5 6 1 3 2
10
1 2 3 4 5 6 7 8 9 10
Output
2
3 4 3 1
1 2
3
2 4 1
2 5 6
2 3 2
1
10 1 2 3 4 5 6 7 8 9 10
Note
In the example, we can split:
* [4, 3, 1, 2] into [4, 3, 1], [2]
* [4, 5, 6, 1, 3, 2] into [4, 1], [5, 6] and [3, 2]
* [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] into [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Surely, there are many more answers possible.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
arr = []
arr = [int(x) for x in input().split()]
subs = []
tmp = []
for i in arr:
if len(tmp) == 0 or (len(tmp) == 1 and tmp[0] != i) or (tmp[0] > tmp[len(tmp)-1] > i) or (tmp[0] < tmp[len(tmp)-1] < i):
tmp.append(i)
else:
subs.append(tmp)
tmp = []
tmp.append(i)
if len(tmp) > 0:
subs.append(tmp)
print(len(subs))
for i in range(len(subs)):
print(len(subs[i]), *subs[i])
``` | instruction | 0 | 102,923 | 12 | 205,846 |
No | output | 1 | 102,923 | 12 | 205,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves sortings.
He has an array a consisting of n integers. Let's number the array elements from 1 to n, then the i-th element will be denoted as ai. The Little Elephant can make one move to choose an arbitrary pair of integers l and r (1 β€ l β€ r β€ n) and increase ai by 1 for all i such that l β€ i β€ r.
Help the Little Elephant find the minimum number of moves he needs to convert array a to an arbitrary array sorted in the non-decreasing order. Array a, consisting of n elements, is sorted in the non-decreasing order if for any i (1 β€ i < n) ai β€ ai + 1 holds.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the size of array a. The next line contains n integers, separated by single spaces β array a (1 β€ ai β€ 109). The array elements are listed in the line in the order of their index's increasing.
Output
In a single line print a single integer β the answer to the problem.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 3
Output
0
Input
3
3 2 1
Output
2
Input
4
7 4 1 47
Output
6
Note
In the first sample the array is already sorted in the non-decreasing order, so the answer is 0.
In the second sample you need to perform two operations: first increase numbers from second to third (after that the array will be: [3, 3, 2]), and second increase only the last element (the array will be: [3, 3, 3]).
In the third sample you should make at least 6 steps. The possible sequence of the operations is: (2; 3), (2; 3), (2; 3), (3; 3), (3; 3), (3; 3). After that the array converts to [7, 7, 7, 47]. | instruction | 0 | 103,133 | 12 | 206,266 |
Tags: brute force, greedy
Correct Solution:
```
#rOkY
#FuCk
################################## kOpAl #####################################
t=int(input())
l=list(map(int,input().split()))
t1=l[0]
sum=0
for i in range(1,t,1):
if(l[i]<t1):
sum+=(t1-l[i])
t1=l[i]
print(sum)
``` | output | 1 | 103,133 | 12 | 206,267 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves sortings.
He has an array a consisting of n integers. Let's number the array elements from 1 to n, then the i-th element will be denoted as ai. The Little Elephant can make one move to choose an arbitrary pair of integers l and r (1 β€ l β€ r β€ n) and increase ai by 1 for all i such that l β€ i β€ r.
Help the Little Elephant find the minimum number of moves he needs to convert array a to an arbitrary array sorted in the non-decreasing order. Array a, consisting of n elements, is sorted in the non-decreasing order if for any i (1 β€ i < n) ai β€ ai + 1 holds.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the size of array a. The next line contains n integers, separated by single spaces β array a (1 β€ ai β€ 109). The array elements are listed in the line in the order of their index's increasing.
Output
In a single line print a single integer β the answer to the problem.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 3
Output
0
Input
3
3 2 1
Output
2
Input
4
7 4 1 47
Output
6
Note
In the first sample the array is already sorted in the non-decreasing order, so the answer is 0.
In the second sample you need to perform two operations: first increase numbers from second to third (after that the array will be: [3, 3, 2]), and second increase only the last element (the array will be: [3, 3, 3]).
In the third sample you should make at least 6 steps. The possible sequence of the operations is: (2; 3), (2; 3), (2; 3), (3; 3), (3; 3), (3; 3). After that the array converts to [7, 7, 7, 47]. | instruction | 0 | 103,134 | 12 | 206,268 |
Tags: brute force, greedy
Correct Solution:
```
n=int(input())
list1=list(map(int,input().split()))
s=0
for i in range(1,n):
if(list1[i]<list1[i-1]):
s+=abs(list1[i]-list1[i-1])
print(s)
``` | output | 1 | 103,134 | 12 | 206,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves sortings.
He has an array a consisting of n integers. Let's number the array elements from 1 to n, then the i-th element will be denoted as ai. The Little Elephant can make one move to choose an arbitrary pair of integers l and r (1 β€ l β€ r β€ n) and increase ai by 1 for all i such that l β€ i β€ r.
Help the Little Elephant find the minimum number of moves he needs to convert array a to an arbitrary array sorted in the non-decreasing order. Array a, consisting of n elements, is sorted in the non-decreasing order if for any i (1 β€ i < n) ai β€ ai + 1 holds.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the size of array a. The next line contains n integers, separated by single spaces β array a (1 β€ ai β€ 109). The array elements are listed in the line in the order of their index's increasing.
Output
In a single line print a single integer β the answer to the problem.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 3
Output
0
Input
3
3 2 1
Output
2
Input
4
7 4 1 47
Output
6
Note
In the first sample the array is already sorted in the non-decreasing order, so the answer is 0.
In the second sample you need to perform two operations: first increase numbers from second to third (after that the array will be: [3, 3, 2]), and second increase only the last element (the array will be: [3, 3, 3]).
In the third sample you should make at least 6 steps. The possible sequence of the operations is: (2; 3), (2; 3), (2; 3), (3; 3), (3; 3), (3; 3). After that the array converts to [7, 7, 7, 47]. | instruction | 0 | 103,135 | 12 | 206,270 |
Tags: brute force, greedy
Correct Solution:
```
"""
Author : co_devil Chirag Garg
Institute : JIIT
"""
from __future__ import division, print_function
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil,floor,log,sqrt,factorial,pow,pi
# from bisect import bisect_left,bisect_right
# from decimal import *,threading
"""from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
else:
from builtins import str as __str__
str = lambda x=b'': x if type(x) is bytes else __str__(x).encode()
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._buffer = BytesIO()
self._fd = file.fileno()
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):
return self._buffer.read() if self._buffer.tell() else os.read(self._fd, os.fstat(self._fd).st_size)
def readline(self):
while self.newlines == 0:
b, ptr = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE)), self._buffer.tell()
self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
self.newlines += b.count(b'\n') + (not b)
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)
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b'\r\n')
def print(*args, **kwargs):
sep, file = kwargs.pop('sep', b' '), kwargs.pop('file', sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop('end', b'\n'))
if kwargs.pop('flush', False):
file.flush()
"""
def ii(): return int(input())
def si(): return str(input())
def mi(): return map(int,input().split())
def li(): return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12,
'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24,
'z': 25}
mod = 1000000007
dx, dy = [-1, 1, 0, 0], [0, 0, 1, -1]
def getKey(item): return item[0]
def sort2(l): return sorted(l, key=getKey)
def d2(n, m, num): return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo(x): return (x and (not (x & (x - 1))))
def decimalToBinary(n): return bin(n).replace("0b", "")
def ntl(n): return [int(i) for i in str(n)]
def powerMod(x, y, p):
res = 1
x %= p
while y > 0:
if y & 1:
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
def gcd(x, y):
while y:
x, y = y, x % y
return x
# For getting input from input.txt file
# sys.stdin = open('input.txt', 'r')
# Printing the Output to output.txt file
# sys.stdout = open('output.txt', 'w')
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000
def dfs(v, c):
if visited[v]:
if col[v] != c:
print('-1')
exit()
return
col[v] = c
visited[v] = 1
for i in graph[v]:
dfs(i, c ^ 1)
def bfs(d,v):
q=[]
q.append(v)
visited[v]=1
while len(q)!=0:
x=q[0]
q.pop(0)
for i in d[x]:
if visited[i]!=1:
visited[i]=1
q.append(i)
print(x)
print(l)
def make_graph(e):
d={}
for i in range(e):
x,y=mi()
if x not in d.keys():
d[x]=[y]
else:
d[x].append(y)
if y not in d.keys():
d[y] = [x]
else:
d[y].append(x)
return d
def gr2(n):
d={}
for i in range(n):
x,y=mi()
if x not in d.keys():
d[x]=[y]
else:
d[x].append(y)
return d
def connected_components(graph):
seen = set()
def dfs(v):
vs = set([v])
component=[]
while vs:
v = vs.pop()
seen.add(v)
vs |= set(graph[v]) - seen
component.append(v)
return component
ans=[]
for v in graph:
if v not in seen:
d=dfs(v)
ans.append(d)
return ans
n=ii()
s=li()
c=0
for i in range(1,n):
c+=max(s[i],s[i-1])-s[i]
print(c)
``` | output | 1 | 103,135 | 12 | 206,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves sortings.
He has an array a consisting of n integers. Let's number the array elements from 1 to n, then the i-th element will be denoted as ai. The Little Elephant can make one move to choose an arbitrary pair of integers l and r (1 β€ l β€ r β€ n) and increase ai by 1 for all i such that l β€ i β€ r.
Help the Little Elephant find the minimum number of moves he needs to convert array a to an arbitrary array sorted in the non-decreasing order. Array a, consisting of n elements, is sorted in the non-decreasing order if for any i (1 β€ i < n) ai β€ ai + 1 holds.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the size of array a. The next line contains n integers, separated by single spaces β array a (1 β€ ai β€ 109). The array elements are listed in the line in the order of their index's increasing.
Output
In a single line print a single integer β the answer to the problem.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 3
Output
0
Input
3
3 2 1
Output
2
Input
4
7 4 1 47
Output
6
Note
In the first sample the array is already sorted in the non-decreasing order, so the answer is 0.
In the second sample you need to perform two operations: first increase numbers from second to third (after that the array will be: [3, 3, 2]), and second increase only the last element (the array will be: [3, 3, 3]).
In the third sample you should make at least 6 steps. The possible sequence of the operations is: (2; 3), (2; 3), (2; 3), (3; 3), (3; 3), (3; 3). After that the array converts to [7, 7, 7, 47]. | instruction | 0 | 103,136 | 12 | 206,272 |
Tags: brute force, greedy
Correct Solution:
```
n=int(input())
a=[int(x) for x in input().split()]
ans=0
for i in range(n-1):
if a[i+1]<a[i]:
ans+=a[i]-a[i+1]
print(ans)
``` | output | 1 | 103,136 | 12 | 206,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves sortings.
He has an array a consisting of n integers. Let's number the array elements from 1 to n, then the i-th element will be denoted as ai. The Little Elephant can make one move to choose an arbitrary pair of integers l and r (1 β€ l β€ r β€ n) and increase ai by 1 for all i such that l β€ i β€ r.
Help the Little Elephant find the minimum number of moves he needs to convert array a to an arbitrary array sorted in the non-decreasing order. Array a, consisting of n elements, is sorted in the non-decreasing order if for any i (1 β€ i < n) ai β€ ai + 1 holds.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the size of array a. The next line contains n integers, separated by single spaces β array a (1 β€ ai β€ 109). The array elements are listed in the line in the order of their index's increasing.
Output
In a single line print a single integer β the answer to the problem.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 3
Output
0
Input
3
3 2 1
Output
2
Input
4
7 4 1 47
Output
6
Note
In the first sample the array is already sorted in the non-decreasing order, so the answer is 0.
In the second sample you need to perform two operations: first increase numbers from second to third (after that the array will be: [3, 3, 2]), and second increase only the last element (the array will be: [3, 3, 3]).
In the third sample you should make at least 6 steps. The possible sequence of the operations is: (2; 3), (2; 3), (2; 3), (3; 3), (3; 3), (3; 3). After that the array converts to [7, 7, 7, 47]. | instruction | 0 | 103,137 | 12 | 206,274 |
Tags: brute force, greedy
Correct Solution:
```
#coding=utf-8
import sys
n=int(input())
a=[int(i) for i in input().split()]
i=n-1
sum=0
while i>0:
if a[i]<a[i-1]:
sum+=a[i-1]-a[i]
i-=1
print(sum)
``` | output | 1 | 103,137 | 12 | 206,275 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves sortings.
He has an array a consisting of n integers. Let's number the array elements from 1 to n, then the i-th element will be denoted as ai. The Little Elephant can make one move to choose an arbitrary pair of integers l and r (1 β€ l β€ r β€ n) and increase ai by 1 for all i such that l β€ i β€ r.
Help the Little Elephant find the minimum number of moves he needs to convert array a to an arbitrary array sorted in the non-decreasing order. Array a, consisting of n elements, is sorted in the non-decreasing order if for any i (1 β€ i < n) ai β€ ai + 1 holds.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the size of array a. The next line contains n integers, separated by single spaces β array a (1 β€ ai β€ 109). The array elements are listed in the line in the order of their index's increasing.
Output
In a single line print a single integer β the answer to the problem.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 3
Output
0
Input
3
3 2 1
Output
2
Input
4
7 4 1 47
Output
6
Note
In the first sample the array is already sorted in the non-decreasing order, so the answer is 0.
In the second sample you need to perform two operations: first increase numbers from second to third (after that the array will be: [3, 3, 2]), and second increase only the last element (the array will be: [3, 3, 3]).
In the third sample you should make at least 6 steps. The possible sequence of the operations is: (2; 3), (2; 3), (2; 3), (3; 3), (3; 3), (3; 3). After that the array converts to [7, 7, 7, 47]. | instruction | 0 | 103,138 | 12 | 206,276 |
Tags: brute force, greedy
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
cnt=0
ans=0
for i in range(1,n):
if l[i]+cnt<l[i-1]:
ans+=abs(l[i]+cnt-l[i-1])
cnt+=ans
l[i]+=cnt
print(ans)
``` | output | 1 | 103,138 | 12 | 206,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves sortings.
He has an array a consisting of n integers. Let's number the array elements from 1 to n, then the i-th element will be denoted as ai. The Little Elephant can make one move to choose an arbitrary pair of integers l and r (1 β€ l β€ r β€ n) and increase ai by 1 for all i such that l β€ i β€ r.
Help the Little Elephant find the minimum number of moves he needs to convert array a to an arbitrary array sorted in the non-decreasing order. Array a, consisting of n elements, is sorted in the non-decreasing order if for any i (1 β€ i < n) ai β€ ai + 1 holds.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the size of array a. The next line contains n integers, separated by single spaces β array a (1 β€ ai β€ 109). The array elements are listed in the line in the order of their index's increasing.
Output
In a single line print a single integer β the answer to the problem.
Please, do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 3
Output
0
Input
3
3 2 1
Output
2
Input
4
7 4 1 47
Output
6
Note
In the first sample the array is already sorted in the non-decreasing order, so the answer is 0.
In the second sample you need to perform two operations: first increase numbers from second to third (after that the array will be: [3, 3, 2]), and second increase only the last element (the array will be: [3, 3, 3]).
In the third sample you should make at least 6 steps. The possible sequence of the operations is: (2; 3), (2; 3), (2; 3), (3; 3), (3; 3), (3; 3). After that the array converts to [7, 7, 7, 47]. | instruction | 0 | 103,139 | 12 | 206,278 |
Tags: brute force, greedy
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
print(sum(max(0,a[i-1]-a[i]) for i in range(1,n)))
# Made By Mostafa_Khaled
``` | output | 1 | 103,139 | 12 | 206,279 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.