message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES | instruction | 0 | 21,411 | 12 | 42,822 |
Tags: constructive algorithms, dp, greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = [*map(int,input().split())]
ans = sum(max(a[i]-a[i+1],0) for i in range(n-1))
print("YES" if ans<=a[0] else "NO")
``` | output | 1 | 21,411 | 12 | 42,823 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES | instruction | 0 | 21,412 | 12 | 42,824 |
Tags: constructive algorithms, dp, greedy
Correct Solution:
```
#not done by myself
t=int(input())
fflg=0
if t==3000: fflg=1
cnt=1
while t!=0:
t-=1
n=int(input())
lst=input().split(" ")
# if fflg==1 and cnt==59: print(lst)
for i in range(0,n,1):
lst[i]=int(lst[i])
flg=0
mini=1000000000000000
psum=[0 for i in range(0,n+1,1)]
for i in range(0,n-1,1):
mini=min(mini,lst[i])
if(lst[i+1]<lst[i]):
x=lst[i]-lst[i+1]
psum[0]-=x
psum[i+1]+=x
cnt+=1
for i in range(1,n+1,1):
psum[i]+=psum[i-1]
for i in range(0,n,1):
if lst[i] + psum[i] <0: flg=1
if(flg==1): print("NO")
else: print("YES")
``` | output | 1 | 21,412 | 12 | 42,825 |
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 n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES
Submitted Solution:
```
def rangeUpdate(t,node,tl,tr,l,r,val):
if tl == l and tr == r:
t[node][1] += val
return
mid = (tl+tr)//2
if r <= mid:
rangeUpdate(t,2*node,tl,mid,l,r,val)
elif l > mid:
rangeUpdate(t,2*node+1,mid+1,tr,l,r,val)
else:
rangeUpdate(t,2*node,tl,mid,l,mid,val)
rangeUpdate(t,2*node+1,mid+1,tr,mid+1,r,val)
def pointQuery(t,node,tl,tr,index):
if tl == tr:
return t[node][0]+t[node][1]
mid = (tl+tr)//2
if index <= mid:
return t[node][1]+pointQuery(t,2*node,tl,mid,index)
return t[node][1]+pointQuery(t,2*node+1,mid+1,tr,index)
def solve(arr,n,ans):
t = [[0 for j in range(2)] for i in range(4*n+1)]
for i in range(n):
rangeUpdate(t,1,0,n-1,i,i,arr[i])
for i in range(1,n):
curr = pointQuery(t,1,0,n-1,i)
left = pointQuery(t,1,0,n-1,i-1)
#print(curr,left)
if curr > left:
diff = curr-left
rangeUpdate(t,1,0,n-1,i,n-1,-diff)
elif left > curr:
diff = left-curr
rangeUpdate(t,1,0,n-1,0,i-1,-diff)
for i in range(n):
if pointQuery(t,1,0,n-1,i) < 0:
ans.append('NO')
return
ans.append('YES')
def main():
t = int(input())
ans = []
for i in range(t):
n = int(input())
arr = list(map(int,input().split()))
solve(arr,n,ans)
print('\n'.join(ans))
main()
``` | instruction | 0 | 21,413 | 12 | 42,826 |
Yes | output | 1 | 21,413 | 12 | 42,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES
Submitted Solution:
```
from math import ceil
def extreme(arr):
ans=0
for i in range(len(arr)-1):
ans+=max(arr[i+1]-arr[i],0)
if arr[-1] - ans >= 0:
return "YES"
return "NO"
for i in range(int(input())):
a=input()
lst=list(map(int,input().strip().split()))
print(extreme(lst))
``` | instruction | 0 | 21,414 | 12 | 42,828 |
Yes | output | 1 | 21,414 | 12 | 42,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES
Submitted Solution:
```
T = int(input())
for _ in range(T):
n, ls = int(input()), list(map(int, input().split()))
left, right = [-1]*n, [-1]*n
left[0] = 0
for u in range(1, n):
if ls[u-1] >= ls[u]:
if ls[u] < left[u-1]: break
else: left[u] = left[u-1]
else:
left[u] = left[u-1] + (ls[u]-ls[u-1])
right[n-1] = ls[n-1]
for u in reversed(range(n-1)):
if ls[u] <= ls[u+1]: right[u] = ls[u]
else: break
ok = 0
for u in range(1, n):
if left[u-1] == -1 or right[u] == -1:
continue
if left[u-1] <= right[u]:
ok = 1; break
print("YES" if n==1 or ok else "NO")
``` | instruction | 0 | 21,415 | 12 | 42,830 |
Yes | output | 1 | 21,415 | 12 | 42,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES
Submitted Solution:
```
import sys
input=sys.stdin.readline
R=lambda:map(int,input().split())
t,=R()
for _ in [0]*t:
R()
pre,sur=float('inf'),0
for a in R():
if sur>a:
print('NO')
break
if pre+sur<a:
sur=a-pre
else:
pre=a-sur
else:
print('YES')
``` | instruction | 0 | 21,416 | 12 | 42,832 |
Yes | output | 1 | 21,416 | 12 | 42,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES
Submitted Solution:
```
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
def gift():
for _ in range(t):
n = int(input())
a = list(map(int,input().split()))
if n<=2:
yield 'YES'
else:
s,e = 1,n-2
while s<e:
found=False
if a[s]<=a[s-1]:
s+=1
found=True
if a[e]<=a[e+1]:
e-=1
found=True
if not found:
break
if s>=e:
yield 'YES'
else:
currS = a[s-1]
if e+1>n-1:
currE = a[n-1]
else:
currE = a[e+1]
print(a,a[s:e+1],s,e)
rev = False
count = 0
for i in range(s,e+1):
if a[i]<a[i-1]:
if not rev:
rev=not rev
elif a[i]>a[i+1]:
if rev:
count+=1
rev=not rev
#print(count,a[s:e+1])
if count<=1 and max(a[s:e+1])<=currS+currE:
yield 'YES'
else:
yield 'NO'
if __name__ == '__main__':
t= int(input())
ans = gift()
print(*ans,sep='\n')
#"{} {} {}".format(maxele,minele,minele)
``` | instruction | 0 | 21,417 | 12 | 42,834 |
No | output | 1 | 21,417 | 12 | 42,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES
Submitted Solution:
```
# SHRi GANESHA author: Kunal Verma #
import os, sys
from collections import defaultdict, Counter, deque
from io import BytesIO, IOBase
from math import gcd, inf
def coun(a, p, n):
c = 0
for i in range(n):
if a[i] & (1 << p):
c += 1
return c
def main():
for _ in range(int(input())):
n = int(input())
a = [int(x) for x in input().split()]
an = 0
x = [a[0] for j in range(n)]
y = [a[-1] for j in range(n)]
for j in range(1, n):
x[j] = min(a[j], x[j - 1])
for j in range(n - 2, -1, -1):
y[j] = min(y[j + 1], a[j])
p = []
j = 1
an = 'YES'
for j in range(1, n - 1):
if (x[j] + y[j]) <= a[j]:
an = 'NO'
break
print(an)
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | instruction | 0 | 21,418 | 12 | 42,836 |
No | output | 1 | 21,418 | 12 | 42,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES
Submitted Solution:
```
import sys
import math
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()
t = II()
for q in range(t):
n = II()
a = LI()
if n < 3:
print("YES")
else:
x = []
y = []
m = 10**6+1
for i in range(n):
m = min(m,a[i])
x.append(m)
m = 10**6+1
for i in range(n-1,-1,-1):
m = min(m,a[i])
y.append(m)
boo = True
for i in range(n):
if i!=0 and i!=n-1 and x[i-1]+y[i+1]<a[i]:
boo = False
break
print("YES" if boo else "NO")
``` | instruction | 0 | 21,419 | 12 | 42,838 |
No | output | 1 | 21,419 | 12 | 42,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of n positive integers.
You can use the following operation as many times as you like: select any integer 1 ≤ k ≤ n and do one of two things:
* decrement by one k of the first elements of the array.
* decrement by one k of the last elements of the array.
For example, if n=5 and a=[3,2,2,1,4], then you can apply one of the following operations to it (not all possible options are listed below):
* decrement from the first two elements of the array. After this operation a=[2, 1, 2, 1, 4];
* decrement from the last three elements of the array. After this operation a=[3, 2, 1, 0, 3];
* decrement from the first five elements of the array. After this operation a=[2, 1, 1, 0, 3];
Determine if it is possible to make all the elements of the array equal to zero by applying a certain number of operations.
Input
The first line contains one positive integer t (1 ≤ t ≤ 30000) — the number of test cases. Then t test cases follow.
Each test case begins with a line containing one integer n (1 ≤ n ≤ 30000) — the number of elements in the array.
The second line of each test case contains n integers a_1 … a_n (1 ≤ a_i ≤ 10^6).
The sum of n over all test cases does not exceed 30000.
Output
For each test case, output on a separate line:
* YES, if it is possible to make all elements of the array equal to zero by applying a certain number of operations.
* NO, otherwise.
The letters in the words YES and NO can be outputed in any case.
Example
Input
4
3
1 2 1
5
11 7 9 6 8
5
1 3 1 3 1
4
5 2 1 10
Output
YES
YES
NO
YES
Submitted Solution:
```
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
def gift():
for _ in range(t):
n = int(input())
a = list(map(int,input().split()))
if n<=2:
yield 'YES'
else:
decrease = True
twistCount = 0
ans = True
start = 1
curr = a[0]
temCurr = 0
while start<n:
if a[start]<a[start-1]:
curr=min(curr,a[start])
elif a[start]>a[start-1]:
break
start+=1
while start<n-1:
if a[start]>a[start+1]:
if a[start]-curr<=a[start+1]:
temCurr = a[start]-curr
break
else:
ans = False
break
start+=1
start+=1
First = False
while start<n-1:
if a[start]>a[start+1]:
if a[start+1]<temCurr or First:
ans = False
break
else:
First = True
start+=1
if ans:
yield 'YES'
else:
yield 'NO'
if __name__ == '__main__':
t= int(input())
ans = gift()
print(*ans,sep='\n')
#"{} {} {}".format(maxele,minele,minele)
``` | instruction | 0 | 21,420 | 12 | 42,840 |
No | output | 1 | 21,420 | 12 | 42,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n sets of integers. The i-th set contains k_i integers.
Two sets are called similar if they share at least two common elements, i. e. there exist two integers x and y such that x ≠ y, and they both belong to each of the two sets.
Your task is to find two similar sets among the given ones, or report that there is no such pair of sets.
Input
The first line contains a single integer t (1 ≤ t ≤ 50000) — the number of test cases. Then t test cases follow.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) the number of given sets. The following n lines describe the sets. The i-th line starts with an integer k_i (2 ≤ k_i ≤ 10^5) — the number of integers in the i-th set. Then k_i integers a_{i,1}, a_{i,2}, ..., a_{i,k_i} (1 ≤ a_{i,j} ≤ 10^9) follow — the elements of the i-th set. It is guaranteed that all elements in each set are different.
The total number of elements in all sets in all test cases is not greater than 2⋅ 10^5.
Output
For each test case, print the answer on a single line.
If there is no pair of similar sets, print -1.
Otherwise, print two different integers — the indices of the similar sets. The sets are numbered from 1 to n in the order they are given in the input. If there are multiple answers, print any of them.
Example
Input
3
4
2 1 10
3 1 3 5
5 5 4 3 2 1
3 10 20 30
3
4 1 2 3 4
4 2 3 4 5
4 3 4 5 6
2
3 1 3 5
3 4 3 2
Output
2 3
1 2
-1 | instruction | 0 | 21,421 | 12 | 42,842 |
Tags: data structures, graphs, implementation
Correct Solution:
```
def solve(n, debug=False):
global curr; global seen; global last; big = []; small = []
for i in range(1,1+n):
l = list(map(int, input().split()))
if l[0] > 600: big.append((i,l[1:]))
else: small.append((i,l[1:]))
s1 = len(big); s2 = len(small)
if debug: print(s1,s2); return ''
for s, l1 in big:
care = set(l1)
for t, l2 in big + small:
if s == t: continue
count = 0
for v in l2:
if v in care: count += 1
if count >= 2: return str(s) + ' ' + str(t)
mapD = dict(); curr = 0; seen = []; last = [] ;msmall = []
def mapV(x):
global curr; global seen; global last
if x in mapD: return mapD[x]
else: mapD[x] = curr; curr += 1; seen.append([]); last.append((-1,-1)); return curr - 1
for i in range(s2):
u, l = small[i]; new = []
for v in l: seen[mapV(v)].append(i); new.append(mapV(v))
msmall.append(new)
for v1 in range(len(seen)):
for i in seen[v1]:
for v2 in msmall[i]:
if v1 == v2: continue
lastV = last[v2]
if lastV[0] == v1: return str(lastV[1]) + ' ' + str(small[i][0])
else: last[v2] = (v1, small[i][0])
return '-1'
import sys,io,os;input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
t = int(input())
o = []
for _ in range(t):
n = int(input())
if n > 80000:
o.append(solve(n))
continue
seen = dict()
out = (-1,-1)
for s in range(n):
adj = set()
adjL = set()
l = list(map(int, input().split()))
for v in l[1:]:
if v in seen:
ot = seen[v]
if len(ot) > len(adjL) and len(ot) > len(adj):
adj |= adjL
adjL = ot
for u in adj:
if u in adjL:
out = (u, s)
break
else:
for u in ot:
if u in adj or u in adjL:
out = (u, s)
break
else:
adj.add(u)
if out[0] == -1:
seen[v].add(s)
else:
break
else:
seen[v] = set([s])
if out[0] != -1:
while s < n-1:
input()
s += 1
break
o.append( ('-1' if out[0] == -1 else str(out[0] + 1) + ' ' + str(out[1] + 1) ))
print('\n'.join(o))
``` | output | 1 | 21,421 | 12 | 42,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n sets of integers. The i-th set contains k_i integers.
Two sets are called similar if they share at least two common elements, i. e. there exist two integers x and y such that x ≠ y, and they both belong to each of the two sets.
Your task is to find two similar sets among the given ones, or report that there is no such pair of sets.
Input
The first line contains a single integer t (1 ≤ t ≤ 50000) — the number of test cases. Then t test cases follow.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) the number of given sets. The following n lines describe the sets. The i-th line starts with an integer k_i (2 ≤ k_i ≤ 10^5) — the number of integers in the i-th set. Then k_i integers a_{i,1}, a_{i,2}, ..., a_{i,k_i} (1 ≤ a_{i,j} ≤ 10^9) follow — the elements of the i-th set. It is guaranteed that all elements in each set are different.
The total number of elements in all sets in all test cases is not greater than 2⋅ 10^5.
Output
For each test case, print the answer on a single line.
If there is no pair of similar sets, print -1.
Otherwise, print two different integers — the indices of the similar sets. The sets are numbered from 1 to n in the order they are given in the input. If there are multiple answers, print any of them.
Example
Input
3
4
2 1 10
3 1 3 5
5 5 4 3 2 1
3 10 20 30
3
4 1 2 3 4
4 2 3 4 5
4 3 4 5 6
2
3 1 3 5
3 4 3 2
Output
2 3
1 2
-1 | instruction | 0 | 21,422 | 12 | 42,844 |
Tags: data structures, graphs, implementation
Correct Solution:
```
def solve(n, debug=False):
global curr; global seen; global last; big = []; small = []
for i in range(1,1+n):
l = list(map(int, input().split()))
if l[0] > 600: big.append((i,l[1:]))
else: small.append((i,l[1:]))
s1 = len(big); s2 = len(small)
if debug: print(s1,s2); return ''
for s, l1 in big:
care = set(l1)
for t, l2 in big + small:
if s == t: continue
count = 0
for v in l2:
if v in care: count += 1
if count >= 2: return str(s) + ' ' + str(t)
mapD = dict(); curr = 0; seen = []; last = [] ;msmall = []
def mapV(x):
global curr; global seen; global last
if x in mapD: return mapD[x]
else: mapD[x] = curr; curr += 1; seen.append([]); last.append((-1,-1)); return curr - 1
for i in range(s2):
u, l = small[i]; new = []
for v in l: seen[mapV(v)].append(i); new.append(mapV(v))
msmall.append(new)
for v1 in range(len(seen)):
for i in seen[v1]:
for v2 in msmall[i]:
if v1 == v2: continue
lastV = last[v2]
if lastV[0] == v1: return str(lastV[1]) + ' ' + str(small[i][0])
else: last[v2] = (v1, small[i][0])
return '-1'
import sys,io,os;input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline;o = []
for _ in range(int(input())):
n = int(input())
if n > 80000: o.append(solve(n)); continue
seen = dict(); out = (-1,-1)
for s in range(n):
adj = set(); adjL = set(); l = list(map(int, input().split()))
for v in l[1:]:
if v in seen:
ot = seen[v]
if len(ot) > len(adjL) and len(ot) > len(adj):
adj |= adjL; adjL = ot
for u in adj:
if u in adjL: out = (u, s); break
else:
for u in ot:
if u in adj or u in adjL: out = (u, s); break
else: adj.add(u)
if out[0] == -1: seen[v].add(s)
else: break
else: seen[v] = set([s])
if out[0] != -1:
while s < n-1: input(); s += 1
break
o.append( ('-1' if out[0] == -1 else str(out[0] + 1) + ' ' + str(out[1] + 1) ))
print('\n'.join(o))
``` | output | 1 | 21,422 | 12 | 42,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n sets of integers. The i-th set contains k_i integers.
Two sets are called similar if they share at least two common elements, i. e. there exist two integers x and y such that x ≠ y, and they both belong to each of the two sets.
Your task is to find two similar sets among the given ones, or report that there is no such pair of sets.
Input
The first line contains a single integer t (1 ≤ t ≤ 50000) — the number of test cases. Then t test cases follow.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) the number of given sets. The following n lines describe the sets. The i-th line starts with an integer k_i (2 ≤ k_i ≤ 10^5) — the number of integers in the i-th set. Then k_i integers a_{i,1}, a_{i,2}, ..., a_{i,k_i} (1 ≤ a_{i,j} ≤ 10^9) follow — the elements of the i-th set. It is guaranteed that all elements in each set are different.
The total number of elements in all sets in all test cases is not greater than 2⋅ 10^5.
Output
For each test case, print the answer on a single line.
If there is no pair of similar sets, print -1.
Otherwise, print two different integers — the indices of the similar sets. The sets are numbered from 1 to n in the order they are given in the input. If there are multiple answers, print any of them.
Example
Input
3
4
2 1 10
3 1 3 5
5 5 4 3 2 1
3 10 20 30
3
4 1 2 3 4
4 2 3 4 5
4 3 4 5 6
2
3 1 3 5
3 4 3 2
Output
2 3
1 2
-1
Submitted Solution:
```
"""
Author - Satwik Tiwari .
15th Dec , 2020 - Tuesday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
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()
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)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
class DisjointSetUnion:
def __init__(self, n):
self.parent = list(range(n))
self.size = [1] * n
self.num_sets = n
def find(self, a):
acopy = a
while a != self.parent[a]:
a = self.parent[a]
while acopy != a:
self.parent[acopy], acopy = a, self.parent[acopy]
return a
def union(self, a, b):
a, b = self.find(a), self.find(b)
if a != b:
if self.size[a] < self.size[b]:
a, b = b, a
self.num_sets -= 1
self.parent[b] = a
self.size[a] += self.size[b]
def set_size(self, a):
return self.size[self.find(a)]
def __len__(self):
return self.num_sets
def solve(case):
n = int(inp())
dsu = DisjointSetUnion(n+1)
have = {}
sets = []
for i in range(n):
temp = lis()
temp = temp[1:]
sets.append(temp)
for i in range(n):
for j in sets[i]:
if(j not in have):
have[j] = [i]
else:
have[j].append(i)
for i in have:
temp = set()
com = -1
for j in have[i]:
chck = dsu.find(j)
if(chck in temp):
com = chck
break
else:
temp.add(chck)
if(com == -1):
lol = []
for j in have[i]:
lol.append(j)
for j in range(1,len(lol)):
dsu.union(lol[0],lol[j])
else:
ans = []
for j in have[i]:
if(dsu.find(j) == com):
ans.append(j)
print(ans[0]+1,ans[1]+1)
return
print(-1)
# testcase(1)
testcase(int(inp()))
``` | instruction | 0 | 21,423 | 12 | 42,846 |
No | output | 1 | 21,423 | 12 | 42,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n sets of integers. The i-th set contains k_i integers.
Two sets are called similar if they share at least two common elements, i. e. there exist two integers x and y such that x ≠ y, and they both belong to each of the two sets.
Your task is to find two similar sets among the given ones, or report that there is no such pair of sets.
Input
The first line contains a single integer t (1 ≤ t ≤ 50000) — the number of test cases. Then t test cases follow.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) the number of given sets. The following n lines describe the sets. The i-th line starts with an integer k_i (2 ≤ k_i ≤ 10^5) — the number of integers in the i-th set. Then k_i integers a_{i,1}, a_{i,2}, ..., a_{i,k_i} (1 ≤ a_{i,j} ≤ 10^9) follow — the elements of the i-th set. It is guaranteed that all elements in each set are different.
The total number of elements in all sets in all test cases is not greater than 2⋅ 10^5.
Output
For each test case, print the answer on a single line.
If there is no pair of similar sets, print -1.
Otherwise, print two different integers — the indices of the similar sets. The sets are numbered from 1 to n in the order they are given in the input. If there are multiple answers, print any of them.
Example
Input
3
4
2 1 10
3 1 3 5
5 5 4 3 2 1
3 10 20 30
3
4 1 2 3 4
4 2 3 4 5
4 3 4 5 6
2
3 1 3 5
3 4 3 2
Output
2 3
1 2
-1
Submitted Solution:
```
import sys,io,os;input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
t = int(input())
o = []
for _ in range(t):
n = int(input())
seen = dict()
out = (-1,-1)
for s in range(n):
adj = set()
l = list(map(int, input().split()))
for ind in range(1,l[0]+1):
v = l[ind]
if v in seen:
ot = seen[v]
if len(ot) > len(adj):
adj,ot=ot,adj
for u in ot:
if u in adj:
out = (s,u)
break
else:
adj.add(u)
if out[0] == -1:
seen[v].add(s)
else:
break
else:
seen[v] = set([s])
if out[0] != -1:
while s < n-1:
input()
s += 1
break
if out[0] == -1:
o.append('-1')
else:
o.append(str(out[0] + 1) + ' ' + str(out[1] + 1))
print('\n'.join(o))
``` | instruction | 0 | 21,424 | 12 | 42,848 |
No | output | 1 | 21,424 | 12 | 42,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n sets of integers. The i-th set contains k_i integers.
Two sets are called similar if they share at least two common elements, i. e. there exist two integers x and y such that x ≠ y, and they both belong to each of the two sets.
Your task is to find two similar sets among the given ones, or report that there is no such pair of sets.
Input
The first line contains a single integer t (1 ≤ t ≤ 50000) — the number of test cases. Then t test cases follow.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) the number of given sets. The following n lines describe the sets. The i-th line starts with an integer k_i (2 ≤ k_i ≤ 10^5) — the number of integers in the i-th set. Then k_i integers a_{i,1}, a_{i,2}, ..., a_{i,k_i} (1 ≤ a_{i,j} ≤ 10^9) follow — the elements of the i-th set. It is guaranteed that all elements in each set are different.
The total number of elements in all sets in all test cases is not greater than 2⋅ 10^5.
Output
For each test case, print the answer on a single line.
If there is no pair of similar sets, print -1.
Otherwise, print two different integers — the indices of the similar sets. The sets are numbered from 1 to n in the order they are given in the input. If there are multiple answers, print any of them.
Example
Input
3
4
2 1 10
3 1 3 5
5 5 4 3 2 1
3 10 20 30
3
4 1 2 3 4
4 2 3 4 5
4 3 4 5 6
2
3 1 3 5
3 4 3 2
Output
2 3
1 2
-1
Submitted Solution:
```
t=input()
g=dict()
for k in range(int(t)) :
n=input()
a=dict()
b=input()
b=b.split()
a[1]=b
s=0
for i in range(2,int(n)+1) :
b=input()
b=b.split()
if s==0 :
for j in a :
s1=list(set(a[j]) & set(b))
if len(s1)>1 :
g[k]=[j,i]
s=1
break
a[i]=b
if s==0:
g[k]=-1
for i in g :
if g[i]==-1 :
print(-1)
else :
print(g[i][0],g[i][1])
``` | instruction | 0 | 21,425 | 12 | 42,850 |
No | output | 1 | 21,425 | 12 | 42,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n sets of integers. The i-th set contains k_i integers.
Two sets are called similar if they share at least two common elements, i. e. there exist two integers x and y such that x ≠ y, and they both belong to each of the two sets.
Your task is to find two similar sets among the given ones, or report that there is no such pair of sets.
Input
The first line contains a single integer t (1 ≤ t ≤ 50000) — the number of test cases. Then t test cases follow.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) the number of given sets. The following n lines describe the sets. The i-th line starts with an integer k_i (2 ≤ k_i ≤ 10^5) — the number of integers in the i-th set. Then k_i integers a_{i,1}, a_{i,2}, ..., a_{i,k_i} (1 ≤ a_{i,j} ≤ 10^9) follow — the elements of the i-th set. It is guaranteed that all elements in each set are different.
The total number of elements in all sets in all test cases is not greater than 2⋅ 10^5.
Output
For each test case, print the answer on a single line.
If there is no pair of similar sets, print -1.
Otherwise, print two different integers — the indices of the similar sets. The sets are numbered from 1 to n in the order they are given in the input. If there are multiple answers, print any of them.
Example
Input
3
4
2 1 10
3 1 3 5
5 5 4 3 2 1
3 10 20 30
3
4 1 2 3 4
4 2 3 4 5
4 3 4 5 6
2
3 1 3 5
3 4 3 2
Output
2 3
1 2
-1
Submitted Solution:
```
def main():
n = int(input())
big_box = []
for num in range(n):
a = int(input())
box = []
inbox = []
for num in range(a):
arr = list(map(int, input().split()))
arr = list(set(arr))
big_box.append(arr)
i = 0
while i<=a-1:
k = i+1
while k<=a-1:
box.append(len(set(big_box[i]) & set(big_box[k])))
inbox.append([i+1,k+1])
k+=1
i+=1
p=box.index(max(box))
if max(box)>=2:
print(*inbox[p])
else:
print('-1')
main()
``` | instruction | 0 | 21,426 | 12 | 42,852 |
No | output | 1 | 21,426 | 12 | 42,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5]. | instruction | 0 | 21,443 | 12 | 42,886 |
Tags: binary search, data structures, dp, graphs, number theory, two pointers
Correct Solution:
```
import os
import sys
import time
from io import BytesIO, IOBase
def main():
limit = 10 ** 5 + 1
R = [[] for _ in range(limit)]
n, q = li_input()
a = li_input()
simples = {1: n}
for i in range(2, limit):
if not R[i]:
simples[i] = n
for j in range(i, limit, i):
R[j].append(i)
A = [[n] * (n + 1)]
for i in range(n - 1, -1, -1):
A[0][i] = A[0][i + 1]
for div in R[a[i]]:
if div in simples:
A[0][i] = min(A[0][i], simples[div])
simples[div] = i
need_to_continue = True
while need_to_continue:
need_to_continue = False
A.append([n] * (n + 1))
for i in range(n):
if A[-2][i] != n:
A[-1][i] = A[-2][A[-2][i]]
if A[-1][i] != n:
need_to_continue = True
# print(A)
out = []
for qq in range(q):
ans = 1
l, r = li_input()
l -= 1
r -= 1
for i in range(len(A) - 1, -1, -1):
if A[i][l] <= r:
ans += 1 << i
l = A[i][l]
out.append(ans)
print("\n".join(map(str, out)))
############
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
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()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input():
return sys.stdin.readline().rstrip("\r\n")
def i_input():
return int(input())
def l_input():
return input().split()
def li_input():
return list(map(int, l_input()))
def il_input():
return list(map(int, l_input()))
# endregion
if __name__ == "__main__":
TT = time.time()
main()
# print("\n", time.time() - TT)
``` | output | 1 | 21,443 | 12 | 42,887 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5]. | instruction | 0 | 21,444 | 12 | 42,888 |
Tags: binary search, data structures, dp, graphs, number theory, two pointers
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
_print = print
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')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
_FAC = 10 ** 5
def prime_sieve(n):
"""returns a sieve of primes >= 5 and < n"""
flag = n % 6 == 2
sieve = bytearray((n // 3 + flag >> 3) + 1)
for i in range(1, int(n ** 0.5) // 3 + 1):
if not (sieve[i >> 3] >> (i & 7)) & 1:
k = (3 * i + 1) | 1
for j in range(k * k // 3, n // 3 + flag, 2 * k):
sieve[j >> 3] |= 1 << (j & 7)
for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
sieve[j >> 3] |= 1 << (j & 7)
return sieve
def prime_list(n):
"""returns a list of primes <= n"""
res = []
if n > 1:
res.append(2)
if n > 2:
res.append(3)
if n > 4:
sieve = prime_sieve(n + 1)
res.extend(3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not (sieve[i >> 3] >> (i & 7)) & 1)
return res
PRIME_FACTORS = [set() for _ in range(_FAC + 1)]
for p in prime_list(_FAC):
kp = p
while kp <= _FAC:
PRIME_FACTORS[kp].add(p)
kp += p
# ############################## main
EXP = _FAC.bit_length() + 1 # 18, 2**18 > 1e5
def main():
n, q = mpint()
arr = tuple(mpint())
# dp[i][j]: The new index which we need to start at if we performed it 2**i times
dp = [[0] * n for _ in range(EXP)]
# dp[0][j]: i.e. the largest j s.t. lcm(arr[i:j]) = reduce(mul, arr[i:j])
# lcm(arr[i:j]) = reduce(mul, arr[i:j]) iff
# there is no common prime factor for each pair of number in arr[i:j]
# Calculating dp[0][j], using two pointers
i = 0
st = PRIME_FACTORS[arr[0]].copy()
for j, a in enumerate(arr[1:], 1):
pf = PRIME_FACTORS[a]
cp = st & pf # common prime
if cp: # have common prime factor, need new start
while cp:
dp[0][i] = j
prev_pf = PRIME_FACTORS[arr[i]]
st -= prev_pf
cp -= prev_pf
i += 1
st |= pf
# deal with i ~ n-1
while i != n:
dp[0][i] = n
i += 1
# _print(dp[0])
# dp doubling
# dp[i][j] = dp[i-1][dp[i-1][j]]
# since dp[i-1][j] is the previous starting point of j performed 2**i times
for i in range(1, EXP):
for j in range(n):
lf = dp[i - 1][j]
dp[i][j] = n if lf == n else dp[i - 1][lf]
# Now we can performed the starting points quickly
for _ in range(q):
lf, rg = mpint()
lf = dp[0][lf - 1]
ans = 1 # 2**0 = 1
while lf < rg:
for step in range(1, EXP):
if dp[step][lf] >= rg:
# let previous bound be the new start
ans += 1 << step - 1
lf = dp[step - 1][lf]
break
print(ans)
DEBUG = 0
URL = 'https://codeforces.com/contest/1516/problem/D'
if __name__ == '__main__':
# 0: normal, 1: runner, 2: debug, 3: interactive
if DEBUG == 1:
import requests
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
else:
if DEBUG != 2:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
if DEBUG:
def print(*args, **kwargs):
_print(*args, **kwargs)
sys.stdout.flush()
main()
# Please check!
``` | output | 1 | 21,444 | 12 | 42,889 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5]. | instruction | 0 | 21,445 | 12 | 42,890 |
Tags: binary search, data structures, dp, graphs, number theory, two pointers
Correct Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
from math import gcd
input = sys.stdin.buffer.readline
V = 10**5
minfactor = list(range(V+1))
for d in range(2, V+1):
for x in range(2, V+1):
if d*x > V:
break
if minfactor[d*x] == d*x:
minfactor[d*x] = d
N, Q = map(int, input().split())
A = [0] + list(map(int, input().split())) + [1]
N += 1
M = 1
seen = [0] * (V+1)
r = 1
nxt_0 = [-1] * (N+1)
for l in range(1, N+1):
while True:
if r == N:
break
a = A[r]
d_set = set()
while a != 1:
d = minfactor[a]
d_set.add(d)
a //= d
ok = 1
for d in d_set:
if seen[d]:
ok = 0
break
if not ok:
break
else:
r += 1
for d in d_set:
seen[d] = 1
nxt_0[l] = r
a = A[l]
while a != 1:
d = minfactor[a]
seen[d] = 0
a //= d
nxt = [[-1] * (N+1) for _ in range(18)]
nxt[0] = nxt_0
for lv in range(1, 18):
for l in range(1, N+1):
nxt[lv][l] = nxt[lv-1][nxt[lv-1][l]]
for _ in range(Q):
l, r = map(int, input().split())
ans = 0
for lv in range(17, -1, -1):
l_new = nxt[lv][l]
if l_new <= r:
ans += 1 << lv
l = l_new
ans += 1
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 21,445 | 12 | 42,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5]. | instruction | 0 | 21,446 | 12 | 42,892 |
Tags: binary search, data structures, dp, graphs, number theory, two pointers
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
_print = print
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')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
_FAC = 10 ** 5
def prime_sieve(n):
"""returns a sieve of primes >= 5 and < n"""
flag = n % 6 == 2
sieve = bytearray((n // 3 + flag >> 3) + 1)
for i in range(1, int(n ** 0.5) // 3 + 1):
if not (sieve[i >> 3] >> (i & 7)) & 1:
k = (3 * i + 1) | 1
for j in range(k * k // 3, n // 3 + flag, 2 * k):
sieve[j >> 3] |= 1 << (j & 7)
for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
sieve[j >> 3] |= 1 << (j & 7)
return sieve
def prime_list(n):
"""returns a list of primes <= n"""
res = []
if n > 1:
res.append(2)
if n > 2:
res.append(3)
if n > 4:
sieve = prime_sieve(n + 1)
res.extend(3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not (sieve[i >> 3] >> (i & 7)) & 1)
return res
PRIME_FACTORS = [set() for _ in range(_FAC + 1)]
for p in prime_list(_FAC):
kp = p
while kp <= _FAC:
PRIME_FACTORS[kp].add(p)
kp += p
def dp_doubling(dp: list):
exp, n = len(dp), len(dp[0])
for i in range(1, exp):
for j in range(n):
lf = dp[i - 1][j]
dp[i][j] = n if lf == n else dp[i - 1][lf]
def query(left, right):
left = dp[0][left]
ans = 1 # 2**0 = 1
while left < right:
for step in range(1, exp):
if dp[step][left] >= right:
# let previous bound be the new start
ans += 1 << step - 1
left = dp[step - 1][left]
break
return ans
return query
# ############################## main
def main():
n, q = mpint()
exp = n.bit_length() + 1
arr = tuple(mpint())
# dp[i][j]: The new index which we need to start at if we performed it 2**i times
dp = [[0] * n for _ in range(exp)]
# dp[0][j]: i.e. the largest j s.t. lcm(arr[i:j]) = reduce(mul, arr[i:j])
# lcm(arr[i:j]) = reduce(mul, arr[i:j]) iff
# there is no common prime factor for each pair of number in arr[i:j]
# Calculating dp[0][j], using two pointers
i = 0
st = PRIME_FACTORS[arr[0]].copy()
for j, a in enumerate(arr[1:], 1):
pf = PRIME_FACTORS[a]
cp = st & pf # common prime
if cp: # have common prime factor, need new start
while cp:
dp[0][i] = j
prev_pf = PRIME_FACTORS[arr[i]]
st -= prev_pf
cp -= prev_pf
i += 1
st |= pf
# deal with i ~ n-1
while i != n:
dp[0][i] = n
i += 1
# dp doubling
query = dp_doubling(dp)
for _ in range(q):
lf, rg = mpint()
lf -= 1
print(query(lf, rg))
DEBUG = 0
URL = 'https://codeforces.com/contest/1516/problem/D'
if __name__ == '__main__':
# 0: normal, 1: runner, 2: debug, 3: interactive
if DEBUG == 1:
import requests
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
else:
if DEBUG != 2:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
if DEBUG:
def print(*args, **kwargs):
_print(*args, **kwargs)
sys.stdout.flush()
main()
# Please check!
``` | output | 1 | 21,446 | 12 | 42,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5]. | instruction | 0 | 21,447 | 12 | 42,894 |
Tags: binary search, data structures, dp, graphs, number theory, two pointers
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
def some_random_function():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function5():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
import os,sys
from io import BytesIO,IOBase
def main():
n,q = map(int,input().split())
a = list(map(int,input().split()))
inde = [[] for _ in range(10**5+1)]
for ind,i in enumerate(a):
inde[i].append(ind)
st = [n+1]*n
sieve = [0]*(10**5+1)
for i in range(2,10**5+1):
me = []
if not sieve[i]:
for x in range(i,10**5+1,i):
sieve[x] = 1
me += inde[x]
me.sort()
for j in range(len(me)-1):
st[me[j]] = min(st[me[j]],me[j+1])
for i in range(n-2,-1,-1):
st[i] = min(st[i],st[i+1])
xx = n.bit_length()
lifting = [[n+1]*xx for _ in range(n)]
for i in range(n-2,-1,-1):
if st[i] != n+1:
l = st[i]
lifting[i][0] = l
j = 0
while j != xx-1 and l != n+1 and lifting[l][j] != n+1:
lifting[i][j+1] = lifting[l][j]
l = lifting[l][j]
j += 1
powe = [pow(2,i) for i in range(xx)]
for _ in range(q):
l,r = map(lambda xxx:int(xxx)-1,input().split())
ans = 1
for j in range(xx-1,-1,-1):
if lifting[l][j] <= r:
ans += powe[j]
l = lifting[l][j]
print(ans)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def some_random_function1():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function2():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function3():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function4():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function6():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function7():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function8():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
if __name__ == '__main__':
main()
``` | output | 1 | 21,447 | 12 | 42,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5]. | instruction | 0 | 21,448 | 12 | 42,896 |
Tags: binary search, data structures, dp, graphs, number theory, two pointers
Correct Solution:
```
'''
from bisect import bisect,bisect_left
from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *'''
#------------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def A(n):return [0]*n
def AI(n,x): return [x]*n
def A2(n,m): return [[0]*m for i in range(n)]
def G(n): return [[] for i in range(n)]
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
mod=10**9+7
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
fact(x,mod)
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa.reverse()
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
if a==0:return b//c*(n+1)
if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
m=(a*n+b)//c
return n*m-floorsum(c,c-b-1,a,m-1)
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
def lowbit(n):
return n&-n
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
class ST:
def __init__(self,arr):#n!=0
n=len(arr)
mx=n.bit_length()#取不到
self.st=[[0]*mx for i in range(n)]
for i in range(n):
self.st[i][0]=arr[i]
for j in range(1,mx):
for i in range(n-(1<<j)+1):
self.st[i][j]=max(self.st[i][j-1],self.st[i+(1<<j-1)][j-1])
def query(self,l,r):
if l>r:return -inf
s=(r+1-l).bit_length()-1
return max(self.st[l][s],self.st[r-(1<<s)+1][s])
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]>self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return flag
def dij(s,graph):
d={}
d[s]=0
heap=[(0,s)]
seen=set()
while heap:
dis,u=heappop(heap)
if u in seen:
continue
seen.add(u)
for v,w in graph[u]:
if v not in d or d[v]>d[u]+w:
d[v]=d[u]+w
heappush(heap,(d[v],v))
return d
def bell(s,g):#bellman-Ford
dis=AI(n,inf)
dis[s]=0
for i in range(n-1):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change=A(n)
for i in range(n):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change[v]=1
return dis
def lcm(a,b): return a*b//gcd(a,b)
def lis(nums):
res=[]
for k in nums:
i=bisect.bisect_left(res,k)
if i==len(res):
res.append(k)
else:
res[i]=k
return len(res)
def RP(nums):#逆序对
n = len(nums)
s=set(nums)
d={}
for i,k in enumerate(sorted(s),1):
d[k]=i
bi=BIT([0]*(len(s)+1))
ans=0
for i in range(n-1,-1,-1):
ans+=bi.query(d[nums[i]]-1)
bi.update(d[nums[i]],1)
return ans
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
def nb(i,j,n,m):
for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
if 0<=ni<n and 0<=nj<m:
yield ni,nj
def topo(n):
q=deque()
res=[]
for i in range(1,n+1):
if ind[i]==0:
q.append(i)
res.append(i)
while q:
u=q.popleft()
for v in g[u]:
ind[v]-=1
if ind[v]==0:
q.append(v)
res.append(v)
return res
@bootstrap
def gdfs(r,p):
for ch in g[r]:
if ch!=p:
yield gdfs(ch,r)
yield None
flag=Prime(10**5)
t=1
for i in range(t):
n,q=RL()
a=RLL()
r=AI(n,n-1)
g=G(10**5)
x=a[-1]
while flag[x]:
c=flag[x]
while x%c==0:
x//=c
g[c].append(n-1)
if x>1:
g[x].append(n-1)
for i in range(n-2,-1,-1):
x=a[i]
#print(i,x,flag[x])
while flag[x]:
c=flag[x]
while x%c==0:
x//=c
if g[c]:
r[i]=min(r[i],g[c][-1]-1)
g[c].append(i)
if x>1:
#print(i,x,g[x])
if g[x]:
#print(i,x,g[x])
r[i]=min(r[i],g[x][-1]-1)
g[x].append(i)
#print(i,r[i],g[7])
r[i]=min(r[i],r[i+1])
dp=[[n]*18 for i in range(n+1)]
#print(r)
for i in range(n):
dp[i][0]=r[i]+1
for j in range(1,18):
for i in range(n):
#print(dp[i][j])
dp[i][j]=dp[dp[i][j-1]][j-1]
#print(dp)
for i in range(q):
a,b=RL()
a-=1
b-=1
c=0
for i in range(17,-1,-1):
if dp[a][i]>b:
continue
a=dp[a][i]
c+=1<<i
#print(i,a,c)
if a<=b:
c+=1
print(c)
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thr
ead(target=main)
t.start()
t.join()
'''
``` | output | 1 | 21,448 | 12 | 42,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5]. | instruction | 0 | 21,449 | 12 | 42,898 |
Tags: binary search, data structures, dp, graphs, number theory, two pointers
Correct Solution:
```
import sys
input_ = lambda: sys.stdin.readline().strip("\r\n")
ii = lambda : int(input_())
il = lambda : list(map(int, input_().split()))
ilf = lambda : list(map(float, input_().split()))
ip = lambda : input_()
fi = lambda : float(input_())
ap = lambda ab,bc,cd : ab[bc].append(cd)
li = lambda : list(input_())
pr = lambda x : print(x)
prinT = lambda x : print(x)
f = lambda : sys.stdout.flush()
mod = 10**9 + 7
MX = 10**5+1
prime = [ [] for i in range (MX)]
for i in range(2,MX) :
if prime[i] == [] :
for j in range (i,MX,i) :
prime[j].append(i)
n,q = il()
a = [0] + il()
nxt = [n+1 for _ in range (MX)]
dp = [ [0 for i in range (18)] for j in range (n+2)]
dp[n+1][0] = n+1
for i in range (n,0,-1) :
dp[i][0] = dp[i+1][0]
for j in prime[a[i]] :
dp[i][0] = min(dp[i][0], nxt[j])
nxt[j] = i
for i in range (n+1,0,-1) :
for j in range (1,18) :
dp[i][j] = dp[dp[i][j-1]][j-1]
for _ in range (q) :
l,r = il()
ans = 1
for i in range (17,-1,-1) :
if (dp[l][i] <= r) :
ans += 1<<i
l = dp[l][i]
print(ans)
``` | output | 1 | 21,449 | 12 | 42,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5]. | instruction | 0 | 21,450 | 12 | 42,900 |
Tags: binary search, data structures, dp, graphs, number theory, two pointers
Correct Solution:
```
import sys
import bisect
input_=lambda: sys.stdin.readline().strip("\r\n")
from math import log
from math import gcd
from random import randint
sa=lambda :input_()
sb=lambda:int(input_())
sc=lambda:input_().split()
sd=lambda:list(map(int,input_().split()))
se=lambda:float(input_())
sf=lambda:list(input_())
flsh=lambda: sys.stdout.flush()
#sys.setrecursionlimit(10**6)
mod=10**9+7
gp=[]
cost=[]
dp=[]
mx=[]
prime=[[] for i in range(10**5+3)]
def gen_prime():
n=10**5+1
for i in range(2,n+1,2):
prime[i].append(2)
for i in range(3,n+1,2):
if prime[i]==[]:
for j in range(i,n+1,i):
prime[j].append(i)
gen_prime()
def dfs(root,par):
global gp,cost,dp
dp[root]=cost[root]
for i in gp[root]:
if i==par:continue
dfs(i,root)
dp[root]=max(dp[root],dp[i])
def hnbhai():
n,q=sd()
last=[n+1 for _ in range(10**5+2)]
a=[0]+sd()
kthpar=[[0 for i in range(18)]for j in range(n+2)]
kthpar[n+1][0]=n+1
for i in range(n,0,-1):
kthpar[i][0]=kthpar[i+1][0]
for child in prime[a[i]]:
#print(child)
kthpar[i][0]=min(kthpar[i][0],last[child])
last[child]=i
##binary_lifting
for i in range(n+1,0,-1):
for j in range(1,18):
kthpar[i][j]=kthpar[kthpar[i][j-1]][j-1]
for t in range(q):
l,r=sd()
ans=1
for i in range(17,-1,-1):
if(kthpar[l][i]<=r):
ans+=1<<i
l=kthpar[l][i]
print(ans)
for _ in range(1):
hnbhai()
``` | output | 1 | 21,450 | 12 | 42,901 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5].
Submitted Solution:
```
#素因数分解、計算量はO(√N)
import sys,os,io
input = sys.stdin.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from collections import defaultdict
def sieve(n):
fact = [float('inf')]*(n+1)
fact[1] = 1
for i in range(2, n+1):
if fact[i]==float('inf'):
j = i
while j <= n:
fact[j] = min(fact[j], i)
j += i
return fact
def osa_k(n):
fct = defaultdict(lambda: 0)
while n>1:
fct[facts[n]] += 1
n //= facts[n]
return fct.keys()
N, Q = map(int, input().split())
A = list(map(int, input().split()))
facts = sieve(max(A))
facts = [osa_k(a) for a in A]
dic1 = {i:i for i in range(N)}
left = 0
lis = defaultdict(lambda: 0)
for fact in facts[0]:
lis[fact] += 1
for i in range(N):
dic1[i] = left
for j in range(left+1,N):
check = True
for fact in facts[j]:
if lis[fact]>0:
check = False
break
if not check:
break
dic1[i] = j
left += 1
for fact in facts[j]:
lis[fact] += 1
for fact in facts[i]:
lis[fact] -= 1
dic2 = {i:-1 for i in range(N)}
lis2 = [[] for _ in range(N)]
for i in range(N):
if dic2[i]==-1:
p = i
while p<N-1 and dic2[p]==-1:
lis2[i].append(p)
dic2[p] = i
p = dic1[p]+1
lis2[i].append(p)
if p<N and dic2[p]==-1:
dic2[p] = i
ans = [0]*Q
from bisect import *
for i in range(Q):
l,r = map(int, input().split())
l -= 1; r -= 1
start = l
while r>lis2[dic2[start]][-1]:
ans[i] += len(lis2[dic2[start]])-bisect_right(lis2[dic2[start]],start)
start = lis2[dic2[start]][-1]
ind_l = bisect_right(lis2[dic2[start]],start)-1
ind_r = bisect_right(lis2[dic2[start]],r)
ans[i] += ind_r - ind_l
print(*ans, sep='\n')
``` | instruction | 0 | 21,451 | 12 | 42,902 |
Yes | output | 1 | 21,451 | 12 | 42,903 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5].
Submitted Solution:
```
from sys import stdin, stdout
def cut(n, a_a):
N = max(a_a)
p_a = seive_a(N)
dic = {}
# up to 2**20
b_a = [[-1 for j in range(20)] for i in range(n)]
b_a[n-1][0] = n
for i in range(n-1, -1, -1):
if i == n - 1:
r = n
else:
r = b_a[i+1][0]
for p in p_a[a_a[i]]:
if p in dic:
r = min(r, dic[p])
dic[p] = i
b_a[i][0] = r
for i in range(1, 20):
for j in range(n):
if b_a[j][i-1] == -1 or b_a[j][i-1] == n or b_a[b_a[j][i-1]][i-1] == -1:
continue
b_a[j][i] = b_a[b_a[j][i-1]][i-1]
return b_a
def solve(b_a, l, r):
res = 0
for step in range(19, -1, -1):
if b_a[l][step] != -1 and b_a[l][step] <= r:
# print(step)
res += (1 << step)
l = b_a[l][step]
return res + 1
def seive_a(n):
p_a = [[] for i in range(n+1)]
for i in range(2, n + 1):
if len(p_a[i]) > 0:
continue
j = i
while j <= n:
p_a[j].append(i)
j += i
return p_a
n, q = map(int, stdin.readline().split())
a_a = list(map(int, stdin.readline().split()))
b_a = cut(n, a_a)
for _ in range(q):
l, r = map(int, stdin.readline().split())
res = solve(b_a, l-1, r-1)
stdout.write(str(res) + '\n')
``` | instruction | 0 | 21,452 | 12 | 42,904 |
Yes | output | 1 | 21,452 | 12 | 42,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5].
Submitted Solution:
```
from sys import stdin, stdout
import bisect
import math
def get_prime(n):
nn = math.ceil(math.sqrt(n))
prime = [2]
for x in range(3, nn+1, 2):
is_prime = True
for p in prime:
if p * p > x:
break
if x % p == 0:
is_prime = False
break
if is_prime:
prime.append(x)
return prime
def main():
n,q = list(map(int, stdin.readline().split()))
N = 10 ** 5 + 3
prime = get_prime(N)
arr = list(map(int, stdin.readline().split()))
p_dp = [n] * N
cut = [[n for _ in range(n + 1)] for _ in range(18)]
cut[0][n] = n
for i in range(n-1,-1,-1):
p_set = set()
xx = arr[i]
for p in prime:
if p * p > xx:
break
while xx % p == 0:
xx = xx // p
p_set.add(p)
if xx > 1:
p_set.add(xx)
cut[0][i] = cut[0][i + 1]
for y in p_set:
cut[0][i] = min(cut[0][i], p_dp[y])
p_dp[y] = i
for i in range(1, 18):
for j in range(n):
cut[i][j] = cut[i-1][cut[i-1][j]]
for _ in range(q):
l,r = list(map(int, stdin.readline().split()))
l -= 1
r -= 1
cost = 1
for i in range(17,-1,-1):
if cut[i][l] <= r:
cost += (2 ** i)
l = cut[i][l]
stdout.write(str(cost)+"\n")
main()
``` | instruction | 0 | 21,453 | 12 | 42,906 |
Yes | output | 1 | 21,453 | 12 | 42,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5].
Submitted Solution:
```
import sys
input = sys.stdin.buffer.readline
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
n, q = LI()
arr = LI()
prime_last_appear_at = dict()
dp = [[n] * (n+1) for i in range(18)] ## 2 ** 20
have_primes = [ [ ]for _ in range(10**5+3)]
for p in range(2,10**5+2):
if not have_primes[p]:
prime_last_appear_at[p] = n
i = p
while i < len(have_primes):
have_primes[i].append(p)
i += p
for i in range(n-1,-1,-1):
dp[0][i] = dp[0][i+1]
for p in have_primes[arr[i]]:
dp[0][i] = min(dp[0][i],prime_last_appear_at[p])
prime_last_appear_at[p] = i
for i in range(1,len(dp)):
for j in range(n):
dp[i][j] = dp[i-1][dp[i-1][j]]
for _ in range(q):
l,r = LI_()
cur = l
res = 1
for jump in range(len(dp)-1,-1,-1):
if dp[jump][cur] <= r :
res += 1 << jump
cur = dp[jump][cur]
print(res)
``` | instruction | 0 | 21,454 | 12 | 42,908 |
Yes | output | 1 | 21,454 | 12 | 42,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5].
Submitted Solution:
```
from sys import stdin, stdout
def cut(n, a_a):
s_a = seive(max(a_a))
l_a = [-1]
s = set()
for i in range(n):
if not check(a_a[i], s_a, s):
l_a.append(i-1)
l_a.append(10**20)
r_a = [10**20]
s = set()
for i in range(n-1, -1, -1):
if not check(a_a[i], s_a, s):
s = set()
r_a.append(i)
r_a.append(-1)
r_a.reverse()
return l_a, r_a
def check(n, s_a, s):
f_a = []
r = True
while n != 1:
if s_a[n] in s:
r = False
f_a.append(s_a[n])
n //= s_a[n]
if not r:
s.clear()
for f in f_a:
s.add(f)
return r
def seive(n):
s_a = [i for i in range(n+1)]
for i in range(2, n + 1):
if s_a[i] != i:
continue
j = i*i
while j <= n:
s_a[j] = i
j += i
return s_a
def solve(l_a, r_a, lv, rv):
#l1 = bs_l(l_a, lv-1)
#r1 = bs_r(l_a, rv-1)
l2 = bs_l(r_a, lv-1)
r2 = bs_r(r_a, rv-1)
#res = min(r1, r2) - max(l1, l2)
res = r2 - l2
return res
def bs_r(a_a, v):
l = 0
r = len(a_a)-1
while l < r:
m = (l + r) // 2
if a_a[m] >= v:
r = m
else:
l = m + 1
return r
def bs_l(a_a, v):
l = 0
r = len(a_a) - 1
while l < r:
m = (l + r + 1) // 2
if a_a[m] >= v:
r = m - 1
else:
l = m
return l
n, q = map(int, stdin.readline().split())
a_a = list(map(int, stdin.readline().split()))
l_a, r_a = cut(n, a_a)
for _ in range(q):
l, r = map(int, stdin.readline().split())
res = solve(l_a, r_a, l, r)
stdout.write(str(res) + '\n')
``` | instruction | 0 | 21,455 | 12 | 42,910 |
No | output | 1 | 21,455 | 12 | 42,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5].
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
_print = print
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')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
_FAC = 10 ** 5
def prime_sieve(n):
"""returns a sieve of primes >= 5 and < n"""
flag = n % 6 == 2
sieve = bytearray((n // 3 + flag >> 3) + 1)
for i in range(1, int(n ** 0.5) // 3 + 1):
if not (sieve[i >> 3] >> (i & 7)) & 1:
k = (3 * i + 1) | 1
for j in range(k * k // 3, n // 3 + flag, 2 * k):
sieve[j >> 3] |= 1 << (j & 7)
for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
sieve[j >> 3] |= 1 << (j & 7)
return sieve
def prime_list(n):
"""returns a list of primes <= n"""
res = []
if n > 1:
res.append(2)
if n > 2:
res.append(3)
if n > 4:
sieve = prime_sieve(n + 1)
res.extend(3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not (sieve[i >> 3] >> (i & 7)) & 1)
return res
PRIME_FACTORS = [set() for _ in range(_FAC + 1)]
for p in prime_list(_FAC):
kp = p
while kp <= _FAC:
PRIME_FACTORS[kp].add(p)
kp += p
# ############################## main
EXP = _FAC.bit_length() + 1 # 18, 2**18 > 1e5
def main():
n, q = mpint()
arr = tuple(mpint())
# dp[i][j]: The new index which we need to start at if we performed it 2**i times
dp = [[0] * n for _ in range(EXP)]
# dp[0][j]: i.e. the largest j s.t. lcm(arr[i:j]) = reduce(mul, arr[i:j])
# lcm(arr[i:j]) = reduce(mul, arr[i:j]) iff
# there is no common prime factor for each pair of number in arr[i:j]
# Calculating dp[0][j], using two pointers
i = 0
st = PRIME_FACTORS[arr[0]].copy()
for j, a in enumerate(arr[1:], 1):
pf = PRIME_FACTORS[a]
cp = st & pf # common prime
if cp: # have common prime factor, need new start
while cp:
dp[0][i] = j
prev_pf = PRIME_FACTORS[arr[i]]
st -= prev_pf
cp -= prev_pf
i += 1
st |= pf
# deal with i ~ n-1
while i != n:
dp[0][i] = n
i += 1
# _print(dp[0])
# dp doubling
# dp[i][j] = dp[i-1][dp[i-1][j]]
# since dp[i-1][j] is the previous starting point of j performed 2**i times
for i in range(1, EXP):
for j in range(n):
lf = dp[i - 1][j]
dp[i][j] = n if lf == n else dp[i - 1][lf]
# Now we can performed the starting points quickly
for _ in range(q):
lf, rg = mpint()
ans = 1
lf = dp[0][lf - 1]
while lf < rg:
ans += 1
for step in range(1, EXP):
if dp[step][lf] >= rg:
# let previous bound be the new start
lf = dp[step - 1][lf]
break
print(ans)
DEBUG = 0
URL = 'https://codeforces.com/contest/1516/problem/D'
if __name__ == '__main__':
# 0: normal, 1: runner, 2: debug, 3: interactive
if DEBUG == 1:
import requests
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
else:
if DEBUG != 2:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
if DEBUG:
def print(*args, **kwargs):
_print(*args, **kwargs)
sys.stdout.flush()
main()
# Please check!
``` | instruction | 0 | 21,456 | 12 | 42,912 |
No | output | 1 | 21,456 | 12 | 42,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5].
Submitted Solution:
```
#!/usr/bin/env python3
import sys, getpass
import math, random
import functools, itertools, collections, heapq, bisect
from collections import Counter, defaultdict, deque
input = sys.stdin.readline # to read input quickly
# available on Google, AtCoder Python3, not available on Codeforces
# import numpy as np
# import scipy
M9 = 10**9 + 7 # 998244353
# d4 = [(1,0),(0,1),(-1,0),(0,-1)]
# d8 = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
# d6 = [(2,0),(1,1),(-1,1),(-2,0),(-1,-1),(1,-1)] # hexagonal layout
MAXINT = sys.maxsize
# if testing locally, print to terminal with a different color
OFFLINE_TEST = getpass.getuser() == "hkmac"
# OFFLINE_TEST = False # codechef does not allow getpass
def log(*args):
if OFFLINE_TEST:
print('\033[36m', *args, '\033[0m', file=sys.stderr)
def solve(*args):
# screen input
if OFFLINE_TEST:
log("----- solving ------")
log(*args)
log("----- ------- ------")
return solve_(*args)
def read_matrix(rows):
return [list(map(int,input().split())) for _ in range(rows)]
def read_strings(rows):
return [input().strip() for _ in range(rows)]
# ---------------------------- template ends here ----------------------------
LARGE = 10**5+10
# LARGE = 100
primes = [set() for _ in range(LARGE)]
for i in range(2, LARGE):
if primes[i]:
continue
for j in range(i, LARGE, i):
primes[j].add(i)
# log(primes)
def solve_(lst, qrr):
# your solution here
count = [0 for _ in lst]
idx = 0
curbag = set()
for i,x in enumerate(lst):
newbag = primes[x]
for p in newbag:
if p in curbag:
idx += 1
curbag = newbag.copy()
break
curbag.add(p)
count[i] = idx
count2 = [0 for _ in lst]
idx = 0
curbag = set()
for i,x in enumerate(lst[::-1]):
newbag = primes[x]
for p in newbag:
if p in curbag:
idx += 1
curbag = newbag.copy()
break
curbag.add(p)
count2[i] = idx
count2 = count2[::-1]
count2 = [count[-1] - x for x in count2]
log(count)
log(count2)
res = []
for a,b in qrr:
val = max(1, count[b] - count2[a] + 1)
res.append(val)
# val2 = count2[b] - count2[a] + 1
# res.append(min(val, val2))
return res
for case_num in [0]: # no loop over test case
# for case_num in range(100): # if the number of test cases is specified
# for case_num in range(int(input())):
# read line as an integer
# k = int(input())
# read line as a string
# srr = input().strip()
# read one line and parse each word as a string
# lst = input().split()
# read one line and parse each word as an integer
_,k = list(map(int,input().split()))
lst = list(map(int,input().split()))
# read multiple rows
qrr = read_matrix(k) # and return as a list of list of int
# arr = read_strings(k) # and return as a list of str
qrr = [(a-1, b-1) for a,b in qrr]
res = solve(lst, qrr) # include input here
# print result
# Google and Facebook - case number required
# print("Case #{}: {}".format(case_num+1, res))
# Other platforms - no case number required
print("\n".join(str(x) for x in res))
# print(len(res))
# print(*res) # print a list with elements
# for r in res: # print each list in a different line
# print(res)
# print(*res)
``` | instruction | 0 | 21,457 | 12 | 42,914 |
No | output | 1 | 21,457 | 12 | 42,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time Baby Ehab will only cut and not stick. He starts with a piece of paper with an array a of length n written on it, and then he does the following:
* he picks a range (l, r) and cuts the subsegment a_l, a_{l + 1}, …, a_r out, removing the rest of the array.
* he then cuts this range into multiple subranges.
* to add a number theory spice to it, he requires that the elements of every subrange must have their product equal to their [least common multiple (LCM)](https://en.wikipedia.org/wiki/Least_common_multiple).
Formally, he partitions the elements of a_l, a_{l + 1}, …, a_r into contiguous subarrays such that the product of every subarray is equal to its LCM. Now, for q independent ranges (l, r), tell Baby Ehab the minimum number of subarrays he needs.
Input
The first line contains 2 integers n and q (1 ≤ n,q ≤ 10^5) — the length of the array a and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^5) — the elements of the array a.
Each of the next q lines contains 2 integers l and r (1 ≤ l ≤ r ≤ n) — the endpoints of this query's interval.
Output
For each query, print its answer on a new line.
Example
Input
6 3
2 3 10 7 5 14
1 6
2 4
3 5
Output
3
1
2
Note
The first query asks about the whole array. You can partition it into [2], [3,10,7], and [5,14]. The first subrange has product and LCM equal to 2. The second has product and LCM equal to 210. And the third has product and LCM equal to 70. Another possible partitioning is [2,3], [10,7], and [5,14].
The second query asks about the range (2,4). Its product is equal to its LCM, so you don't need to partition it further.
The last query asks about the range (3,5). You can partition it into [10,7] and [5].
Submitted Solution:
```
#Fast I/O
import sys,os
import math
# To enable the file I/O i the below 2 lines are uncommented.
# read from in.txt if uncommented
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
# will print on Console if file I/O is not activated
#if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')
# inputs template
from io import BytesIO, IOBase
import math as mt
def getFactorization(x):
ret = list()
while (x != 1):
ret.append(spf[x])
x = x // spf[x]
return ret
def main():
n,q=MI()
arr=list(MI())
dp=[1]
MAXN = 100002
spf = [0 for i in range(MAXN)]
spf[1] = 1
for i in range(2, MAXN):
spf[i] = i
for i in range(4, MAXN, 2):
spf[i] = 2
for i in range(3, mt.ceil(mt.sqrt(MAXN))):
if (spf[i] == i):
for j in range(i * i, MAXN, i):
if (spf[j] == j):
spf[j] = i
dick={}
j=0
while j<n:
cur=arr[j]
cul=False
dic={}
while cur!=1:
if spf[cur] in dick:
cul=True
if spf[cur] in dic:
dic[spf[cur]]+=1
else:
dic[spf[cur]]=1
cur=cur//spf[cur]
if cul:
dick=dic
dp.append(dp[-1]+1)
else:
dp.append(dp[-1])
for i in dic:
dick[i]=dic[i]
j+=1
dp[0]=0
for i in range(q):
l,r=MI()
l-=1
print(dp[r]-dp[l])
# Sample Inputs/Output
# 6 2
# 1 3 2 3 3 2
# 1 6
# 2 5
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#for array of integers
def MI():return (map(int,input().split()))
# endregion
#for fast output, always take string
def outP(var): sys.stdout.write(str(var)+'\n')
# end of any user-defined functions
MOD=10**9+7
# main functions for execution of the program.
if __name__ == '__main__':
#This doesn't works here but works wonders when submitted on CodeChef or CodeForces
main()
``` | instruction | 0 | 21,458 | 12 | 42,916 |
No | output | 1 | 21,458 | 12 | 42,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4. | instruction | 0 | 21,489 | 12 | 42,978 |
Tags: dp, number theory
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
dp = [1] * (n + 5)
tmax = [0 for _ in range(100005)]
p = [[] for _ in range(100005)]
p[1] = [1]
for i in range(2, 100001):
if (not p[i]):
for j in range(i, 100001, i):
p[j].append(i)
for i in range(len(a)):
dp[i] = max(tmax[j] for j in p[a[i]]) + 1
for j in p[a[i]]: tmax[j] = max(tmax[j], dp[i])
print(max(dp))
``` | output | 1 | 21,489 | 12 | 42,979 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4. | instruction | 0 | 21,490 | 12 | 42,980 |
Tags: dp, number theory
Correct Solution:
```
import bisect
import collections
import copy
import functools
import heapq
import itertools
import math
import random
import re
import string
import sys
import time
from typing import Counter, List
sys.setrecursionlimit(99999)
input()
mx = 10**5 + 5
f = [0] * mx
f[1] = 1
for i in range(2, mx):
if f[i] == 0:
f[i] = i
for j in range(i * i, mx, i):
if f[j] == 0:
f[j] = i
mp = collections.defaultdict(int)
for c in map(int, input().split()):
p = []
while f[c] != c:
k = f[c]
p.append(k)
while c % k == 0:
c //= k
if c > 1:
p.append(c)
if p:
mx = max(mp[x] for x in p)
for c in p:
mp[c] = mx + 1
if mp:
print(max(mp.values()))
else:
print(1)
``` | output | 1 | 21,490 | 12 | 42,981 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4. | instruction | 0 | 21,492 | 12 | 42,984 |
Tags: dp, number theory
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
dp = [1] * (n + 5)
tmax = [0 for _ in range(100005)]
p = [[] for _ in range(100005)]
p[1] = [1]
for i in range(2, 100001):
if p[i]==[]:
for j in range(i, 100001, i):
p[j].append(i)
for i in range(len(a)):
dp[i] = max(tmax[j] for j in p[a[i]]) + 1
for j in p[a[i]]: tmax[j] = max(tmax[j], dp[i])
print(max(dp))
``` | output | 1 | 21,492 | 12 | 42,985 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4. | instruction | 0 | 21,493 | 12 | 42,986 |
Tags: dp, number theory
Correct Solution:
```
"""
#If FastIO not needed, used this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import defaultdict as dd, deque as dq
import math, string
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
MOD = 10**9+7
def prime_factors(n):
factors = []
num = 0
while n % 2 == 0:
num += 1
n //= 2
if num:
factors.append(2)
i = 3
while n > 1 and i*i <= n:
num = 0
while n % i == 0:
num += 1
n //= i
if num:
factors.append(i)
i += 2
if n > 2:
factors.append(n)
return factors
"""
We want to add A[i] onto the end of the longest possible sequence we can
We already know that numbers are strictly increasing, so it's just a case of finding non-coprimes
For each prime in a number, we look up the previous occurence of that prime and add one to that sequence, and take the max of these
"""
def solve():
N = getInt()
A = [0] + getInts()
prime_last_index = dd(int)
dp = [1]*(N+1)
for i in range(1,N+1):
facs = prime_factors(A[i])
for fac in facs:
last = prime_last_index[fac]
if last: dp[i] = max(dp[last]+1,dp[i])
prime_last_index[fac] = i
return max(dp)
#for _ in range(getInt()):
print(solve())
``` | output | 1 | 21,493 | 12 | 42,987 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4. | instruction | 0 | 21,495 | 12 | 42,990 |
Tags: dp, number theory
Correct Solution:
```
n = 111111
p = [0] * n
t = {}
t[1] = [1]
for i in range(2, n):
if t.get(i,0) == 0:
t[i] = [i]
for j in range(2 * i, n, i):
if j not in t:
t[j] = []
t[j].append(i)
input()
a = list(map(int, input().split()))
for i in a:
x = max(p[j] for j in t[i]) + 1
for j in t[i]:
p[j] = x
print(max(p))
``` | output | 1 | 21,495 | 12 | 42,991 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4. | instruction | 0 | 21,496 | 12 | 42,992 |
Tags: dp, number theory
Correct Solution:
```
lis=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973]
n = int(input())
li = list(map(int,input().split()))
has=[0]*(100005)
for i in li:
mx=0
tmp=[]
for j in lis:
if i<j:
break
if i%j==0:
mx = max(mx,has[j]+1)
tmp.append(j)
for j in tmp:
has[j]=mx
print(max(has+[1]))
``` | output | 1 | 21,496 | 12 | 42,993 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.
Submitted Solution:
```
import os
import sys
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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
from collections import Counter
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
import heapq
# c=sorted((i,int(val))for i,val in enumerate(input().split()))
# n = int(input())
# ls = list(map(int, input().split()))
#n=int(input())
#arr = list(map(int, input().split()))
#for _ in range(int(input())):
n=int(input())
#n,x= map(int, input().split())
arr = list(map(int, input().split()))
dp=[0 for i in range(arr[-1]+1)]
for i in arr:
divisors=set()
for d in range(2,int(i**0.5)+1):
if i%d==0:
divisors.add(d)
divisors.add(i//d)
divisors.add(i)
if divisors:
dp[i]=max(dp[k] for k in divisors)+1
for j in divisors:
dp[j]=dp[i]
if n==1:
print(1)
else:
print(max(dp))
``` | instruction | 0 | 21,497 | 12 | 42,994 |
Yes | output | 1 | 21,497 | 12 | 42,995 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.
Submitted Solution:
```
# import math
# import collections
# from itertools import permutations
# from itertools import combinations
# import sys
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
'''def is_prime(n):
j=2
while j*j<=n:
if n%j==0:
return 0
j+=1
return 1'''
'''def gcd(x, y):
while(y):
x, y = y, x % y
return x'''
'''fact=[]
def factors(n) :
i = 1
while i <= math.sqrt(n):
if (n % i == 0) :
if (n / i == i) :
fact.append(i)
else :
fact.append(i)
fact.append(n//i)
i = i + 1'''
n = 100001
p = [0] * n
y = [[] for i in range(n)]
y[1] = [1]
for i in range(2, n):
if not y[i]:
y[i] = [i]
for j in range(2 * i, n, i): y[j].append(i)
def prob():
n = int(input())
# s=input()
l = [int(x) for x in input().split()]
# a,b = list(map(int , input().split()))
for i in l:
k = max(p[j] for j in y[i])+1
for j in y[i]:
p[j] = k
print(max(p))
t=1
# t=int(input())
for _ in range(0,t):
prob()
``` | instruction | 0 | 21,498 | 12 | 42,996 |
Yes | output | 1 | 21,498 | 12 | 42,997 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.
Submitted Solution:
```
n = 100001
p = [0] * n
t = [[] for i in range(n)]
t[1] = [1]
for i in range(2, n):
if not t[i]:
t[i] = [i]
for j in range(2 * i, n, i): t[j].append(i)
input()
a = list(map(int, input().split()))
for i in a:
x = max(p[j] for j in t[i]) + 1
for j in t[i]: p[j] = x
print(max(p))
``` | instruction | 0 | 21,499 | 12 | 42,998 |
Yes | output | 1 | 21,499 | 12 | 42,999 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.
Submitted Solution:
```
m=10**5+1
p=[0]*m
t=[[] for i in range(m)]
t[1]=[1]
for i in range(2,m):
if not t[i]:
t[i]=[i]
for j in range(2*i,m,i):
t[j].append(i)
n=int(input())
a=list(map(int,input().split()))
for i in range(n):
x=max(p[j] for j in t[a[i]])+1
for j in t[a[i]]:
p[j]=x
print(max(p))
``` | instruction | 0 | 21,500 | 12 | 43,000 |
Yes | output | 1 | 21,500 | 12 | 43,001 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.
Submitted Solution:
```
#from time import time
def isEmpty(p):
return len(p) == 0
def topo(p):
return p[-1]
from math import gcd
n = int(input())
a = input().split(" ")
a = map(int, a)
a = list(a)
#t = time()
p = [] #pilha
#estritamente crescente
#adjacentes não são coprimos, gcd(x,x+1) > 1
#todos os elementos são good integers
#encontrar o comprimento da maior good sequence
count = 0
maximo = 0
i = 0
j = 0
count = 0
while i < n:
if len(p) == 0:
p.append(a[i])
elif gcd(topo(p), a[i]) > 1:
p.append(a[i])
i += 1
if i == n:
maximo = max(maximo, len(p))
p = []
j += 1
i = j
count += 1
if count*count > n//2:
break
print(maximo)
#print(time() - t)
``` | instruction | 0 | 21,501 | 12 | 43,002 |
No | output | 1 | 21,501 | 12 | 43,003 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.
Submitted Solution:
```
"""
Vamos resolver esse problema com programação dinâmica. Seja D(x) o conjunto dos divisores de x e dp(d, i) o tamanho
da maior subsequência boa considerando apenas os i primeiros números onde o último número escolhido tem d como divisor.
Conseguindo calcular essas duas funções, nossa solução é max(dp(d, n) ∀d).
D(x) pode ser calculado com um crivo, e toma tempo O(nlogn).
dp(d, i) pode ser calculada com a seguinte recorrência.
dp(d, i) = dp(d, i − 1) se d não divide v[i]
dp(d, i) = 1 + max(dp(g, i − 1) ∀g ∈ D(v[i])) se d divide v[i]
Criar esses dois estados usa O(n**2) memória, que podemos reduzir para O(n) observando que nunca precisamos dos
resultados do prefixo i − 2 calculando o prefixo i.
Note que só precisamos calcular os estados dp(d, i) se d divide v[i]. O que nos da uma solução O(n√n).
"""
from math import floor, sqrt
def div(x):
# Crivo de Erastótenes
primos = [1 for i in range(x+1)]
p = 2
while p < x+1:
if primos[p] == 1:
for i in range(p*p,x+1,p):
if primos[i] == 1:
primos[i] = p
primos[p] = p
p += 1
return primos
def fat(mindiv,x):
fat = []
while x!= 1:
fat.append(mindiv[x])
x //= mindiv[x]
return set(fat)
def main():
n = int(input())
arr = input().split()
arr = [int(x) for x in arr]
mindiv = div(arr[-1])
seq = [0 for i in range(arr[-1])]
for num in arr:
fatores = fat(mindiv,num)
tam = 0
for f in fatores:
tam = max(tam,seq[f])
for f in fatores:
seq[f] += 1
print(max(seq))
main()
``` | instruction | 0 | 21,502 | 12 | 43,004 |
No | output | 1 | 21,502 | 12 | 43,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.
Submitted Solution:
```
'''input
10
2 4 8 67 128 324 789 1296 39877 98383
'''
from sys import stdin
def get_prime_dict():
N = 10 ** 5
spf = [0] * (N + 1)
primes = dict()
for i in range(2, N + 1):
if spf[i] == 0:
spf[i] = i
primes[i] = 0
j = i * i
while j <= N:
if spf[j] == 0:
spf[j] = i
j += i
return primes, spf
# main starts
primes, spf = get_prime_dict()
n = int(stdin.readline().strip())
arr = list(map(int, stdin.readline().split()))
best = 0
for i in range(n):
x = arr[i]
while x > 1:
d = spf[x]
best = max(primes[d] + 1, best)
primes[d] = best
while x > 1 and x % d == 0 :
x //= d
mx_len = 1
for i in primes:
mx_len = max(mx_len, primes[i])
print(mx_len)
``` | instruction | 0 | 21,503 | 12 | 43,006 |
No | output | 1 | 21,503 | 12 | 43,007 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Squirrel Liss is interested in sequences. She also has preferences of integers. She thinks n integers a1, a2, ..., an are good.
Now she is interested in good sequences. A sequence x1, x2, ..., xk is called good if it satisfies the following three conditions:
* The sequence is strictly increasing, i.e. xi < xi + 1 for each i (1 ≤ i ≤ k - 1).
* No two adjacent elements are coprime, i.e. gcd(xi, xi + 1) > 1 for each i (1 ≤ i ≤ k - 1) (where gcd(p, q) denotes the greatest common divisor of the integers p and q).
* All elements of the sequence are good integers.
Find the length of the longest good sequence.
Input
The input consists of two lines. The first line contains a single integer n (1 ≤ n ≤ 105) — the number of good integers. The second line contains a single-space separated list of good integers a1, a2, ..., an in strictly increasing order (1 ≤ ai ≤ 105; ai < ai + 1).
Output
Print a single integer — the length of the longest good sequence.
Examples
Input
5
2 3 4 6 9
Output
4
Input
9
1 2 3 5 6 7 8 9 10
Output
4
Note
In the first example, the following sequences are examples of good sequences: [2; 4; 6; 9], [2; 4; 6], [3; 9], [6]. The length of the longest good sequence is 4.
Submitted Solution:
```
import math
n = int(input())
arr = list(map(int,input().split()))
if n == 1 :
print(1)
else :
brr = arr
dp = []
for _ in range(n) :
temp = []
for _ in range(n) :
temp.append(0)
dp.append(temp)
for i in range(1,n) :
for j in range(1,n) :
if i == 1 or j == 1 :
if math.gcd(arr[i],brr[j-1]) > 1:
dp[i][j] = 2
else :
dp[i][j] = 1
else :
if math.gcd(arr[i],brr[j-1]) > 1:
dp[i][j]= 1 + dp[i-1][j-1]
else :
dp[i][j]= max(dp[i][j-1],dp[i-1][j-1])
if n == 756 :
print(dp[378][755],dp[379][755],dp[377][755])
else :
print(dp[n-1][n-1])
``` | instruction | 0 | 21,504 | 12 | 43,008 |
No | output | 1 | 21,504 | 12 | 43,009 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For the given sequence with n different elements find the number of increasing subsequences with k + 1 elements. It is guaranteed that the answer is not greater than 8·1018.
Input
First line contain two integer values n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ 10) — the length of sequence and the number of elements in increasing subsequences.
Next n lines contains one integer ai (1 ≤ ai ≤ n) each — elements of sequence. All values ai are different.
Output
Print one integer — the answer to the problem.
Examples
Input
5 2
1
2
3
5
4
Output
7 | instruction | 0 | 21,618 | 12 | 43,236 |
Tags: data structures, dp
Correct Solution:
```
from bisect import insort,bisect_right,bisect_left
from sys import stdout, stdin, setrecursionlimit
from math import sqrt,ceil,floor,factorial,gcd,log2,log10
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from string import *
from queue import *
from heapq import heappush, heappop, heapify
from re import *
from os import *
####################################---fast-input-output----#########################################
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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
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:
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")
stdin, stdout = IOWrapper(stdin), IOWrapper(stdout)
graph, mod, szzz = {}, 10**9 + 7, lambda: sorted(zzz())
def getStr(): return input()
def getInt(): return int(input())
def listStr(): return list(input())
def getStrs(): return input().split()
def isInt(s): return '0' <= s[0] <= '9'
def input(): return stdin.readline().strip()
def zzz(): return [int(i) for i in input().split()]
def output(answer, end='\n'): stdout.write(str(answer) + end)
def lcd(xnum1, xnum2): return (xnum1 * xnum2 // gcd(xnum1, xnum2))
def getPrimes(N = 10**5):
SN = int(sqrt(N))
sieve = [i for i in range(N+1)]
sieve[1] = 0
for i in sieve:
if i > SN:
break
if i == 0:
continue
for j in range(2*i, N+1, i):
sieve[j] = 0
prime = [i for i in range(N+1) if sieve[i] != 0]
return prime
def primeFactor(n,prime=getPrimes()):
lst = []
mx=int(sqrt(n))+1
for i in prime:
if i>mx:break
while n%i==0:
lst.append(i)
n//=i
if n>1:
lst.append(n)
return lst
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
#################################################---Some Rule For Me To Follow---#################################
"""
--instants of Reading problem continuously try to understand them.
--If you Know some-one , Then you probably don't know him !
--Try & again try, maybe you're just one statement away!
"""
##################################################---START-CODING---###############################################
n,k = zzz()
arr = [getInt() for i in range(n)]
dp = [[0 for i in range(n+1)] for j in range(k+1)]
def query(arr,ind):
res= 0
while ind>0:
res+=arr[ind]
ind-=ind&-ind
return res
def update(arr,pos,val):
while pos<=n:
arr[pos]+=val
pos+=(pos&-pos)
res = [1]*n
for i in range(n):
update(dp[0],arr[i],1)
for j in range(1,k+1):
res[i]=query(dp[j-1],arr[i]-1)
update(dp[j],arr[i],res[i])
print(sum(res))
``` | output | 1 | 21,618 | 12 | 43,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For the given sequence with n different elements find the number of increasing subsequences with k + 1 elements. It is guaranteed that the answer is not greater than 8·1018.
Input
First line contain two integer values n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ 10) — the length of sequence and the number of elements in increasing subsequences.
Next n lines contains one integer ai (1 ≤ ai ≤ n) each — elements of sequence. All values ai are different.
Output
Print one integer — the answer to the problem.
Examples
Input
5 2
1
2
3
5
4
Output
7 | instruction | 0 | 21,619 | 12 | 43,238 |
Tags: data structures, dp
Correct Solution:
```
import sys
def update(BIT, i, value):
while i <= len(BIT) - 1:
BIT[i] += value
i += i & -i
def query(BIT, start, end):
if start > 0:
return query(BIT, 0, end) - query(BIT, 0, start - 1)
res = 0
while end > 0:
res += BIT[end]
end -= end & -end
return res
def read_str():
return sys.stdin.readline().strip()
def read_ints():
return list(map(int, sys.stdin.readline().strip().split()))
n, k = list(map(int, input().split()))
a = [read_ints()[0] for _ in range(n)]
dp = [[0] * (n+1) for i in range(k+1)]
res = [1] * n
for i in range(n):
update(dp[0], a[i], 1)
for j in range(1, k+1):
res[i] = query(dp[j-1], 0, a[i]-1)
update(dp[j], a[i], res[i])
print(sum(res))
``` | output | 1 | 21,619 | 12 | 43,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For the given sequence with n different elements find the number of increasing subsequences with k + 1 elements. It is guaranteed that the answer is not greater than 8·1018.
Input
First line contain two integer values n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ 10) — the length of sequence and the number of elements in increasing subsequences.
Next n lines contains one integer ai (1 ≤ ai ≤ n) each — elements of sequence. All values ai are different.
Output
Print one integer — the answer to the problem.
Examples
Input
5 2
1
2
3
5
4
Output
7 | instruction | 0 | 21,620 | 12 | 43,240 |
Tags: data structures, dp
Correct Solution:
```
import os
from io import BytesIO
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def getSum( BITree, index):
sum = 0
while (index > 0):
sum += BITree[index]
index -= index & (-index)
return sum
def updateBIT(BITree, n, index, val):
while (index <= n):
BITree[index] += val
index += index & (-index)
a, b = map(int, input().split())
c = [int(input())for i in range(a)]
BIT = [[0] * (a + 1 )for i in range(b+1)]
result = [1] * a
for i in range(a):
updateBIT(BIT[0],a,c[i],1)
for j in range(1, b+1):
result[i] = getSum(BIT[j-1], c[i]-1)
updateBIT(BIT[j],a,c[i],result[i])
print(sum(result))
``` | output | 1 | 21,620 | 12 | 43,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For the given sequence with n different elements find the number of increasing subsequences with k + 1 elements. It is guaranteed that the answer is not greater than 8·1018.
Input
First line contain two integer values n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ 10) — the length of sequence and the number of elements in increasing subsequences.
Next n lines contains one integer ai (1 ≤ ai ≤ n) each — elements of sequence. All values ai are different.
Output
Print one integer — the answer to the problem.
Examples
Input
5 2
1
2
3
5
4
Output
7 | instruction | 0 | 21,621 | 12 | 43,242 |
Tags: data structures, dp
Correct Solution:
```
from sys import stdin
def main():
n, k = map(int, input().split())
dp = [[0] * (n + 1) for _ in range(k + 1)]
col0, dp1 = dp[0], dp[1:]
for x in map(int, stdin.read().splitlines()):
x1 = x
while x1 <= n:
col0[x1] += 1
x1 += x1 & (-x1)
for col1, col2 in zip(dp, dp1):
res, x1 = 0, x - 1
while x1:
res += col1[x1]
x1 -= x1 & (-x1)
x1 = x
while x1 <= n:
col2[x1] += res
x1 += x1 & (-x1)
res = 0
while n:
res += dp[k][n]
n -= n & (-n)
print(res)
if __name__ == '__main__':
main()
``` | output | 1 | 21,621 | 12 | 43,243 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.