message stringlengths 2 59.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 37 108k | cluster float64 20 20 | __index_level_0__ int64 74 217k |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
Find the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Constraints
* 2 \leq K \leq 10^5
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Examples
Input
6
Output
3
Input
41
Output
5
Input
79992
Output
36 | instruction | 0 | 97,705 | 20 | 195,410 |
"Correct Solution:
```
from collections import deque
K = int(input())
G = [[] for i in range(K)]
for i in range(K):
G[i].append(((10 * i) % K, 0))
G[i].append(((i + 1) % K, 1))
dist = [float('inf')] * K
dist[1] = 1
que = deque()
que.append(1)
while que:
n = que.pop()
for v, c in G[n]:
if dist[v] > dist[n] + c:
dist[v] = dist[n] + c
if c == 0:
que.append(v)
else:
que.appendleft(v)
print(dist[0])
``` | output | 1 | 97,705 | 20 | 195,411 |
Provide a correct Python 3 solution for this coding contest problem.
Find the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Constraints
* 2 \leq K \leq 10^5
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Examples
Input
6
Output
3
Input
41
Output
5
Input
79992
Output
36 | instruction | 0 | 97,706 | 20 | 195,412 |
"Correct Solution:
```
from collections import deque
def bfs01(K,adjlist):
reached=[False]*K
d=deque()
d.append((1,0))
reached[1]=True
while True:
cur=d.popleft()
reached[cur[0]]=True
if cur[0]==0:
return cur[1]
for j,w in adjlist[cur[0]]:
if w==0:
if not reached[j]:
d.appendleft((j,cur[1]))
elif w==1:
if not reached[j]:
d.append((j,cur[1]+1))
K=int(input())
adjlist=[[] for _ in range(K)]
for i in range(K):
to1=(i+1)%K
to2=(10*i)%K
if to1==to2:
adjlist[i]=[(to2,0)]
else:
adjlist[i]=[(to1,1),(to2,0)]
print(bfs01(K,adjlist)+1)
``` | output | 1 | 97,706 | 20 | 195,413 |
Provide a correct Python 3 solution for this coding contest problem.
Find the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Constraints
* 2 \leq K \leq 10^5
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Examples
Input
6
Output
3
Input
41
Output
5
Input
79992
Output
36 | instruction | 0 | 97,707 | 20 | 195,414 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
from heapq import heappush,heappop
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()
def main():
def dijkstra(start,n,edges):
d=[INF]*n
used=[False]*n
d[start]=0
used[start]=True
edgelist=[]
for edge in edges[start]:
heappush(edgelist,edge)
while edgelist:
minedge=heappop(edgelist)
if used[minedge[1]]:
continue
v=minedge[1]
d[v]=minedge[0]
used[v]=True
for edge in edges[v]:
if not used[edge[1]]:
heappush(edgelist,(edge[0]+d[v],edge[1]))
return d
K=int(input())
edges=[[] for _ in range(K)]
for i in range(K):
edges[i].append((1,(i+1)%K))
edges[i].append((0,i*10%K))
d=dijkstra(1,K,edges)
print(d[0]+1)
if __name__ == '__main__':
main()
``` | output | 1 | 97,707 | 20 | 195,415 |
Provide a correct Python 3 solution for this coding contest problem.
Find the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Constraints
* 2 \leq K \leq 10^5
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Examples
Input
6
Output
3
Input
41
Output
5
Input
79992
Output
36 | instruction | 0 | 97,708 | 20 | 195,416 |
"Correct Solution:
```
from collections import deque
k = int(input())
d = [-1] * (k * 10)
d[0] = 0
q = deque([0])
ans = 100000000
while q:
p = q.pop()
x, r = p // 10, p % 10
if r < 9:
t = (x + 1) % k * 10 + r + 1
if t // 10 == 0:
ans = min(ans, d[p] + 1)
elif d[t] == -1:
q.appendleft(t)
d[t] = d[p] + 1
t = (x * 10) % k * 10
if d[p] != 0 and t // 10 == 0:
ans = min(ans, d[p])
elif d[t] == -1:
q.append(t)
d[t] = d[p]
print(ans)
``` | output | 1 | 97,708 | 20 | 195,417 |
Provide a correct Python 3 solution for this coding contest problem.
Find the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Constraints
* 2 \leq K \leq 10^5
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Examples
Input
6
Output
3
Input
41
Output
5
Input
79992
Output
36 | instruction | 0 | 97,709 | 20 | 195,418 |
"Correct Solution:
```
import sys
# import math
# import queue
# import copy
# import bisect#2ๅๆข็ดข
from collections import deque
def input():
return sys.stdin.readline()[:-1]
def inputi():
return int(input())
K=inputi()
vals=[10**5+1]*K
visit=[]
vals[1]=0
q = deque([1])
flag=False
while len(q)>0:
s=q.popleft()
vs=vals[s]
if s==0:
print(vs+1)
flag=True
break
#visit.append(s)
s0=(10*s)%K
if vs<vals[s0]:
vals[s0]=vs
q.appendleft(s0)
s1=(s+1)%K
if vs+1<vals[s1]:
vals[s1]=vs+1
q.append(s1)
#print(q,s,s0,s1,vals)
#if flag==False:
# print(vals[0]+1)
``` | output | 1 | 97,709 | 20 | 195,419 |
Provide a correct Python 3 solution for this coding contest problem.
Find the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Constraints
* 2 \leq K \leq 10^5
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Examples
Input
6
Output
3
Input
41
Output
5
Input
79992
Output
36 | instruction | 0 | 97,710 | 20 | 195,420 |
"Correct Solution:
```
import sys
from collections import deque
sys.setrecursionlimit(10**7)
k=int(input())
g=[[] for i in range(k)]
for i in range(k):
g[i].append(((i+1)%k,1))
if i:
g[i].append((10*i%k,0))
dq=deque([1])
res=[float('inf')]*k
res[1]=1
while dq:
v=dq.popleft()
if v==0:
break
for t,cost in g[v]:
if res[t]<=res[v]+cost:
continue
res[t]=res[v]+cost
if cost:
dq.append(t)
else:
dq.appendleft(t)
print(res[0])
``` | output | 1 | 97,710 | 20 | 195,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Find the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Constraints
* 2 \leq K \leq 10^5
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print the smallest possible sum of the digits in the decimal notation of a positive multiple of K.
Examples
Input
6
Output
3
Input
41
Output
5
Input
79992
Output
36
Submitted Solution:
```
import sys
def I(): return int(sys.stdin.readline().rstrip())
K = I()
Graph = [0]*K
for i in range(K):
if (i+1) % K != (10*i) % K:
Graph[i] = [(1,(i+1) % K),(0,(10*i) % K)] # 1ใๅ ใใ,10ๅใใ
else:
Graph[i] = [(0,(10*i) % K)]
# dijkstra
from heapq import heappush,heappop
d = [100]*K
d[1] = 1
q = []
heappush(q,(1,1))
v = [False]*K
while q:
a,n = heappop(q)
if v[n]:
continue
v[n] = True
for da,dn in Graph[n]:
if v[dn]:
continue
if a+da < d[dn]:
d[dn] = a+da
heappush(q,(a+da,dn))
print(d[0])
``` | instruction | 0 | 97,713 | 20 | 195,426 |
Yes | output | 1 | 97,713 | 20 | 195,427 |
Provide a correct Python 3 solution for this coding contest problem.
Today's Random Number
E869120 You ran a campaign called "Today's Random Numbers" for N days. This is a project to generate a random number once a day and post the value on Twitter.
The "random numbers of the day" on day $ 1, 2, 3, \ dots, N $ were $ A_1, A_2, A_3, \ dots, A_N $, respectively.
E869120 You would be happy if today's random number is higher than yesterday's random number.
How many times in the $ N $ day did E869120 make you happy with "Today's Random Numbers"?
input
Input is given from standard input in the following format.
$ N $
$ A_1 $ $ A_2 $ $ A_3 $ $ \ dots $ $ A_N $
output
Print out the number of times E869120 was pleased with "Today's Random Numbers" in one line in $ N $ days.
However, insert a line break at the end.
Constraint
* $ 1 \ leq N \ leq 100000 \ (= 10 ^ 5) $
* $ 1 \ leq A_i \ leq 1000000000 \ (= 10 ^ 9) $
* All inputs are integers.
Input example 1
Five
8 6 9 1 20
Output example 1
2
On the 3rd and 5th days, E869120 is happy.
Input example 2
6
3 3 4 3 3 4
Output example 2
2
On the 3rd and 6th days, E869120 is happy.
Input example 3
Ten
10 9 8 7 6 5 4 3 2 1
Output example 3
0
E869120 You will not be happy with "Today's Random Numbers".
Example
Input
5
8 6 9 1 20
Output
2 | instruction | 0 | 97,797 | 20 | 195,594 |
"Correct Solution:
```
input()
l = list(map(int,input().split()))
cnt = 0
for i in range(len(l)-1):
if l[i]<l[i+1]:
cnt+=1
print(cnt)
``` | output | 1 | 97,797 | 20 | 195,595 |
Provide a correct Python 3 solution for this coding contest problem.
Today's Random Number
E869120 You ran a campaign called "Today's Random Numbers" for N days. This is a project to generate a random number once a day and post the value on Twitter.
The "random numbers of the day" on day $ 1, 2, 3, \ dots, N $ were $ A_1, A_2, A_3, \ dots, A_N $, respectively.
E869120 You would be happy if today's random number is higher than yesterday's random number.
How many times in the $ N $ day did E869120 make you happy with "Today's Random Numbers"?
input
Input is given from standard input in the following format.
$ N $
$ A_1 $ $ A_2 $ $ A_3 $ $ \ dots $ $ A_N $
output
Print out the number of times E869120 was pleased with "Today's Random Numbers" in one line in $ N $ days.
However, insert a line break at the end.
Constraint
* $ 1 \ leq N \ leq 100000 \ (= 10 ^ 5) $
* $ 1 \ leq A_i \ leq 1000000000 \ (= 10 ^ 9) $
* All inputs are integers.
Input example 1
Five
8 6 9 1 20
Output example 1
2
On the 3rd and 5th days, E869120 is happy.
Input example 2
6
3 3 4 3 3 4
Output example 2
2
On the 3rd and 6th days, E869120 is happy.
Input example 3
Ten
10 9 8 7 6 5 4 3 2 1
Output example 3
0
E869120 You will not be happy with "Today's Random Numbers".
Example
Input
5
8 6 9 1 20
Output
2 | instruction | 0 | 97,798 | 20 | 195,596 |
"Correct Solution:
```
from itertools import *
from bisect import *
from math import *
from collections import *
from heapq import *
from random import *
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def MF(): return map(float, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LF(): return list(map(float, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
dij = [(1, 0), (0, 1), (-1, 0), (0, -1)]
def main():
input()
aa=LI()
ans=0
for a0,a1 in zip(aa,aa[1:]):
if a0<a1:ans+=1
print(ans)
main()
``` | output | 1 | 97,798 | 20 | 195,597 |
Provide a correct Python 3 solution for this coding contest problem.
Today's Random Number
E869120 You ran a campaign called "Today's Random Numbers" for N days. This is a project to generate a random number once a day and post the value on Twitter.
The "random numbers of the day" on day $ 1, 2, 3, \ dots, N $ were $ A_1, A_2, A_3, \ dots, A_N $, respectively.
E869120 You would be happy if today's random number is higher than yesterday's random number.
How many times in the $ N $ day did E869120 make you happy with "Today's Random Numbers"?
input
Input is given from standard input in the following format.
$ N $
$ A_1 $ $ A_2 $ $ A_3 $ $ \ dots $ $ A_N $
output
Print out the number of times E869120 was pleased with "Today's Random Numbers" in one line in $ N $ days.
However, insert a line break at the end.
Constraint
* $ 1 \ leq N \ leq 100000 \ (= 10 ^ 5) $
* $ 1 \ leq A_i \ leq 1000000000 \ (= 10 ^ 9) $
* All inputs are integers.
Input example 1
Five
8 6 9 1 20
Output example 1
2
On the 3rd and 5th days, E869120 is happy.
Input example 2
6
3 3 4 3 3 4
Output example 2
2
On the 3rd and 6th days, E869120 is happy.
Input example 3
Ten
10 9 8 7 6 5 4 3 2 1
Output example 3
0
E869120 You will not be happy with "Today's Random Numbers".
Example
Input
5
8 6 9 1 20
Output
2 | instruction | 0 | 97,799 | 20 | 195,598 |
"Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
ans = 0
for i in range(1,n):
if a[i-1] < a[i]:
ans += 1
print(ans)
``` | output | 1 | 97,799 | 20 | 195,599 |
Provide a correct Python 3 solution for this coding contest problem.
Today's Random Number
E869120 You ran a campaign called "Today's Random Numbers" for N days. This is a project to generate a random number once a day and post the value on Twitter.
The "random numbers of the day" on day $ 1, 2, 3, \ dots, N $ were $ A_1, A_2, A_3, \ dots, A_N $, respectively.
E869120 You would be happy if today's random number is higher than yesterday's random number.
How many times in the $ N $ day did E869120 make you happy with "Today's Random Numbers"?
input
Input is given from standard input in the following format.
$ N $
$ A_1 $ $ A_2 $ $ A_3 $ $ \ dots $ $ A_N $
output
Print out the number of times E869120 was pleased with "Today's Random Numbers" in one line in $ N $ days.
However, insert a line break at the end.
Constraint
* $ 1 \ leq N \ leq 100000 \ (= 10 ^ 5) $
* $ 1 \ leq A_i \ leq 1000000000 \ (= 10 ^ 9) $
* All inputs are integers.
Input example 1
Five
8 6 9 1 20
Output example 1
2
On the 3rd and 5th days, E869120 is happy.
Input example 2
6
3 3 4 3 3 4
Output example 2
2
On the 3rd and 6th days, E869120 is happy.
Input example 3
Ten
10 9 8 7 6 5 4 3 2 1
Output example 3
0
E869120 You will not be happy with "Today's Random Numbers".
Example
Input
5
8 6 9 1 20
Output
2 | instruction | 0 | 97,800 | 20 | 195,600 |
"Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
ans = 0
for i in range(n-1):
if a[i] < a[i + 1]:
ans += 1
print(ans)
``` | output | 1 | 97,800 | 20 | 195,601 |
Provide a correct Python 3 solution for this coding contest problem.
Today's Random Number
E869120 You ran a campaign called "Today's Random Numbers" for N days. This is a project to generate a random number once a day and post the value on Twitter.
The "random numbers of the day" on day $ 1, 2, 3, \ dots, N $ were $ A_1, A_2, A_3, \ dots, A_N $, respectively.
E869120 You would be happy if today's random number is higher than yesterday's random number.
How many times in the $ N $ day did E869120 make you happy with "Today's Random Numbers"?
input
Input is given from standard input in the following format.
$ N $
$ A_1 $ $ A_2 $ $ A_3 $ $ \ dots $ $ A_N $
output
Print out the number of times E869120 was pleased with "Today's Random Numbers" in one line in $ N $ days.
However, insert a line break at the end.
Constraint
* $ 1 \ leq N \ leq 100000 \ (= 10 ^ 5) $
* $ 1 \ leq A_i \ leq 1000000000 \ (= 10 ^ 9) $
* All inputs are integers.
Input example 1
Five
8 6 9 1 20
Output example 1
2
On the 3rd and 5th days, E869120 is happy.
Input example 2
6
3 3 4 3 3 4
Output example 2
2
On the 3rd and 6th days, E869120 is happy.
Input example 3
Ten
10 9 8 7 6 5 4 3 2 1
Output example 3
0
E869120 You will not be happy with "Today's Random Numbers".
Example
Input
5
8 6 9 1 20
Output
2 | instruction | 0 | 97,801 | 20 | 195,602 |
"Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
count = 0
for i in range(1,n):
if a[i-1] < a[i]:
count += 1
print(count)
``` | output | 1 | 97,801 | 20 | 195,603 |
Provide a correct Python 3 solution for this coding contest problem.
Today's Random Number
E869120 You ran a campaign called "Today's Random Numbers" for N days. This is a project to generate a random number once a day and post the value on Twitter.
The "random numbers of the day" on day $ 1, 2, 3, \ dots, N $ were $ A_1, A_2, A_3, \ dots, A_N $, respectively.
E869120 You would be happy if today's random number is higher than yesterday's random number.
How many times in the $ N $ day did E869120 make you happy with "Today's Random Numbers"?
input
Input is given from standard input in the following format.
$ N $
$ A_1 $ $ A_2 $ $ A_3 $ $ \ dots $ $ A_N $
output
Print out the number of times E869120 was pleased with "Today's Random Numbers" in one line in $ N $ days.
However, insert a line break at the end.
Constraint
* $ 1 \ leq N \ leq 100000 \ (= 10 ^ 5) $
* $ 1 \ leq A_i \ leq 1000000000 \ (= 10 ^ 9) $
* All inputs are integers.
Input example 1
Five
8 6 9 1 20
Output example 1
2
On the 3rd and 5th days, E869120 is happy.
Input example 2
6
3 3 4 3 3 4
Output example 2
2
On the 3rd and 6th days, E869120 is happy.
Input example 3
Ten
10 9 8 7 6 5 4 3 2 1
Output example 3
0
E869120 You will not be happy with "Today's Random Numbers".
Example
Input
5
8 6 9 1 20
Output
2 | instruction | 0 | 97,802 | 20 | 195,604 |
"Correct Solution:
```
N = int(input())
A = list(map(int,input().split()))
ans = 0
for k in range(1,N):
if A[k-1] < A[k]:
ans += 1
print(ans)
``` | output | 1 | 97,802 | 20 | 195,605 |
Provide a correct Python 3 solution for this coding contest problem.
Today's Random Number
E869120 You ran a campaign called "Today's Random Numbers" for N days. This is a project to generate a random number once a day and post the value on Twitter.
The "random numbers of the day" on day $ 1, 2, 3, \ dots, N $ were $ A_1, A_2, A_3, \ dots, A_N $, respectively.
E869120 You would be happy if today's random number is higher than yesterday's random number.
How many times in the $ N $ day did E869120 make you happy with "Today's Random Numbers"?
input
Input is given from standard input in the following format.
$ N $
$ A_1 $ $ A_2 $ $ A_3 $ $ \ dots $ $ A_N $
output
Print out the number of times E869120 was pleased with "Today's Random Numbers" in one line in $ N $ days.
However, insert a line break at the end.
Constraint
* $ 1 \ leq N \ leq 100000 \ (= 10 ^ 5) $
* $ 1 \ leq A_i \ leq 1000000000 \ (= 10 ^ 9) $
* All inputs are integers.
Input example 1
Five
8 6 9 1 20
Output example 1
2
On the 3rd and 5th days, E869120 is happy.
Input example 2
6
3 3 4 3 3 4
Output example 2
2
On the 3rd and 6th days, E869120 is happy.
Input example 3
Ten
10 9 8 7 6 5 4 3 2 1
Output example 3
0
E869120 You will not be happy with "Today's Random Numbers".
Example
Input
5
8 6 9 1 20
Output
2 | instruction | 0 | 97,803 | 20 | 195,606 |
"Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
c=0
for i in range(1,n):
if a[i-1]<a[i]:
c+=1
print(c)
``` | output | 1 | 97,803 | 20 | 195,607 |
Provide a correct Python 3 solution for this coding contest problem.
Today's Random Number
E869120 You ran a campaign called "Today's Random Numbers" for N days. This is a project to generate a random number once a day and post the value on Twitter.
The "random numbers of the day" on day $ 1, 2, 3, \ dots, N $ were $ A_1, A_2, A_3, \ dots, A_N $, respectively.
E869120 You would be happy if today's random number is higher than yesterday's random number.
How many times in the $ N $ day did E869120 make you happy with "Today's Random Numbers"?
input
Input is given from standard input in the following format.
$ N $
$ A_1 $ $ A_2 $ $ A_3 $ $ \ dots $ $ A_N $
output
Print out the number of times E869120 was pleased with "Today's Random Numbers" in one line in $ N $ days.
However, insert a line break at the end.
Constraint
* $ 1 \ leq N \ leq 100000 \ (= 10 ^ 5) $
* $ 1 \ leq A_i \ leq 1000000000 \ (= 10 ^ 9) $
* All inputs are integers.
Input example 1
Five
8 6 9 1 20
Output example 1
2
On the 3rd and 5th days, E869120 is happy.
Input example 2
6
3 3 4 3 3 4
Output example 2
2
On the 3rd and 6th days, E869120 is happy.
Input example 3
Ten
10 9 8 7 6 5 4 3 2 1
Output example 3
0
E869120 You will not be happy with "Today's Random Numbers".
Example
Input
5
8 6 9 1 20
Output
2 | instruction | 0 | 97,804 | 20 | 195,608 |
"Correct Solution:
```
n=int(input())
a=list(map(int, input().split()))
ans=0
for i in range(1, n):
if a[i]>a[i-1]:
ans+=1
print(ans)
``` | output | 1 | 97,804 | 20 | 195,609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros. | instruction | 0 | 97,906 | 20 | 195,812 |
Tags: greedy, implementation, strings
Correct Solution:
```
l, s = int(input()), input()
ans = int(s)
def check(a, b):
a, b = list(a), list(b)
b = b[::-1]
while len(b) and b[-1] == '0':
a.append(b.pop())
if not len(b): return
b = b[::-1]
a = ''.join(a)
b = ''.join(b)
global ans
ans = min(ans, int(a) + int(b))
def check2(a, b):
a, b = list(a), list(b)
b = b[::-1]
while len(a) and a[-1] == '0':
b.append(a.pop())
if len(a) <= 1: return
b.append(a.pop())
b = b[::-1]
a = ''.join(a)
b = ''.join(b)
global ans
ans = min(ans, int(a) + int(b))
check(s[ : l//2], s[l//2 : ])
check2(s[ : l//2], s[l//2 : ])
if l % 2:
check(s[ : l//2 + 1], s[l//2 + 1 : ])
check2(s[ : l//2 + 1], s[l//2 + 1 : ])
print(ans)
``` | output | 1 | 97,906 | 20 | 195,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros. | instruction | 0 | 97,907 | 20 | 195,814 |
Tags: greedy, implementation, strings
Correct Solution:
```
import sys
#(l,n) = list(map(int, input().split()))
l = int(input())
n = int(input())
s = str(n)
length = len(s)
pos1 = max(length // 2 - 1, 1)
pos2 = min(length // 2 + 1, length - 1)
while (pos1 > 1) and s[pos1] == '0':
pos1 -= 1
while (pos2 < length - 1) and s[pos2] == '0':
pos2 += 1
sum = n
for p in range(pos1, pos2 + 1):
#print("p:", p)
if (s[p] != '0'):
#print(int(s[0 : p]))
#print(s[p : length])
sum = min(sum,
int(s[0 : p]) + int(s[p : length]))
print(sum)
sys.exit(0)
``` | output | 1 | 97,907 | 20 | 195,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros. | instruction | 0 | 97,908 | 20 | 195,816 |
Tags: greedy, implementation, strings
Correct Solution:
```
l=int(input())
s=input()
mid=l//2
endfrom0=mid+1
beginforend=mid-1
def so(i):
if(i==0 or i==l):
return int(s)
return int(s[0:i])+int(s[i:l])
while(endfrom0<l and s[endfrom0]=='0'):
endfrom0+=1
while(beginforend>-1 and s[beginforend]=='0'):
beginforend-=1
if(s[mid]!='0'):
print(min(so(mid),so(endfrom0),so(beginforend)))
else:
print(min(so(endfrom0),so(beginforend)))
``` | output | 1 | 97,908 | 20 | 195,817 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros. | instruction | 0 | 97,909 | 20 | 195,818 |
Tags: greedy, implementation, strings
Correct Solution:
```
def IO():
import sys
sys.stdout = open('output.txt', 'w')
sys.stdin = open('input.txt', 'r')
###################### MAIN PROGRAM #####################
def main():
# IO()
l = int(input())
n = str(input())
i = l // 2 - 1
lidx = -1
while (i >= 0):
if (n[i + 1] != '0'):
lidx = i
break
i -= 1
# print(lidx)
ridx = l
i = l // 2 + 1
while (i < l):
if (n[i] != '0'):
ridx = i
break
i += 1
#print(ridx)
option1 = int()
if (lidx != -1):
option1 = int(n[0 : lidx + 1]) + int(n[lidx + 1:])
option2 = int()
if (ridx < l):
option2 = int(n[0 : ridx]) + int(n[ridx:])
# print(option1, option2)
if (l == 2):
print(int(n[0]) + int(n[1]))
elif (lidx == -1):
print(option2)
elif (ridx == l):
print(option1)
else:
print(min(option1, option2))
##################### END OF PROGRAM ####################
if __name__ == "__main__":
main()
``` | output | 1 | 97,909 | 20 | 195,819 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros. | instruction | 0 | 97,910 | 20 | 195,820 |
Tags: greedy, implementation, strings
Correct Solution:
```
def main():
n = int(input())
s = input()
ans = int(s)
half = len(s) // 2
if len(s) % 2 == 0:
for i in range(0, half):
if s[half+i] == '0' and s[half-i] == '0':
continue
else:
# print('try', half+i, half-i)
if s[half+i] != '0':
ans = min(ans, int(s[:half+i]) + int(s[half+i:]))
if s[half-i] != '0':
ans = min(ans, int(s[:half-i]) + int(s[half-i:]))
break
else:
for i in range(0, half):
if s[half+1+i] == '0' and s[half-i] == '0':
continue
else:
if s[half+1+i] != '0':
ans = min(ans, int(s[:half+1+i]) + int(s[half+1+i:]))
if s[half-i] != '0':
ans = min(ans, int(s[:half-i]) + int(s[half-i:]))
break
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 97,910 | 20 | 195,821 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros. | instruction | 0 | 97,911 | 20 | 195,822 |
Tags: greedy, implementation, strings
Correct Solution:
```
n=int(input())
s=input()
minm=int('9'*100010)
for i in range(n//2+1,n):
if(s[i]!='0'):
minm=min(minm,int(s[:i])+int(s[i:]))
break
for i in range(n//2,0,-1):
if(s[i]!='0'):
minm=min(minm,int(s[:i])+int(s[i:]))
break
print(minm)
``` | output | 1 | 97,911 | 20 | 195,823 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros. | instruction | 0 | 97,912 | 20 | 195,824 |
Tags: greedy, implementation, strings
Correct Solution:
```
n = int(input())
s = input()
best = []
b = 10**9
for i in range(n - 1):
if s[i + 1] == '0':
continue
x = max(i + 1, n - i - 1)
if x < b:
best = []
b = x
if x == b:
best.append(i + 1)
res = int(s)
for i in best:
res = min(res, int(s[0 : i]) + int(s[i :]))
print(res)
``` | output | 1 | 97,912 | 20 | 195,825 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros. | instruction | 0 | 97,913 | 20 | 195,826 |
Tags: greedy, implementation, strings
Correct Solution:
```
n = int(input())
s = input()
#s = '1' * n
min_val = n
for i in range(1, n) :
if s[i] == '0' :
continue
min_val = min(min_val, max(i, n-i))
ans = int(s)
for i in range(1, n) :
if s[i] == '0' :
continue
if max(i, n-i) < min_val - 1 or max(i, n-i) > min_val:
continue
candi = int(s[:i]) + int(s[i:])
ans = min(ans, candi)
print(ans)
``` | output | 1 | 97,913 | 20 | 195,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros.
Submitted Solution:
```
n = int(input())
a = input()
s = str(a)
ans = 1e100000
cnt = 0;
for i in range(n//2, -1, -1):
if s[int(i + 1)] == '0':
continue;
ans = min(ans, int(s[0:i + 1]) + int(s[i + 1:n]))
cnt = cnt + 1;
if cnt >= 2: break;
cnt = 0;
for i in range(n//2, n - 1, 1):
if s[int(i + 1)] == '0':
continue;
ans = min(ans, int(s[0:i + 1]) + int(s[i + 1:n]))
cnt = cnt + 1;
if cnt >= 2: break;
print(ans)
``` | instruction | 0 | 97,914 | 20 | 195,828 |
Yes | output | 1 | 97,914 | 20 | 195,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros.
Submitted Solution:
```
n = int(input())
m = input()
ans = 10 ** 110000
ind = n // 2
while(ind >= 0):
if (m[ind] != '0'):
break
ind -= 1
if (ind > 0):
ans = min(ans, int(m[:ind]) + int(m[ind:]))
ind = n // 2 + 1
while(ind < n):
if (m[ind] != '0'):
break
ind += 1
if (ind < n):
ans = min(ans, int(m[:ind]) + int(m[ind:]))
print(ans)
``` | instruction | 0 | 97,915 | 20 | 195,830 |
Yes | output | 1 | 97,915 | 20 | 195,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros.
Submitted Solution:
```
l = int(input())
s = input()
possible = []
for i in range(1,l):
if s[i] is not '0':
possible.append(i)
good = [possible[0]]
digits1 = good[0]
digits2 = l-digits1
maxdigits = max(digits1,digits2)+1
for p in possible:
digits1 = p
digits2 = l-digits1
localmax= max(digits1,digits2)+1
if localmax < maxdigits:
maxdigits = localmax
good = [p]
elif localmax == maxdigits:
good.append(p)
best = 10*int(s)
for g in good:
part1 = int(s[:g])
part2 = int(s[g:])
best = min(best,part1+part2)
print(best)
``` | instruction | 0 | 97,916 | 20 | 195,832 |
Yes | output | 1 | 97,916 | 20 | 195,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros.
Submitted Solution:
```
def gns():
return list(map(int,input().split()))
n=int(input())
s=input()
def sm(x):
# if x==-1 or x==n-1 or n[x+1]=='0':
ans=[]
l=0
i,j=x,n-1
while i>=0 or j>x:
if i>=0:
si=s[i]
else:
si=0
sj=s[j] if j>x else 0
t=int(si)+int(sj)+l
l=t//10
t=t%10
ans.append(t)
i-=1
j-=1
if ans[-1]==0:
ans.pop()
return ans
def cm(x,y):
if len(x)>len(y):
return True
if len(y)>len(x):
return False
i=len(x)-1
while i>=0:
if x[i]>y[i]:
return True
elif x[i]==y[i]:
i-=1
continue
else:
return False
def r(x):
print(''.join(map(str,x[::-1])))
if n%2==0:
m=n//2-1
x,y=m,m
else:
m=n//2
x,y=m-1,m
if True:
while x>=0 and y<n and s[x+1]=='0' and s[y+1]=='0':
x-=1
y+=1
if s[x+1]!='0' and s[y+1]!='0':
smx=sm(x)
smy=sm(y)
if cm(smx,smy):
r(smy)
quit()
else:
r(smx)
quit()
elif s[x+1]!='0':
smx=sm(x)
r(smx)
quit()
elif s[y+1]!='0':
smy = sm(y)
r(smy)
quit()
``` | instruction | 0 | 97,917 | 20 | 195,834 |
Yes | output | 1 | 97,917 | 20 | 195,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros.
Submitted Solution:
```
def B(n, l):
s = int(l)
pos = n // 2;
i = pos
m = 1
cnt = 0
while i < n and i > 0 and cnt < 3:
if l[i] != '0':
s = min(int(l[:i]) + int(l[i:]), s)
cnt += 1
i += m
m += 1
m *= -1
return s
n, l = int(input()), input()
print(B(n, l))
``` | instruction | 0 | 97,918 | 20 | 195,836 |
No | output | 1 | 97,918 | 20 | 195,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros.
Submitted Solution:
```
l = int(input())
s = str(input())
t = -(-l//2)
print(int(s[:t]) + int((s[t:])))
``` | instruction | 0 | 97,919 | 20 | 195,838 |
No | output | 1 | 97,919 | 20 | 195,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros.
Submitted Solution:
```
def findNotZero(s,half):
min = 10000000
pos = 0
for i in s:
if int(i) != 0 :
if abs(pos-half) < abs(min-half) :
min = pos
elif abs(pos-half) == abs(min-half) :
first = ''
second = ''
for i in s[min:] :
first += str(i)
for i in s[:pos] :
second += str(i)
# print(half,min,pos,first,second)
if first == '' :
min = pos
elif int(first) > int(second) :
min = pos
pos += 1
return min
def findResult(first,second):
# print(first,second)
pos = 0
first = first[::-1]
second = second[::-1]
res = ''
r = 0
for i in range(len(first)):
if(i < len(second)) :
plus = (first[i] + second[i])+r
else :
plus = first[i]+r
res += str(plus%10)
r = plus//10
pos += 1
if r != 0 :
res += str(r)
print(res[::-1])
l = int(input())
s = [int(i) for i in input()]
# print(s)
half = len(s)//2
if s[half] == 0 :
half = findNotZero(s,half)
# print(half)
first = s[:half]
second = s[half:]
elif l%2 == 1 and s[half] > s[0]:
first = s[:half+1]
second = s[half+1:]
else :
first = s[:half]
second = s[half:]
if len(first) >= len(second) :
findResult(first,second)
else :
findResult(second,first)
# print(result)
# print(first,second)
``` | instruction | 0 | 97,920 | 20 | 195,840 |
No | output | 1 | 97,920 | 20 | 195,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima worked all day and wrote down on a long paper strip his favorite number n consisting of l digits. Unfortunately, the strip turned out to be so long that it didn't fit in the Dima's bookshelf.
To solve the issue, Dima decided to split the strip into two non-empty parts so that each of them contains a positive integer without leading zeros. After that he will compute the sum of the two integers and write it down on a new strip.
Dima wants the resulting integer to be as small as possible, because it increases the chances that the sum will fit it in the bookshelf. Help Dima decide what is the minimum sum he can obtain.
Input
The first line contains a single integer l (2 โค l โค 100 000) โ the length of the Dima's favorite number.
The second line contains the positive integer n initially written on the strip: the Dima's favorite number.
The integer n consists of exactly l digits and it does not contain leading zeros. Dima guarantees, that there is at least one valid way to split the strip.
Output
Print a single integer โ the smallest number Dima can obtain.
Examples
Input
7
1234567
Output
1801
Input
3
101
Output
11
Note
In the first example Dima can split the number 1234567 into integers 1234 and 567. Their sum is 1801.
In the second example Dima can split the number 101 into integers 10 and 1. Their sum is 11. Note that it is impossible to split the strip into "1" and "01" since the numbers can't start with zeros.
Submitted Solution:
```
l=int(input("dina number size"))
n=str(input("dina number"))
word=""
c=1
min_num= int(n)
for i in n:
word=word+i
part_1=int(word)
part_2=(int(n)-((int(word))*(10**(l-c))))
if part_2<10**(l-c-1):
c=c+1
continue
temp_num=part_1+part_2
if min_num>temp_num:
min_num=temp_num
c=c+1
print(min_num)
``` | instruction | 0 | 97,921 | 20 | 195,842 |
No | output | 1 | 97,921 | 20 | 195,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between the easy and the hard versions is the maximum value of k.
You are given an infinite sequence of form "112123123412345..." which consist of blocks of all consecutive positive integers written one after another. The first block consists of all numbers from 1 to 1, the second one โ from 1 to 2, the third one โ from 1 to 3, ..., the i-th block consists of all numbers from 1 to i.
So the first 56 elements of the sequence are "11212312341234512345612345671234567812345678912345678910". Elements of the sequence are numbered from one. For example, the 1-st element of the sequence is 1, the 3-rd element of the sequence is 2, the 20-th element of the sequence is 5, the 38-th element is 2, the 56-th element of the sequence is 0.
Your task is to answer q independent queries. In the i-th query you are given one integer k_i. Calculate the digit at the position k_i of the sequence.
Input
The first line of the input contains one integer q (1 โค q โค 500) โ the number of queries.
The i-th of the following q lines contains one integer k_i (1 โค k_i โค 10^{18}) โ the description of the corresponding query.
Output
Print q lines. In the i-th line print one digit x_i (0 โค x_i โค 9) โ the answer to the query i, i.e. x_i should be equal to the element at the position k_i of the sequence.
Examples
Input
5
1
3
20
38
56
Output
1
2
5
2
0
Input
4
2132
506
999999999999999999
1000000000000000000
Output
8
2
4
1
Note
Answers on queries from the first example are described in the problem statement. | instruction | 0 | 97,939 | 20 | 195,878 |
Tags: binary search, math
Correct Solution:
```
def s(i):
n = 1
result = i
while i >= n*9:
i -= 9*n
result += i
n *= 10
return result
def n(i):
result = 0
while True:
i //= 10
result += 1
if i == 0: break
return result
def get_char_from_block(i, k):
k = k if k != 0 else s(i)
c = 1
m = 1
if k < 10:
return k
while k > 9*m*c:
k -= 9*m*c
m *= 10
c += 1
ost = (k + c - 1) % c
num = ((k + c - 1) // c) + m - 1
while ost < c - 1:
num //= 10
ost += 1
return num % 10
def main():
q = int(input())
for i in range(q):
k = int(input())
l, r = int(1), int(10**9)
res = 0
"""h = 1
block_i = 0
p = 0
m = 0
while p < k:
m += 1
i = m
p = 0
c = 10**(n(i) - 1)
while c != 0:
p += (s(c) + s(i)) * (i - c + 1) // 2
i = c - 1
c //= 10
if k == 1:
print(1)
continue
p -= s(m)
res = get_char_from_block(m , k - p)
print(res)"""
h = 1
while l + 1 < r:
m = (l + r) // 2
i = m
c = 10**(n(i) - 1)
p = 0
while c != 0:
p += (s(c) + s(i)) * (i - c + 1) // 2
i = c - 1
c //= 10
if p > k:
r = m
else:
h = p
l = m
if k == h:
res = get_char_from_block(l, k - h)
else:
res = get_char_from_block(l + 1, k - h)
print(res)
if __name__ == "__main__":
main()
``` | output | 1 | 97,939 | 20 | 195,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between the easy and the hard versions is the maximum value of k.
You are given an infinite sequence of form "112123123412345..." which consist of blocks of all consecutive positive integers written one after another. The first block consists of all numbers from 1 to 1, the second one โ from 1 to 2, the third one โ from 1 to 3, ..., the i-th block consists of all numbers from 1 to i.
So the first 56 elements of the sequence are "11212312341234512345612345671234567812345678912345678910". Elements of the sequence are numbered from one. For example, the 1-st element of the sequence is 1, the 3-rd element of the sequence is 2, the 20-th element of the sequence is 5, the 38-th element is 2, the 56-th element of the sequence is 0.
Your task is to answer q independent queries. In the i-th query you are given one integer k_i. Calculate the digit at the position k_i of the sequence.
Input
The first line of the input contains one integer q (1 โค q โค 500) โ the number of queries.
The i-th of the following q lines contains one integer k_i (1 โค k_i โค 10^{18}) โ the description of the corresponding query.
Output
Print q lines. In the i-th line print one digit x_i (0 โค x_i โค 9) โ the answer to the query i, i.e. x_i should be equal to the element at the position k_i of the sequence.
Examples
Input
5
1
3
20
38
56
Output
1
2
5
2
0
Input
4
2132
506
999999999999999999
1000000000000000000
Output
8
2
4
1
Note
Answers on queries from the first example are described in the problem statement. | instruction | 0 | 97,945 | 20 | 195,890 |
Tags: binary search, math
Correct Solution:
```
from functools import *
def sumnum(start, end):
# ex end
# inc start
return end*(end-1)//2 -start*(start-1)//2
def digits(i):
return len(f"{i}")
@lru_cache(maxsize=32)
def digit_count(i):
if i==0:
return 0
d = digits(i)
base = 10**(d-1)-1
return digit_count(base) + d*(i-base)
@lru_cache(maxsize=32)
def cumulative_digit_count(i):
if i==0:
return 0
d = digits(i);
base = 10**(d-1)-1
return cumulative_digit_count(base) + digit_count(base)*(i-base) + d*sumnum(base+1, i+1) - d*(base)*(i-base)
def bin_search(k, f):
for d in range(1,20):
if f(10**(d-1)-1) > k:
break
upper = 10**(d-1)-1
lower = 10**(d-2)-1
while upper-lower > 1:
middle = (lower+upper)//2;
if f(middle) > k:
upper = middle
else:
lower = middle
return lower, k-f(lower)
def answer(q):
lower1, k = bin_search(q, cumulative_digit_count)
if k==0:
return lower1 % 10
lower2, l = bin_search(k, digit_count)
if l==0:
return lower2 % 10
return int(f"{lower2 + 1}"[l-1])
def naive_cum(i):
cum = 0
for ii in range(1, i+1):
for j in range(1, ii+1):
cum = cum + len(f"{j}")
return cum
# print("cum", cum)
a = input()
for i in range(int(a)):
q=input()
print(answer(int(q)))
``` | output | 1 | 97,945 | 20 | 195,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1. | instruction | 0 | 98,034 | 20 | 196,068 |
Tags: dfs and similar, dp, graphs, math
Correct Solution:
```
import sys
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input().strip()
return(list(s[:len(s)]))
def invr():
return(map(int,input().split()))
def from_file(f):
return f.readline
def build_graph(n, A, reversed=False):
edges = [[] for _ in range(n)]
for i, j in A:
i -= 1
j -= 1
if reversed:
j, i = i, j
edges[i].append(j)
return edges
def fill_min(s, edges, visited_dfs, visited, container):
visited[s] = True
visited_dfs.add(s)
for c in edges[s]:
if c in visited_dfs:
# cycle
return -1
if not visited[c]:
res = fill_min(c, edges, visited_dfs, visited, container)
if res == -1:
return -1
container[s] = min(container[s], container[c])
visited_dfs.remove(s)
return 0
def dfs(s, edges, visited, container):
stack = [s]
colors = {s: 0}
while stack:
v = stack.pop()
if colors[v] == 0:
colors[v] = 1
stack.append(v)
else:
# all children are visited
tmp = [container[c] for c in edges[v]]
if tmp:
container[v] = min(min(tmp), container[v])
colors[v] = 2 # finished
visited[v] = True
for c in edges[v]:
if visited[c]:
continue
if c not in colors:
colors[c] = 0 # white
stack.append(c)
elif colors[c] == 1:
# grey
return -1
return 0
def iterate_topologically(n, edges, container):
visited = [False] * n
for s in range(n):
if not visited[s]:
# visited_dfs = set()
# res = fill_min(s, edges, visited_dfs, visited, container)
res = dfs(s, edges, visited, container)
if res == -1:
return -1
return 0
def solve(n, A):
edges = build_graph(n, A, False)
container_forward = list(range(n))
container_backward = list(range(n))
res = iterate_topologically(n, edges, container_forward)
if res == -1:
return None
edges = build_graph(n, A, True)
iterate_topologically(n, edges, container_backward)
container = [min(i,j) for i,j in zip(container_forward, container_backward)]
res = sum((1 if container[i] == i else 0 for i in range(n)))
s = "".join(["A" if container[i] == i else "E" for i in range(n)])
return res, s
# with open('5.txt') as f:
# input = from_file(f)
n, m = invr()
A = []
for _ in range(m):
i, j = invr()
A.append((i, j))
result = solve(n, A)
if not result:
print (-1)
else:
print(f"{result[0]}")
print(f"{result[1]}")
``` | output | 1 | 98,034 | 20 | 196,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1. | instruction | 0 | 98,035 | 20 | 196,070 |
Tags: dfs and similar, dp, graphs, math
Correct Solution:
```
import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
f = iter(open('E.in').readlines())
def input():
return next(f)
else:
input = sys.stdin.readline
n, m = map(int, input().split())
g = {i : [] for i in range(1, n+1)}
r = {i : [] for i in range(1, n+1)}
for _ in range(m):
u, v = map(int, input().split())
g[u].append(v)
r[v].append(u)
mincomp = list(range(n+1))
try:
for gr in [g, r]:
color = [0] * (n+1)
for i in range(1, n+1):
if color[i] == 0:
s = [i]
while s:
u = s[-1]
if color[u] == 0:
color[u] = 1
for v in gr[u]:
if color[v] == 0:
s.append(v)
mincomp[v] = min(mincomp[u], mincomp[v])
elif color[v] == 1:
raise RuntimeError
if s[-1] == u:
color[u] = 2
s.pop()
elif color[u] == 1:
color[u] = 2
u = s.pop()
elif color[u] == 2:
s.pop()
print(sum([u <= mincomp[u] for u in range(1, n+1)]))
print(''.join(['A' if u <= mincomp[u] else 'E' for u in range(1, n+1)]))
except RuntimeError:
print(-1)
``` | output | 1 | 98,035 | 20 | 196,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1. | instruction | 0 | 98,036 | 20 | 196,072 |
Tags: dfs and similar, dp, graphs, math
Correct Solution:
```
import sys
def input(): return sys.stdin.readline().rstrip()
from collections import deque
def find_loop(n, e, flag):
x = [0]*n
d = deque()
t = []
c = 0
for i in range(n):
for j in e[i]:
x[j] += 1
for i in range(n):
if x[i] == 0:
d.append(i)
t.append(i)
c += 1
while d:
i = d.popleft()
for j in e[i]:
x[j] -= 1
if x[j] == 0:
d.append(j)
t.append(j)
c += 1
if c!=n:
print(-1)
exit()
return t
n,m=map(int,input().split())
edge=[[]for _ in range(n)]
redge=[[]for _ in range(n)]
into=[0]*n
for _ in range(m):
a,b=map(int,input().split())
a-=1
b-=1
into[b]+=1
edge[a].append(b)
redge[b].append(a)
dag=find_loop(n,edge,0)
mi=list(range(n))
for node in dag[::-1]:
for mode in redge[node]:
mi[mode]=min(mi[node],mi[mode])
ans=["E"]*n
visited=[0]*n
for i in range(n):
if visited[i]==0:
stack=[i]
ans[i]="A"
visited[i]=1
for node in stack:
for mode in edge[node]:
if visited[mode]:continue
visited[mode]=1
stack.append(mode)
for i in range(n):
if i>mi[i]:ans[i]="E"
print(ans.count("A"))
print("".join(ans))
``` | output | 1 | 98,036 | 20 | 196,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1. | instruction | 0 | 98,037 | 20 | 196,074 |
Tags: dfs and similar, dp, graphs, math
Correct Solution:
```
import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
f = iter(open('E.in').readlines())
def input():
return next(f)
else:
input = sys.stdin.readline
n, m = map(int, input().split())
g = {i : [] for i in range(1, n+1)}
r = {i : [] for i in range(1, n+1)}
for _ in range(m):
u, v = map(int, input().split())
g[u].append(v)
r[v].append(u)
mincomp = list(range(n+1))
# res = [0 for _ in range(n+1)]
# from collections import deque
try:
for gr in [g, r]:
color = [0] * (n+1)
for i in range(1, n+1):
if color[i] == 0:
s = [i]
while s:
u = s[-1]
if color[u] == 0:
color[u] = 1
for v in gr[u]:
if color[v] == 0:
s.append(v)
mincomp[v] = min(mincomp[u], mincomp[v])
elif color[v] == 1:
raise RuntimeError
# if s[-1] == u:
# color[u] = 2
# s.pop()
elif color[u] == 1:
color[u] = 2
u = s.pop()
elif color[u] == 2:
s.pop()
print(sum([u <= mincomp[u] for u in range(1, n+1)]))
print(''.join(['A' if u <= mincomp[u] else 'E' for u in range(1, n+1)]))
except RuntimeError:
print(-1)
``` | output | 1 | 98,037 | 20 | 196,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1. | instruction | 0 | 98,038 | 20 | 196,076 |
Tags: dfs and similar, dp, graphs, math
Correct Solution:
```
import sys
from collections import deque
input=sys.stdin.readline
n,m=map(int,input().split())
edge=[[] for i in range(n)]
revedge=[[] for i in range(n)]
for i in range(m):
j,k=map(int,input().split())
edge[j-1].append(k-1)
revedge[k-1].append(j-1)
deg=[len(revedge[i]) for i in range(n)]
ans = list(v for v in range(n) if deg[v]==0)
deq = deque(ans)
used = [0]*n
while deq:
v = deq.popleft()
for t in edge[v]:
deg[t] -= 1
if deg[t]==0:
deq.append(t)
ans.append(t)
if len(ans)!=n:
print(-1)
exit()
res=0
potential=[0]*n
revpotential=[0]*n
ans=[""]*n
def bfs(v):
que=deque([v])
potential[v]=1
while que:
pos=que.popleft()
for nv in edge[pos]:
if not potential[nv]:
potential[nv]=1
que.append(nv)
def revbfs(v):
que=deque([v])
revpotential[v]=1
while que:
pos=que.popleft()
for nv in revedge[pos]:
if not revpotential[nv]:
revpotential[nv]=1
que.append(nv)
for i in range(n):
if not potential[i] and not revpotential[i]:
ans[i]="A"
res+=1
bfs(i)
revbfs(i)
else:
ans[i]="E"
bfs(i)
revbfs(i)
print(res)
print("".join(ans))
``` | output | 1 | 98,038 | 20 | 196,077 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1. | instruction | 0 | 98,039 | 20 | 196,078 |
Tags: dfs and similar, dp, graphs, math
Correct Solution:
```
import collections
import sys
input=sys.stdin.readline
n,m=map(int,input().split())
ans=['']*(n+1)
g1=[[] for _ in range(n+1)]
g2=[[] for _ in range(n+1)]
deg=[0]*(n+1)
for _ in range(m):
a,b=map(int,input().split())
g1[a].append(b)
g2[b].append(a)
deg[a]+=1
status=[0]*(n+1)
q=collections.deque()
for i in range(1,n+1):
if deg[i]==0:
q.append(i)
while len(q)!=0:
v=q.pop()
status[v]=1
for u in g2[v]:
deg[u]-=1
if deg[u]==0:
q.append(u)
if status.count(0)>=2:
print(-1)
else:
status1=[0]*(n+1)
status2=[0]*(n+1)
for i in range(1,n+1):
if status1[i]==0 and status2[i]==0:
ans[i]='A'
else:
ans[i]='E'
if status1[i]==0:
q=collections.deque()
q.append(i)
while len(q)!=0:
v=q.pop()
status1[v]=1
for u in g1[v]:
if status1[u]==0:
status1[u]=1
q.append(u)
if status2[i]==0:
q=collections.deque()
q.append(i)
while len(q)!=0:
v=q.pop()
status2[v]=1
for u in g2[v]:
if status2[u]==0:
status2[u]=1
q.append(u)
print(ans.count('A'))
print(''.join(map(str,ans[1:])))
``` | output | 1 | 98,039 | 20 | 196,079 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1. | instruction | 0 | 98,040 | 20 | 196,080 |
Tags: dfs and similar, dp, graphs, math
Correct Solution:
```
import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
f = iter(open('E.in').readlines())
def input():
return next(f)
else:
input = sys.stdin.readline
n, m = map(int, input().split())
g = {i : [] for i in range(1, n+1)}
r = {i : [] for i in range(1, n+1)}
for _ in range(m):
u, v = map(int, input().split())
g[u].append(v)
r[v].append(u)
mincomp = list(range(n+1))
try:
for gr in [g, r]:
color = [0] * (n+1)
for i in range(1, n+1):
if color[i] == 0:
s = [i]
while s:
u = s.pop()
if color[u] == 0:
s.append(u)
color[u] = 1
for v in gr[u]:
if color[v] == 0:
s.append(v)
mincomp[v] = min(mincomp[u], mincomp[v])
elif color[v] == 1:
raise RuntimeError
elif color[u] == 1:
color[u] = 2
# print(sum([u <= mincomp[u] for u in range(1, n+1)]))
s = ''.join(['A' if u <= mincomp[u] else 'E' for u in range(1, n+1)])
print(s.count('A'))
print(s)
except RuntimeError:
print(-1)
``` | output | 1 | 98,040 | 20 | 196,081 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1. | instruction | 0 | 98,041 | 20 | 196,082 |
Tags: dfs and similar, dp, graphs, math
Correct Solution:
```
import sys
n, m = [int(x) for x in input().split()]
adj_for = [[] for _ in range(n)]
adj_back = [[] for _ in range(n)]
for _ in range(m):
a, b = [int(x) for x in sys.stdin.readline().split()]
a -= 1
b -= 1
adj_for[a].append(b)
adj_back[b].append(a)
lens = [len(adj_back[i]) for i in range(n)]
stack = [x for x in range(n) if lens[x] == 0]
toposort = [x for x in range(n) if lens[x] == 0]
while len(stack):
cur = stack.pop()
for nb in adj_for[cur]:
lens[nb] -= 1
if lens[nb] == 0:
toposort.append(nb)
stack.append(nb)
if len(toposort) != n:
print(-1)
sys.exit(0)
min_above = list(range(n))
min_below = list(range(n))
for i in toposort:
for j in adj_back[i]:
if min_above[j] < min_above[i]:
min_above[i] = min_above[j]
for i in reversed(toposort):
for j in adj_for[i]:
if min_below[j] < min_below[i]:
min_below[i] = min_below[j]
qt = ["A" if min_below[i] == min_above[i] == i else "E" for i in range(n)]
# qt = [None for x in range(n)]
#
# for i in range(n):
# if qt[i] is not None:
# continue
# qt[i] = 'A'
# stack_for = [i]
# while len(stack_for):
# cur = stack_for.pop()
# for nb in adj_for[cur]:
# if qt[nb] is None:
# qt[nb] = 'E'
# stack_for.append(nb)
#
#
# stack_back = [i]
# while len(stack_back):
# cur = stack_back.pop()
# for nb in adj_back[cur]:
# if qt[nb] is None:
# qt[nb] = 'E'
# stack_back.append(nb)
#
print(len([x for x in qt if x == 'A']))
print("".join(qt))
``` | output | 1 | 98,041 | 20 | 196,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1.
Submitted Solution:
```
import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
f = iter(open('E.in').readlines())
def input():
return next(f)
else:
input = sys.stdin.readline
n, m = map(int, input().split())
g = {i : [] for i in range(1, n+1)}
r = {i : [] for i in range(1, n+1)}
for _ in range(m):
u, v = map(int, input().split())
g[u].append(v)
r[v].append(u)
mincomp = list(range(n+1))
try:
for gr in [g, r]:
color = [0] * (n+1)
for i in range(1, n+1):
if color[i] == 0:
s = [i]
while s:
u = s[-1]
if color[u] == 0:
color[u] = 1
for v in gr[u]:
if color[v] == 0:
s.append(v)
mincomp[v] = min(mincomp[u], mincomp[v])
elif color[v] == 1:
raise RuntimeError
# if s[-1] == u:
# color[u] = 2
# s.pop()
elif color[u] == 1:
color[u] = 2
u = s.pop()
elif color[u] == 2:
s.pop()
print(sum([u <= mincomp[u] for u in range(1, n+1)]))
print(''.join(['A' if u <= mincomp[u] else 'E' for u in range(1, n+1)]))
except RuntimeError:
print(-1)
``` | instruction | 0 | 98,042 | 20 | 196,084 |
Yes | output | 1 | 98,042 | 20 | 196,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1.
Submitted Solution:
```
import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
f = iter(open('E.in').readlines())
def input():
return next(f)
else:
input = sys.stdin.readline
n, m = map(int, input().split())
g = {i : [] for i in range(1, n+1)}
r = {i : [] for i in range(1, n+1)}
for _ in range(m):
u, v = map(int, input().split())
g[u].append(v)
r[v].append(u)
mincomp = list(range(n+1))
try:
for gr in [g, r]:
color = [0] * (n+1)
for i in range(1, n+1):
if color[i] == 0:
s = [i]
while s:
u = s.pop()
if color[u] == 0:
s.append(u)
color[u] = 1
for v in gr[u]:
if color[v] == 0:
s.append(v)
mincomp[v] = min(mincomp[u], mincomp[v])
elif color[v] == 1:
raise RuntimeError
elif color[u] == 1:
color[u] = 2
print(sum([u <= mincomp[u] for u in range(1, n+1)]))
print(''.join(['A' if u <= mincomp[u] else 'E' for u in range(1, n+1)]))
except RuntimeError:
print(-1)
``` | instruction | 0 | 98,043 | 20 | 196,086 |
Yes | output | 1 | 98,043 | 20 | 196,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1.
Submitted Solution:
```
import sys
n, m, *jk = map(int, sys.stdin.buffer.read().split())
links = [set() for _ in range(n)]
rev_links = [set() for _ in range(n)]
degrees_in = [0] * n
for j, k in zip(jk[0::2], jk[1::2]):
j -= 1
k -= 1
if k not in links[j]:
degrees_in[k] += 1
links[j].add(k)
rev_links[k].add(j)
s = {i for i, c in enumerate(degrees_in) if c == 0}
length = 0
while s:
length += 1
v = s.pop()
for u in links[v]:
degrees_in[u] -= 1
if degrees_in[u] == 0:
s.add(u)
if length < n:
print(-1)
exit()
ans = ['E'] * n
larger_fixed = [False] * n
smaller_fixed = [False] * n
universal_cnt = 0
for i in range(n):
if not larger_fixed[i] and not smaller_fixed[i]:
ans[i] = 'A'
universal_cnt += 1
q = [i]
while q:
v = q.pop()
if larger_fixed[v]:
continue
larger_fixed[v] = True
q.extend(u for u in links[v] if not larger_fixed[u])
q = [i]
while q:
v = q.pop()
if smaller_fixed[v]:
continue
smaller_fixed[v] = True
q.extend(u for u in rev_links[v] if not smaller_fixed[u])
print(universal_cnt)
print(''.join(ans))
``` | instruction | 0 | 98,044 | 20 | 196,088 |
Yes | output | 1 | 98,044 | 20 | 196,089 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1.
Submitted Solution:
```
import sys;input=sys.stdin.readline
N, M = map(int, input().split())
G1 = [[] for _ in range(N+1)]
G2 = [[] for _ in range(N+1)]
for _ in range(M):
x, y = map(int, input().split())
G1[x].append(y)
G2[y].append(x)
lens = [len(G2[i]) for i in range(N+1)]
stack = [x for x in range(N+1) if lens[x] == 0 and x != 0]
topo = [x for x in range(N+1) if lens[x] == 0 and x != 0]
#print(topo)
while stack:
cur = stack.pop()
for nb in G1[cur]:
lens[nb] -= 1
if lens[nb] == 0:
topo.append(nb)
stack.append(nb)
#print(topo)
if len(topo) != N:
print(-1)
sys.exit(0)
R = [0] * (N+1)
v1 = set()
v2 = set()
c = 0
for s in range(1, N+1):
if s in v1 or s in v2:
R[s] = 'E'
else:
R[s] = 'A'
c += 1
stack = [s]
while stack:
v = stack.pop()
for u in G1[v]:
if u in v1:
continue
v1.add(u)
stack.append(u)
stack = [s]
while stack:
v = stack.pop()
for u in G2[v]:
if u in v2:
continue
v2.add(u)
stack.append(u)
print(c)
print("".join(R[1:]))
``` | instruction | 0 | 98,045 | 20 | 196,090 |
Yes | output | 1 | 98,045 | 20 | 196,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1.
Submitted Solution:
```
n, m = map(int, input().split())
adj = [[] for _ in range(n)]
in_deg = [0] * n
for _ in range(m):
u, v = map(int, input().split())
u -= 1
v -= 1
adj[u].append(v)
in_deg[v] += 1
q = [i for i, deg in enumerate(in_deg) if deg == 0]
while q:
top = q.pop()
for nei in adj[top]:
in_deg[nei] -= 1
if in_deg[nei] == 0:
q.append(nei)
if any(in_deg):
print(-1)
exit()
is_all = [1] * n
for u in range(n):
for v in adj[u]:
is_all[max(u, v)] = 0
print(sum(is_all))
print("".join("EA"[ia] for ia in is_all))
``` | instruction | 0 | 98,046 | 20 | 196,092 |
No | output | 1 | 98,046 | 20 | 196,093 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1.
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
buff_readline = sys.stdin.buffer.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, S):
ls = set()
rs = set()
for l, r in S:
ls.add(l)
rs.add(r)
if ls & rs:
return -1
ans = []
for i in range(1, N+1):
if i in rs:
ans.append('E')
else:
ans.append('A')
return str(ans.count('A')) + '\n' + ''.join(ans)
def main():
N, M = read_int_n()
S = [read_int_n() for _ in range(M)]
print(slv(N, M, S))
if __name__ == '__main__':
main()
``` | instruction | 0 | 98,047 | 20 | 196,094 |
No | output | 1 | 98,047 | 20 | 196,095 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1.
Submitted Solution:
```
from bisect import *
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().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
#------------------------------------------------------------------------
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
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 lowbit(n):
return n&-n
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
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 SMT:
def __init__(self,arr):
self.n=len(arr)-1
self.arr=[0]*(self.n<<2)
self.lazy=[0]*(self.n<<2)
def Build(l,r,rt):
if l==r:
self.arr[rt]=arr[l]
return
m=(l+r)>>1
Build(l,m,rt<<1)
Build(m+1,r,rt<<1|1)
self.pushup(rt)
Build(1,self.n,1)
def pushup(self,rt):
self.arr[rt]=self.arr[rt<<1]+self.arr[rt<<1|1]
def pushdown(self,rt,ln,rn):#lr,rn่กจๅบ้ดๆฐๅญๆฐ
if self.lazy[rt]:
self.lazy[rt<<1]+=self.lazy[rt]
self.lazy[rt<<1|1]+=self.lazy[rt]
self.arr[rt<<1]+=self.lazy[rt]*ln
self.arr[rt<<1|1]+=self.lazy[rt]*rn
self.lazy[rt]=0
def update(self,L,R,c,l=1,r=None,rt=1):#L,R่กจ็คบๆไฝๅบ้ด
if r==None: r=self.n
if L<=l and r<=R:
self.arr[rt]+=c*(r-l+1)
self.lazy[rt]+=c
return
m=(l+r)>>1
self.pushdown(rt,m-l+1,r-m)
if L<=m: self.update(L,R,c,l,m,rt<<1)
if R>m: self.update(L,R,c,m+1,r,rt<<1|1)
self.pushup(rt)
def query(self,L,R,l=1,r=None,rt=1):
if r==None: r=self.n
#print(L,R,l,r,rt)
if L<=l and R>=r:
return self.arr[rt]
m=(l+r)>>1
self.pushdown(rt,m-l+1,r-m)
ans=0
if L<=m: ans+=self.query(L,R,l,m,rt<<1)
if R>m: ans+=self.query(L,R,m+1,r,rt<<1|1)
return ans
'''
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 prime
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 GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
def nb(i,j):
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
@bootstrap
def gdfs(r,p):
if len(g[r])==1 and p!=-1:
yield None
for ch in g[r]:
if ch!=p:
yield gdfs(ch,r)
yield None
def lcm(a,b):
return a*b//gcd(a,b)
@bootstrap
def down(r):
for ch in g[r]:
if can[ch]:
can[ch]=0
yield down(ch)
yield None
@bootstrap
def up(r):
for ch in par[r]:
if can[ch]:
can[ch]=0
yield up(ch)
yield None
t=1
for i in range(t):
n,m=RL()
g=[[] for i in range(n+1)]
par=[[] for i in range(n+1)]
ind=[0]*(n+1)
for i in range(m):
u,v=RL()
g[u].append(v)
ind[v]+=1
par[v].append(u)
q=deque()
vis=set()
for i in range(1,n+1):
if ind[i]==0:
q.append(i)
vis.add(i)
while q:
u=q.popleft()
for v in g[u]:
ind[v]-=1
if ind[v]==0:
q.append(v)
vis.add(v)
if not len(vis)==n:
print(-1)
exit()
ans=[]
c=0
can=[1]*(n+1)
for i in range(1,n+1):
if can[i]:
ans.append('A')
c+=1
can[i]=0
up(i)
down(i)
else:
ans.append('E')
print(c)
ans=''.join(ans)
print(ans)
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thread(target=main)
t.start()
t.join()
'''
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thread(target=main)
t.start()
t.join()
'''
``` | instruction | 0 | 98,048 | 20 | 196,096 |
No | output | 1 | 98,048 | 20 | 196,097 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (โ) and existential (โ). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* โ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* โ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* โ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* โ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* โ x,โ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* โ y,โ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,โฆ,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})โง (x_{j_2}<x_{k_2})โง โ
โ
โ
โง (x_{j_m}<x_{k_m}), $$$
where โง denotes logical AND. That is, f(x_1,โฆ, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,โฆ,x_n) is false.
Your task is to assign quantifiers Q_1,โฆ,Q_n to either universal (โ) or existential (โ) so that the statement $$$ Q_1 x_1, Q_2 x_2, โฆ, Q_n x_n, f(x_1,โฆ, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement โ x_2,โ x_1, x_1<x_2. If you assign Q_1=โ and Q_2=โ, it will only be interpreted as โ x_1,โ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2โค nโค 2โ
10^5; 1โค mโค 2โ
10^5) โ the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1โค j_i,k_iโค n, j_iโ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (โ), or "E" if Q_i should be an existential quantifier (โ). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement โ x_1, โ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement โ x_1, โ x_2, โ x_3, (x_1<x_3)โง (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1.
Submitted Solution:
```
import sys;input=sys.stdin.readline
N, M = map(int, input().split())
G1 = [[] for _ in range(N+1)]
G2 = [[] for _ in range(N+1)]
for _ in range(M):
x, y = map(int, input().split())
G1[x].append(y)
G2[y].append(x)
vs = set()
for s in range(1, N+1):
stack = [s]
if s in vs:
print(-1)
sys.exit()
vs.add(s)
ps = set([s])
while stack:
v = stack.pop()
for u in G1[v]:
if u in ps:
print(-1)
sys.exit()
if u in vs:
continue
ps.add(u)
vs.add(u)
stack.append(u)
R = [0] * (N+1)
v1 = set()
v2 = set()
c = 0
for s in range(1, N+1):
if s in v1 or s in v2:
R[s] = 'E'
else:
R[s] = 'A'
c += 1
stack = [s]
while stack:
v = stack.pop()
for u in G1[v]:
if u in v1:
continue
v1.add(u)
stack.append(u)
stack = [s]
while stack:
v = stack.pop()
for u in G2[v]:
if u in v2:
continue
v2.add(u)
stack.append(u)
print(c)
print("".join(R[1:]))
``` | instruction | 0 | 98,049 | 20 | 196,098 |
No | output | 1 | 98,049 | 20 | 196,099 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Amr doesn't like Maths as he finds it really boring, so he usually sleeps in Maths lectures. But one day the teacher suspected that Amr is sleeping and asked him a question to make sure he wasn't.
First he gave Amr two positive integers n and k. Then he asked Amr, how many integer numbers x > 0 exist such that:
* Decimal representation of x (without leading zeroes) consists of exactly n digits;
* There exists some integer y > 0 such that:
* <image>;
* decimal representation of y is a suffix of decimal representation of x.
As the answer to this question may be pretty huge the teacher asked Amr to output only its remainder modulo a number m.
Can you help Amr escape this embarrassing situation?
Input
Input consists of three integers n, k, m (1 โค n โค 1000, 1 โค k โค 100, 1 โค m โค 109).
Output
Print the required number modulo m.
Examples
Input
1 2 1000
Output
4
Input
2 2 1000
Output
45
Input
5 3 1103
Output
590
Note
A suffix of a string S is a non-empty string that can be obtained by removing some number (possibly, zero) of first characters from S. | instruction | 0 | 98,239 | 20 | 196,478 |
Tags: dp, implementation
Correct Solution:
```
def get_input():
hahaha=input()
(n,k,m)=hahaha.split(sep=None, maxsplit=1000)
return (int(n),int(k),int(m))
(n,k,m)=get_input()
f=[0 for i in range(k)]
s=0
for v in range(n):
tens = 10**v%k
f=[ (sum( [f[(j+k-(x+1)*tens)%k] for x in range(9)] )+f[j])%m for j in range(k)]
for x in range(9):
f[(x+1)*tens%k]+=1
if n-v-1==0:
s+=(f[0]%m)
else:
s+=f[0]*((10**(n-v-2)*9))%m
f[0]=0
print(s%m)
``` | output | 1 | 98,239 | 20 | 196,479 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.