id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_1001
|
s = input()
a, b = map(int, input().split())
n = a - 1
m = b - 1
x = s[n]
y = s[m]
print(x)
print(y)
print(s[:n] + y + s[a:m] + x + s[m + 1 :])
s = input()
a, b = map(int, input().split())
n = a - 1
m = b - 1
x = s[n]
y = s[m]
print(s[:n] + y + s[a:m] + x + s[m + 1 :])
|
ConDefects/ConDefects/Code/abc236_a/Python/45430544
|
condefects-python_data_1002
|
from collections import deque
import sys
import math
import heapq
import random
import itertools
from functools import cmp_to_key
from fractions import Fraction
def gs():
return sys.stdin.readline().split()[0]
def gd():
return float(sys.stdin.readline())
def gi():
return int(sys.stdin.readline())
def gia():
return list(map(int,sys.stdin.readline().split()))
def gsa():
return sys.stdin.readline().split()
def readGraph(N,M, idx=0, hasDirect=False, hasCost=False):
G=[]
if(hasCost):
G=Graph(N)
else:
for i in range(N):
G.append([])
for i in range(M):
E=gia()
if(not hasCost):
u=E[0]-(1-idx)
v=E[1]-(1-idx)
G[u].append(v)
if(not hasDirect):
G[v].append(u)
else:
u=E[0]-(1-idx)
v=E[1]-(1-idx)
c=E[2]
G.addEdge(u,v,c)
if(not hasDirect):
G.addEdge(v,u,c)
return G
def ceil_pow2(n):
x=0
while((1<<x)<n):
x+=1
return x
def uclid(m, n):
if(n==0):
return m
else:
return uclid(n, m%n)
#拡張ユークリッドの互除法
def invGcd(a, b):
a%=b
if a==0: return b,0
s, t=b, a
m0, m1=0,1
while(t):
u=s//t
s-=t*u
m0-=m1*u
s,t=t,s
m0,m1=m1,m0
if m0<0: m0+=b//s
return s,m0
# 逆元を求める。存在しないときは-1を返す
def invMod(x, m):
z=invGcd(x,m)
if(z[0]!=1):return -1
return z[1]
#約数取得
def yakusu(n):
l=[]
for i in range(1, n+1):
if(i*i>n):
break;
if(n%i==0):
l.append(i)
if(n/i!=i):
l.append(n//i)
return l
def insuB(n):
l=[]
i=2
while(i*i<=n):
if(n%i==0):
l.append(i)
n=n//i
else:
i+=1
if(n!=1):
l.append(n)
return l
def insuBm(n):
m=dict()
for i in range(2, n):
if(i*i>n):break
while(n%i==0):
if(not(i in m)):
m[i]=1
else:
m[i]+=1
n=n//i
if(n!=1):
if(not(n in m)):
m[n]=1
else:
m[n]+=1
return m
KAIJO_DP=[0]*4000000
def kaijo(n, mod):
if(n<=1):
return 1
if(KAIJO_DP[n]!=0):
return KAIJO_DP[n]
ans=n*kaijo(n-1, mod)
ans%=mod
KAIJO_DP[n]=ans
return ans
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
def beforeCmb(num,mod):
for i in range( 2, num + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
def isP(n):
if(n==1):
return False
for i in range(2, math.floor(math.sqrt(n))+1):
if(n%i==0):
return False
return True
def nextCombination(sub):
x=sub & (-sub)
y=sub+x
return (((sub & ~y) // x) >> 1) | y
class FenwickTree:
def __init__(self, n):
self.N = n
self.data = [0] * n
def add(self, p, x):
if(p<0 or p >= self.N):
return None
p+=1
while(p<=self.N):
self.data[p-1]+=x
p+=p&-p;
def get(self, l, r):
if(l<0 or l>r or r>self.N):
return -(1<<64)
return self._innerSum(r) - self._innerSum(l)
def _innerSum(self, r):
s=0
while(r>0):
s+=self.data[r-1]
r-=r&-r
return s
class FenwickTreeImos:
def __init__(self, n):
self.fw = FenwickTree(n+1)
def add(self, s, t, x):
self.fw.add(s, x)
self.fw.add(t, -x)
def get(self, i):
return self[i]
def __getitem__(self, key):
return self.fw.get(0, key+1)
class Edge:
def __init__(self, f, t, c):
self._from=f
self._to=t
self._cost=c
def getStart(self):
return self._from
def getEnd(self):
return self._to
def getDistance(self):
return self._cost
def setDistance(self, c):
self._cost =c
class Graph:
def __init__(self, n):
self.gla=[]
self.prev=[-1]*n
for i in range(n):
self.gla.append([])
def addEdge(self, u, v, l):
e=Edge(u, v, l)
self.gla[u].append(e)
def removeEdge(self, u, v):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
l.remove(edge)
def changeLength(self, u, v, d):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
edge.setDistance(d)
break
def getVertexNum(self):
return len(self.gla)
def getEdgeLength(self, u, v):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
return edge.getDistance()
return 1<<64
def dijkstra(self, start):
d=[1<<64] * self.getVertexNum()
d[start]=0
q=[]
heapq.heappush(q, (0, start))
self.prev[start]=-1
while(len(q)!=0):
p=heapq.heappop(q)
if(p[0]>d[p[1]]):
continue
el=self.gla[p[1]]
for edge in el:
to=edge.getEnd()
fr=edge.getStart()
cost=edge.getDistance()
if(d[to]>d[fr]+cost):
d[to]=d[fr]+cost
self.prev[to]=fr
heapq.heappush(q, (d[to], to))
return d
def getPath(self, v):
path=[]
while(v!=-1):
path.append(v)
v=self.prev[v]
path.reverse()
return path
class SegTree:
def __init__(self, v, op, e):
self.n=len(v)
self.log=ceil_pow2(self.n)
self.size=1<<self.log
self.op=op
self.e=e
self.d=[e]*(2*self.size)
for i in range(self.n):
self.d[self.size+i]=v[i]
for i in range(self.size-1, 0, -1):
self._update(i)
def setVal(self, p, x):
p+=self.size
self.d[p]=x
for i in range(1, self.log+1):
self._update(p>>i)
def getVal(self, p):
return self.d[p+self.size]
def prod(self, l, r):
sml=self.e
smr=self.e
l+=self.size
r+=self.size
while(l<r):
if(l&1 != 0):
sml=self.op(sml, self.d[l])
l+=1
if(r&1 != 0):
r-=1
smr=self.op(self.d[r], smr)
l>>=1
r>>=1
return self.op(sml,smr)
def allProd(self):
return self.d[1]
def maxRight(self, l, f):
if(l==self.n):return self.n
l+=self.size
sm=self.e
while True:
while(l%2==0):
l>>=1
if(not f(self.op(sm,self.d[l]))):
while(l<self.size):
l=2*l
if(f(self.op(sm, self.d[l]))):
sm=self.op(sm, self.d[l])
l+=1
return l-self.size
sm=self.op(sm, self.d[l])
l+=1
if((l & -l) == l):break
return self.n
def minLeft(self, r, f):
if(r==0):return 0
r+=self.size
sm=self.e
while(True):
r-=1
while(r>1 and r%2==1):
r>>=1
if(not f(self.op(self.d[r], sm))):
while(r<self.size):
r=2*r+1
if(f(self.op(self.d[r],sm))):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r], sm)
if((r&-r)==r):break
return 0
def _update(self, k):
self.d[k]=self.op(self.d[2*k], self.d[2*k+1])
class UnionFind:
def __init__(self, n):
self.parent=list(range(n))
self.rank=[0]*n
self.count=[1]*n
def find(self, n):
if(n!=self.parent[n]):
self.parent[n]=self.find(self.parent[n])
return self.parent[n]
def union(self, n1, n2):
r1=self.find(n1)
r2=self.find(n2)
if(self.rank[r1]>self.rank[r2]):
self.parent[r2]=r1
self.count[r1]=self.count[r1]+self.count[r2]
elif(self.rank[r1]<self.rank[r2]):
self.parent[r1]=r2
self.count[r2]=self.count[r1]+self.count[r2]
elif(r1!=r2):
self.parent[r2]=r1
self.rank[r1]+=1
self.count[r1]=self.count[r1]+self.count[r2]
def getRunk(self, n):
return self.rank[n]
def getCount(self, n):
return self.count[self.find(n)]
def getKindNum(self):
ret=0
for i in range(len(self.parent)):
if(self.parent[i]==i):
ret+=1
return ret
def same(self, n1, n2):
return self.find(n1)==self.find(n2)
def grouping(self):
m=dict()
for i in range(len(self.parent)):
p=self.find(i)
l=m.get(p, [])
l.append(i)
m[p]=l
return m
def main_():
N=gi()
S=gs()
nsi=0
nli=N-1
si=0
li=N-1
alp="abcdefghijklmnopqrstuvwxyz"
cs=[]
for i in range(N):
cs.append(S[i])
for i in range(26):
nsi=si
nli=li
while(nli>nsi):
while(nli>nsi):
c=cs[nli]
if(c==alp[i]):
break
nli-=1
while(nsi<nli):
c=cs[nsi]
idx=alp.find(c)
if(idx>i):
break
nsi+=1
if(nsi<nli):
tmp=cs[nsi]
cs[nsi]=cs[nli]
cs[nli]=tmp
si=nsi
li=nli
ans=''.join(cs)
print(ans)
main_()
from collections import deque
import sys
import math
import heapq
import random
import itertools
from functools import cmp_to_key
from fractions import Fraction
def gs():
return sys.stdin.readline().split()[0]
def gd():
return float(sys.stdin.readline())
def gi():
return int(sys.stdin.readline())
def gia():
return list(map(int,sys.stdin.readline().split()))
def gsa():
return sys.stdin.readline().split()
def readGraph(N,M, idx=0, hasDirect=False, hasCost=False):
G=[]
if(hasCost):
G=Graph(N)
else:
for i in range(N):
G.append([])
for i in range(M):
E=gia()
if(not hasCost):
u=E[0]-(1-idx)
v=E[1]-(1-idx)
G[u].append(v)
if(not hasDirect):
G[v].append(u)
else:
u=E[0]-(1-idx)
v=E[1]-(1-idx)
c=E[2]
G.addEdge(u,v,c)
if(not hasDirect):
G.addEdge(v,u,c)
return G
def ceil_pow2(n):
x=0
while((1<<x)<n):
x+=1
return x
def uclid(m, n):
if(n==0):
return m
else:
return uclid(n, m%n)
#拡張ユークリッドの互除法
def invGcd(a, b):
a%=b
if a==0: return b,0
s, t=b, a
m0, m1=0,1
while(t):
u=s//t
s-=t*u
m0-=m1*u
s,t=t,s
m0,m1=m1,m0
if m0<0: m0+=b//s
return s,m0
# 逆元を求める。存在しないときは-1を返す
def invMod(x, m):
z=invGcd(x,m)
if(z[0]!=1):return -1
return z[1]
#約数取得
def yakusu(n):
l=[]
for i in range(1, n+1):
if(i*i>n):
break;
if(n%i==0):
l.append(i)
if(n/i!=i):
l.append(n//i)
return l
def insuB(n):
l=[]
i=2
while(i*i<=n):
if(n%i==0):
l.append(i)
n=n//i
else:
i+=1
if(n!=1):
l.append(n)
return l
def insuBm(n):
m=dict()
for i in range(2, n):
if(i*i>n):break
while(n%i==0):
if(not(i in m)):
m[i]=1
else:
m[i]+=1
n=n//i
if(n!=1):
if(not(n in m)):
m[n]=1
else:
m[n]+=1
return m
KAIJO_DP=[0]*4000000
def kaijo(n, mod):
if(n<=1):
return 1
if(KAIJO_DP[n]!=0):
return KAIJO_DP[n]
ans=n*kaijo(n-1, mod)
ans%=mod
KAIJO_DP[n]=ans
return ans
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
def beforeCmb(num,mod):
for i in range( 2, num + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
def isP(n):
if(n==1):
return False
for i in range(2, math.floor(math.sqrt(n))+1):
if(n%i==0):
return False
return True
def nextCombination(sub):
x=sub & (-sub)
y=sub+x
return (((sub & ~y) // x) >> 1) | y
class FenwickTree:
def __init__(self, n):
self.N = n
self.data = [0] * n
def add(self, p, x):
if(p<0 or p >= self.N):
return None
p+=1
while(p<=self.N):
self.data[p-1]+=x
p+=p&-p;
def get(self, l, r):
if(l<0 or l>r or r>self.N):
return -(1<<64)
return self._innerSum(r) - self._innerSum(l)
def _innerSum(self, r):
s=0
while(r>0):
s+=self.data[r-1]
r-=r&-r
return s
class FenwickTreeImos:
def __init__(self, n):
self.fw = FenwickTree(n+1)
def add(self, s, t, x):
self.fw.add(s, x)
self.fw.add(t, -x)
def get(self, i):
return self[i]
def __getitem__(self, key):
return self.fw.get(0, key+1)
class Edge:
def __init__(self, f, t, c):
self._from=f
self._to=t
self._cost=c
def getStart(self):
return self._from
def getEnd(self):
return self._to
def getDistance(self):
return self._cost
def setDistance(self, c):
self._cost =c
class Graph:
def __init__(self, n):
self.gla=[]
self.prev=[-1]*n
for i in range(n):
self.gla.append([])
def addEdge(self, u, v, l):
e=Edge(u, v, l)
self.gla[u].append(e)
def removeEdge(self, u, v):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
l.remove(edge)
def changeLength(self, u, v, d):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
edge.setDistance(d)
break
def getVertexNum(self):
return len(self.gla)
def getEdgeLength(self, u, v):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
return edge.getDistance()
return 1<<64
def dijkstra(self, start):
d=[1<<64] * self.getVertexNum()
d[start]=0
q=[]
heapq.heappush(q, (0, start))
self.prev[start]=-1
while(len(q)!=0):
p=heapq.heappop(q)
if(p[0]>d[p[1]]):
continue
el=self.gla[p[1]]
for edge in el:
to=edge.getEnd()
fr=edge.getStart()
cost=edge.getDistance()
if(d[to]>d[fr]+cost):
d[to]=d[fr]+cost
self.prev[to]=fr
heapq.heappush(q, (d[to], to))
return d
def getPath(self, v):
path=[]
while(v!=-1):
path.append(v)
v=self.prev[v]
path.reverse()
return path
class SegTree:
def __init__(self, v, op, e):
self.n=len(v)
self.log=ceil_pow2(self.n)
self.size=1<<self.log
self.op=op
self.e=e
self.d=[e]*(2*self.size)
for i in range(self.n):
self.d[self.size+i]=v[i]
for i in range(self.size-1, 0, -1):
self._update(i)
def setVal(self, p, x):
p+=self.size
self.d[p]=x
for i in range(1, self.log+1):
self._update(p>>i)
def getVal(self, p):
return self.d[p+self.size]
def prod(self, l, r):
sml=self.e
smr=self.e
l+=self.size
r+=self.size
while(l<r):
if(l&1 != 0):
sml=self.op(sml, self.d[l])
l+=1
if(r&1 != 0):
r-=1
smr=self.op(self.d[r], smr)
l>>=1
r>>=1
return self.op(sml,smr)
def allProd(self):
return self.d[1]
def maxRight(self, l, f):
if(l==self.n):return self.n
l+=self.size
sm=self.e
while True:
while(l%2==0):
l>>=1
if(not f(self.op(sm,self.d[l]))):
while(l<self.size):
l=2*l
if(f(self.op(sm, self.d[l]))):
sm=self.op(sm, self.d[l])
l+=1
return l-self.size
sm=self.op(sm, self.d[l])
l+=1
if((l & -l) == l):break
return self.n
def minLeft(self, r, f):
if(r==0):return 0
r+=self.size
sm=self.e
while(True):
r-=1
while(r>1 and r%2==1):
r>>=1
if(not f(self.op(self.d[r], sm))):
while(r<self.size):
r=2*r+1
if(f(self.op(self.d[r],sm))):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r], sm)
if((r&-r)==r):break
return 0
def _update(self, k):
self.d[k]=self.op(self.d[2*k], self.d[2*k+1])
class UnionFind:
def __init__(self, n):
self.parent=list(range(n))
self.rank=[0]*n
self.count=[1]*n
def find(self, n):
if(n!=self.parent[n]):
self.parent[n]=self.find(self.parent[n])
return self.parent[n]
def union(self, n1, n2):
r1=self.find(n1)
r2=self.find(n2)
if(self.rank[r1]>self.rank[r2]):
self.parent[r2]=r1
self.count[r1]=self.count[r1]+self.count[r2]
elif(self.rank[r1]<self.rank[r2]):
self.parent[r1]=r2
self.count[r2]=self.count[r1]+self.count[r2]
elif(r1!=r2):
self.parent[r2]=r1
self.rank[r1]+=1
self.count[r1]=self.count[r1]+self.count[r2]
def getRunk(self, n):
return self.rank[n]
def getCount(self, n):
return self.count[self.find(n)]
def getKindNum(self):
ret=0
for i in range(len(self.parent)):
if(self.parent[i]==i):
ret+=1
return ret
def same(self, n1, n2):
return self.find(n1)==self.find(n2)
def grouping(self):
m=dict()
for i in range(len(self.parent)):
p=self.find(i)
l=m.get(p, [])
l.append(i)
m[p]=l
return m
def main_():
N=gi()
S=gs()
nsi=0
nli=N-1
si=0
li=N-1
alp="abcdefghijklmnopqrstuvwxyz"
cs=[]
for i in range(N):
cs.append(S[i])
for i in range(26):
nsi=si
nli=li
while(nli>nsi):
while(nli>nsi):
c=cs[nli]
if(c==alp[i]):
break
nli-=1
while(nsi<nli):
c=cs[nsi]
idx=alp.find(c)
if(idx>i):
break
nsi+=1
if(nsi<nli):
tmp=cs[nsi]
cs[nsi]=cs[nli]
cs[nli]=tmp
nsi+=1
nli-=1
si=nsi
li=nli
ans=''.join(cs)
print(ans)
main_()
|
ConDefects/ConDefects/Code/arc134_b/Python/42294633
|
condefects-python_data_1003
|
from collections import deque
N = int(input())
s = list(input())
index = {chr(ord('a') + x): deque() for x in range(26)}
for i in range(N):
index[s[i]].append(i)
l, r = 0, N
while r - l > 1:
for x in range(ord(s[l]) - ord('a')):
c = chr(ord('a') + x)
while len(index[c]) > 0:
i = index[c].pop()
if l < i < r:
s[l], s[i] = s[i], s[l]
l, r = l+1, i
break
elif i < l:
index[c] = []
else:
continue
break
l += 1
print(''.join(s))
from collections import deque
N = int(input())
s = list(input())
index = {chr(ord('a') + x): deque() for x in range(26)}
for i in range(N):
index[s[i]].append(i)
l, r = 0, N
while r - l > 1:
for x in range(ord(s[l]) - ord('a')):
c = chr(ord('a') + x)
while len(index[c]) > 0:
i = index[c].pop()
if l < i < r:
s[l], s[i] = s[i], s[l]
r = i
break
elif i < l:
index[c] = []
else:
continue
break
l += 1
print(''.join(s))
|
ConDefects/ConDefects/Code/arc134_b/Python/40879387
|
condefects-python_data_1004
|
import sys
from collections import Counter
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
N = int(readline())
S = readline().rstrip()
C = Counter(S)
S = list(S)
alp = 'abcdefghijklmnopqrstuvwxyz'
now = 0
left = 0
right = N - 1
while left < right:
while C[alp[now]] == 0:
now += 1
if S[left] == alp[now]:
left += 1
C[alp[now]] -= 1
continue
if S[right] != alp[now]:
right -= 1
C[S[right]] -= 1
else:
S[left], S[right] = S[right], S[left]
C[alp[now]] -= 1
C[S[right]] -= 1
left += 1
right -= 1
print(''.join(S))
import sys
from collections import Counter
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
N = int(readline())
S = readline().rstrip()
C = Counter(S)
S = list(S)
alp = 'abcdefghijklmnopqrstuvwxyz'
now = 0
left = 0
right = N - 1
while left < right:
while C[alp[now]] == 0:
now += 1
if S[left] == alp[now]:
left += 1
C[alp[now]] -= 1
continue
if S[right] != alp[now]:
C[S[right]] -= 1
right -= 1
else:
S[left], S[right] = S[right], S[left]
C[alp[now]] -= 1
C[S[right]] -= 1
left += 1
right -= 1
print(''.join(S))
|
ConDefects/ConDefects/Code/arc134_b/Python/42982979
|
condefects-python_data_1005
|
N = int(input())
S = list(input())
T = [0] * N
X = [[] for _ in range(26)]
cmin = 26
for i, s in enumerate(S):
a = ord(s) - 97
T[i] = a
X[a].append(i)
cmin = min(cmin, a)
j = N
i = 0
while i < j:
if T[i] != cmin:
if X[cmin]:
if i < X[cmin][-1] < j:
j = X[cmin].pop(-1)
S[j] = S[i]
S[i] = chr(cmin + 97)
i += 1
else:
X[cmin] = []
else:
if cmin < 25:
cmin += 1
else:
break
else:
i += 1
print("".join(S))
N = int(input())
S = list(input())
T = [0] * N
X = [[] for _ in range(26)]
cmin = 26
for i, s in enumerate(S):
a = ord(s) - 97
T[i] = a
X[a].append(i)
cmin = min(cmin, a)
j = N
i = 0
while i < j:
if T[i] != cmin:
if X[cmin]:
if i < X[cmin][-1] < j:
j = X[cmin].pop(-1)
S[j] = S[i]
S[i] = chr(cmin + 97)
i += 1
else:
X[cmin].pop(-1)
else:
if cmin < 25:
cmin += 1
else:
break
else:
i += 1
print("".join(S))
|
ConDefects/ConDefects/Code/arc134_b/Python/45004334
|
condefects-python_data_1006
|
r, c = map(int, input().split())
if min(r,c, 15-r, 15-c) % 2 == 1:
print('black')
else:
print('white')
r, c = map(int, input().split())
if max(abs(r-8), abs(c-8)) % 2 == 1:
print('black')
else:
print('white')
|
ConDefects/ConDefects/Code/abc264_b/Python/45725806
|
condefects-python_data_1007
|
r,c=map(int,input().split())
if min(r,c)%2==1:print("black")
else:print("white")
r,c=map(int,input().split())
if max(abs(r-7),abs(c-7))%2==0:print("black")
else:print("white")
|
ConDefects/ConDefects/Code/abc264_b/Python/44649966
|
condefects-python_data_1008
|
r,c = map(int,input().split())
if (abs(r-8)+abs(c-8))%2==0:
print("black")
else:
print("white")
r,c = map(int,input().split())
if max(abs(r-8),abs(c-8)) %2 == 1:
print("black")
else:
print("white")
|
ConDefects/ConDefects/Code/abc264_b/Python/44650000
|
condefects-python_data_1009
|
R,C = map(int,input().split())
t = min(R,C)
ans = 'white'
if t % 2 == 1:
ans = 'black'
print(ans)
R,C = map(int,input().split())
t = min(R,C,16-R,16-C)
ans = 'white'
if t % 2 == 1:
ans = 'black'
print(ans)
|
ConDefects/ConDefects/Code/abc264_b/Python/44791735
|
condefects-python_data_1010
|
r,c=map(int,input().split())
print(("white","blue")[max(abs(r-8),abs(c-8))%2])
r,c=map(int,input().split())
print(("white","black")[max(abs(r-8),abs(c-8))%2])
|
ConDefects/ConDefects/Code/abc264_b/Python/44581422
|
condefects-python_data_1011
|
r,c = list(map(int,input().split(" ")))
if((abs(8-r)+abs(8-c))%2 == 0):
print("black")
else:
print("white")
r,c = list(map(int,input().split(" ")))
if(max([abs(8-r),abs(8-c)])%2 != 0):
print("black")
else:
print("white")
|
ConDefects/ConDefects/Code/abc264_b/Python/45323702
|
condefects-python_data_1012
|
R,C = map(int,input().split())
if max(abs(R-8)%2,abs(C-8)) % 2 != 0:
print("white")
else:
print("black")
R,C = map(int,input().split())
if max(abs(R-8),abs(C-8)) % 2 == 0:
print("white")
else:
print("black")
|
ConDefects/ConDefects/Code/abc264_b/Python/44655850
|
condefects-python_data_1013
|
R,C=map(int,input().split())
dist=min(R-8,C-8)
if dist%2==1: print("black")
else: print("white")
R,C=map(int,input().split())
dist=max(abs(R-8),abs(C-8))
if dist%2==1: print("black")
else: print("white")
|
ConDefects/ConDefects/Code/abc264_b/Python/45507078
|
condefects-python_data_1014
|
N=int(input())
x=0
A=list(map(int,input().split()))
T={}
for i in range(N):
x^=A[i]
T[A[i]]=1
if x in T:
print('Win')
exit()
if N%2==1:
print('Win')
else:
print('No')
N=int(input())
x=0
A=list(map(int,input().split()))
T={}
for i in range(N):
x^=A[i]
T[A[i]]=1
if x in T:
print('Win')
exit()
if N%2==1:
print('Win')
else:
print('Lose')
|
ConDefects/ConDefects/Code/arc131_c/Python/41901450
|
condefects-python_data_1015
|
import sys
input = sys.stdin.readline
inf = float('inf')
def read(dtype=int):
return list(map(dtype, input().split()))
n = int(input())
a = read()
c = 0
for i in a:
c ^= i
for j in range(30):
if all(i >> j & 1 for i in a):
print("Win")
exit()
print("Win" if n == 1 or n == 3 or c in a else "Lose")
import sys
input = sys.stdin.readline
inf = float('inf')
def read(dtype=int):
return list(map(dtype, input().split()))
n = int(input())
a = read()
c = 0
for i in a:
c ^= i
for j in range(30):
if all(i >> j & 1 for i in a):
print("Win")
exit()
print("Win" if n & 1 or c in a else "Lose")
|
ConDefects/ConDefects/Code/arc131_c/Python/40380616
|
condefects-python_data_1016
|
from collections import deque
N,M = map(int,input().split())
XY = list(set([tuple(map(int,input().split())) for _ in range(M)]))
to = [[] for _ in range(N+1)]
deg = [0 for _ in range(N+1)]
for X,Y in XY:
if X == Y: continue
to[X].append(Y)
deg[Y] += 1
dq = deque([i for i in range(1,N+1) if deg[i] == 0])
P = []
while dq:
x = dq.popleft()
P.append(x)
for to_x in to[x]:
deg[to_x] -= 1
if deg[to_x] == 0:
dq.append(to_x)
if len(dq) >= 2:
print("No"); exit()
if len(P) != N:
print("No"); exit()
ans = [0 for _ in range(N+1)]
for i in range(N):
ans[P[i]] = i+1
print("Yes")
print(*ans[1:])
from collections import deque
N,M = map(int,input().split())
XY = list(set([tuple(map(int,input().split())) for _ in range(M)]))
to = [[] for _ in range(N+1)]
deg = [0 for _ in range(N+1)]
for X,Y in XY:
if X == Y: continue
to[X].append(Y)
deg[Y] += 1
dq = deque([i for i in range(1,N+1) if deg[i] == 0])
P = []
while dq and len(dq) < 2:
x = dq.popleft()
P.append(x)
for to_x in to[x]:
deg[to_x] -= 1
if deg[to_x] == 0:
dq.append(to_x)
if len(dq) >= 2:
print("No"); exit()
if len(P) != N:
print("No"); exit()
ans = [0 for _ in range(N+1)]
for i in range(N):
ans[P[i]] = i+1
print("Yes")
print(*ans[1:])
|
ConDefects/ConDefects/Code/abc291_e/Python/45325123
|
condefects-python_data_1017
|
n, m = map(int, input().split())
b = [None for _ in range(n)]
for i in range(n):
b[i] = list(map(int, input().split()))
def check():
c = list(map(list, zip(*b)))
for i in range(m):
for j in range(n - 1):
if c[i][j + 1] != c[i][j] + 7:
return False
temp = b[0]
for i in range(m - 1):
if ((temp[i + 1] + 6) % 7) != ((temp[i] + 6) % 7) + 1:
return False
return True
if check():
print("Yes")
else:
print("No")
n, m = map(int, input().split())
b = [None for _ in range(n)]
for i in range(n):
b[i] = list(map(int, input().split()))
def check():
c = list(map(list, zip(*b)))
for i in range(m):
for j in range(n - 1):
if c[i][j + 1] != c[i][j] + 7:
return False
temp = b[0]
for i in range(m - 1):
if ((temp[i + 1] + 6) % 7) != ((temp[i] + 6) % 7) + 1:
return False
if temp[i + 1] != temp[i] + 1:
return False
return True
if check():
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc225_c/Python/45226527
|
condefects-python_data_1018
|
#import
import sys
import string
import collections
import itertools
import math
#constant
alphabet=string.ascii_lowercase
ALPHABET=string.ascii_uppercase
inf=float("inf")
mod=998244353
sift4=((-1,0),(0,-1),(1,0),(0,1))
sift6=((-1,0,0),(0,-1,0),(0,0,-1),(1,0,0),(0,1,0),(0,0,1))
sift8=((-1,0),(-1,-1),(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,1))
#input
def inputs():return input().split()
def iinput():return int(input())
def sinput():return set(input())
def linput():return list(input())
def linputs():return list(inputs())
def iinputs():return map(int,inputs())
def liinputs():return list(iinputs())
def tiinputs():return tuple(iinputs())
def sinputr(i):return set(input()for _ in range(i))
def linputr(i):return list(input()for _ in range(i))
def llinputr(i):return list(linput()for _ in range(i))
def llinputsr(i):return list(linputs()for _ in range(i))
def lliinputsr(i):return list(liinputs()for _ in range(i))
def stiinputsr(i):return set(tiinputs()for _ in range(i))
#conversion
def A_to_a(c):return chr(ord(c)+32)
def a_to_A(c):return chr(ord(c)-32)
def f_to_i(f):
f_i,f_f = str(f).split(".")
return int(f_i) if int(f_f[0]) < 5 else int(f_i)+1
#judge
def palindrome(a,b):return True if a == b[::-1] else False
#patterns
def distinct_strings(s):
st = set()
for S in itertools.permutations(s):st.add("".join(S))
return list(st)
def manhattan(i):
ans = set()
for I in range(i+1):
ans.add((i-I,I))
ans.add((I-i,I))
ans.add((i-I,-I))
ans.add((I-i,-I))
return ans
#math
def modulo(i):return i % mod
def round_my(i_or_f,i=0):None
def sumr(l):return sum(map(sum,l))
#class
class UnionFind():
def __init__(self,n):
self.n=n
self.parents=[-1]*n
def find(self,x):
if self.parents[x]<0:return x
else:
self.parents[x]=self.find(self.parents[x])
return self.parents[x]
def union(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:return
if self.parents[x]>self.parents[y]:x,y=y,x
self.parents[x]+=self.parents[y]
self.parents[y]=x
def size(self,x):return -self.parents[self.find(x)]
def same(self,x,y):return self.find(x)==self.find(y)
def members(self,x):
root=self.find(x)
return [i for i in range(self.n)if self.find(i)==root]
def roots(self):return [i for i,x in enumerate(self.parents)if x<0]
def group_count(self):return len(self.roots())
def all_group_members(self):
group_members = collections.defaultdict(list)
for member in range(self.n):group_members[self.find(member)].append(member)
return group_members
def __str__(self):return '\n'.join(f'{r}:{m}'for r,m in self.all_group_members().items())
#others
def minreverse(a):return min(a,a[::-1])
def dif_chr(sa,sb):
ans=0
for SA,SB in zip(sa,sb):
if SA!=SB:ans += 1
return ans
def mkl(n,*a):return list(mkl(n,*a[:-1])for A in range(a[-1]))if a else n
def mkt(i,l):
ans=[[]for I in range(i)]
for L1,L2 in l:
ans[L1-1].append(L2-1)
ans[L2-1].append(L1-1)
return ans
#output
def Y_or_N(o):print("Yes" if o else "No")
def a_or_b(a,o,b):print(a if o else b)
def printr(a):
for A in a:print(A)
def lprintr(a):
for A in a:print(*A)
#----------------------------------------------------------------
n,m = iinputs()
b = lliinputsr(n)
ans = True
for M in range(m-1):
b1,b2 = b[0][M:M+2]
if b1+1 != b2 or b1%7+1 != b2%7:ans = False
for N in range(n-1):
for M in range(m):
if b[N][M]+7 != b[N+1][M]:ans = False
Y_or_N(ans)
#import
import sys
import string
import collections
import itertools
import math
#constant
alphabet=string.ascii_lowercase
ALPHABET=string.ascii_uppercase
inf=float("inf")
mod=998244353
sift4=((-1,0),(0,-1),(1,0),(0,1))
sift6=((-1,0,0),(0,-1,0),(0,0,-1),(1,0,0),(0,1,0),(0,0,1))
sift8=((-1,0),(-1,-1),(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,1))
#input
def inputs():return input().split()
def iinput():return int(input())
def sinput():return set(input())
def linput():return list(input())
def linputs():return list(inputs())
def iinputs():return map(int,inputs())
def liinputs():return list(iinputs())
def tiinputs():return tuple(iinputs())
def sinputr(i):return set(input()for _ in range(i))
def linputr(i):return list(input()for _ in range(i))
def llinputr(i):return list(linput()for _ in range(i))
def llinputsr(i):return list(linputs()for _ in range(i))
def lliinputsr(i):return list(liinputs()for _ in range(i))
def stiinputsr(i):return set(tiinputs()for _ in range(i))
#conversion
def A_to_a(c):return chr(ord(c)+32)
def a_to_A(c):return chr(ord(c)-32)
def f_to_i(f):
f_i,f_f = str(f).split(".")
return int(f_i) if int(f_f[0]) < 5 else int(f_i)+1
#judge
def palindrome(a,b):return True if a == b[::-1] else False
#patterns
def distinct_strings(s):
st = set()
for S in itertools.permutations(s):st.add("".join(S))
return list(st)
def manhattan(i):
ans = set()
for I in range(i+1):
ans.add((i-I,I))
ans.add((I-i,I))
ans.add((i-I,-I))
ans.add((I-i,-I))
return ans
#math
def modulo(i):return i % mod
def round_my(i_or_f,i=0):None
def sumr(l):return sum(map(sum,l))
#class
class UnionFind():
def __init__(self,n):
self.n=n
self.parents=[-1]*n
def find(self,x):
if self.parents[x]<0:return x
else:
self.parents[x]=self.find(self.parents[x])
return self.parents[x]
def union(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:return
if self.parents[x]>self.parents[y]:x,y=y,x
self.parents[x]+=self.parents[y]
self.parents[y]=x
def size(self,x):return -self.parents[self.find(x)]
def same(self,x,y):return self.find(x)==self.find(y)
def members(self,x):
root=self.find(x)
return [i for i in range(self.n)if self.find(i)==root]
def roots(self):return [i for i,x in enumerate(self.parents)if x<0]
def group_count(self):return len(self.roots())
def all_group_members(self):
group_members = collections.defaultdict(list)
for member in range(self.n):group_members[self.find(member)].append(member)
return group_members
def __str__(self):return '\n'.join(f'{r}:{m}'for r,m in self.all_group_members().items())
#others
def minreverse(a):return min(a,a[::-1])
def dif_chr(sa,sb):
ans=0
for SA,SB in zip(sa,sb):
if SA!=SB:ans += 1
return ans
def mkl(n,*a):return list(mkl(n,*a[:-1])for A in range(a[-1]))if a else n
def mkt(i,l):
ans=[[]for I in range(i)]
for L1,L2 in l:
ans[L1-1].append(L2-1)
ans[L2-1].append(L1-1)
return ans
#output
def Y_or_N(o):print("Yes" if o else "No")
def a_or_b(a,o,b):print(a if o else b)
def printr(a):
for A in a:print(A)
def lprintr(a):
for A in a:print(*A)
#----------------------------------------------------------------
n,m = iinputs()
b = lliinputsr(n)
ans = True
for M in range(m-1):
b1,b2 = b[0][M]-1,b[0][M+1]-1
if b1+1 != b2 or b1%7+1 != b2%7:ans = False
for N in range(n-1):
for M in range(m):
if b[N][M]+7 != b[N+1][M]:ans = False
Y_or_N(ans)
|
ConDefects/ConDefects/Code/abc225_c/Python/44888915
|
condefects-python_data_1019
|
from sys import stdin
def check(b, n, m):
for i in range(n):
if b[i][0] % 7 + m > 8:
return False
if i + 1 < n and b[i + 1][0] != b[i][0] + 7:
return False
for j in range(m - 1):
if b[i][j + 1] != b[i][j] + 1:
return False
return True
def main():
input = stdin.readline
n, m = map(int, input().split())
b = [list(map(int, input().split())) for _ in range(n)]
print("Yes" if check(b, n, m) else "No")
if __name__ == "__main__":
main()
from sys import stdin
def check(b, n, m):
for i in range(n):
if (b[i][0] - 1) % 7 + m > 7:
return False
if i + 1 < n and b[i + 1][0] != b[i][0] + 7:
return False
for j in range(m - 1):
if b[i][j + 1] != b[i][j] + 1:
return False
return True
def main():
input = stdin.readline
n, m = map(int, input().split())
b = [list(map(int, input().split())) for _ in range(n)]
print("Yes" if check(b, n, m) else "No")
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc225_c/Python/45664223
|
condefects-python_data_1020
|
def a(n,m,B):
x=B[0][0]
for i in range(n):
for j in range(m):
if B[i][j]!=x+i*7+j:
return "No"
return "Yes"
n,m=map(int,input().split())
B=[list(map(int,input().split())) for _ in range(n)]
print(a(n,m,B))
def a(n,m,B):
x=B[0][0]
for i in range(n):
for j in range(m):
if B[i][j]!=x+i*7+j:
return "No"
if B[i][j]%7==0 and j!=m-1:
return "No"
return "Yes"
n,m=map(int,input().split())
B=[list(map(int,input().split())) for _ in range(n)]
print(a(n,m,B))
|
ConDefects/ConDefects/Code/abc225_c/Python/44469125
|
condefects-python_data_1021
|
import sys
from collections import deque,defaultdict
import itertools
import heapq
import bisect
import queue
#sys.setrecursionlimit(10 ** 9)
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
li_st = lambda: list(map(str, input().split()))
lli = lambda n: [li() for _ in range(n)]
mod = 998244353
N,M = mi()
B = lli(N)
ans = "Yes"
for i in range(N):
for j in range(M):
if i != 0:
if B[i][j] != B[i-1][j] + 7:
ans = "No"
if j != 0:
if ((B[i][j] - 1) % 7) - ((B[i][j-1] - 1) % 7) != 1:
ans = "No"
print(ans)
import sys
from collections import deque,defaultdict
import itertools
import heapq
import bisect
import queue
#sys.setrecursionlimit(10 ** 9)
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
li_st = lambda: list(map(str, input().split()))
lli = lambda n: [li() for _ in range(n)]
mod = 998244353
N,M = mi()
B = lli(N)
ans = "Yes"
for i in range(N):
for j in range(M):
if i != 0:
if B[i][j] != B[i-1][j] + 7:
ans = "No"
if j != 0:
if ((B[i][j] - 1) % 7) - ((B[i][j-1] - 1) % 7) != 1:
ans = "No"
if B[i][j] - B[i][j-1] != 1:
ans = "No"
print(ans)
|
ConDefects/ConDefects/Code/abc225_c/Python/44416948
|
condefects-python_data_1022
|
n, m = map(int, input().split())
b = [list(map(int, input().split())) for i in range(n)]
ans = True
for i in range(m-1):
if b[0][i]+1 != b[0][i+1]:
ans = False
if b[0][i]%7+1 != b[0][i+1]%7:
ans = False
for i in range(n-1):
for j in range(m):
if b[i][j]+7 != b[i+1][j]:
ans = False
print("Yes" if ans else "No")
n, m = map(int, input().split())
b = [list(map(int, input().split())) for i in range(n)]
ans = True
for i in range(m-1):
if b[0][i]+1 != b[0][i+1]:
ans = False
if b[0][i]%7 == 0:
ans = False
for i in range(n-1):
for j in range(m):
if b[i][j]+7 != b[i+1][j]:
ans = False
print("Yes" if ans else "No")
|
ConDefects/ConDefects/Code/abc225_c/Python/45041161
|
condefects-python_data_1023
|
n,m = map(int,input().split())
B = [list(map(int,input().split())) for _ in range(n)]
ok = True
for i in range(n):
for j in range(m):
if j+1 < m and B[i][j]+1 != B[i][j+1]:
ok = False
if i+1 < n and B[i][j]+7 != B[i+1][j]:
ok = False
if B[i][j]%7 == 0:
ok = False
print('Yes' if ok else 'No')
n,m = map(int,input().split())
B = [list(map(int,input().split())) for _ in range(n)]
ok = True
for i in range(n):
for j in range(m):
if j+1 < m and B[i][j]+1 != B[i][j+1]:
ok = False
if i+1 < n and B[i][j]+7 != B[i+1][j]:
ok = False
if B[i][j]%7 == 0 and j+1 != m:
ok = False
print('Yes' if ok else 'No')
|
ConDefects/ConDefects/Code/abc225_c/Python/44703471
|
condefects-python_data_1024
|
from collections import defaultdict
n, m = map(int, input().split())
b0 = list(map(int, input().split()))
ans = 'Yes'
for i in range(m-1):
if b0[i+1] - b0[i] != 1:
ans = 'No'
for i in range(n-1):
b = list(map(int, input().split()))
for i in range(m):
if b[i] - b0[i] != 7:
ans = 'No'
b0 = b
print(ans)
from collections import defaultdict
n, m = map(int, input().split())
b0 = list(map(int, input().split()))
ans = 'Yes'
for i in range(m-1):
if b0[i+1] - b0[i] != 1 or (b0[i]%7 == 0 and b0[i+1]%7 == 1):
ans = 'No'
for i in range(n-1):
b = list(map(int, input().split()))
for i in range(m):
if b[i] - b0[i] != 7:
ans = 'No'
b0 = b
print(ans)
|
ConDefects/ConDefects/Code/abc225_c/Python/44135956
|
condefects-python_data_1025
|
n,m = map(int,input().split())
A = [list(map(int,input().split())) for _ in range(n)]
start = A[0][0]
r = start- (start//7)*7
if r+m-1>7:
print("No")
exit()
else:
for i in range(n):
for j in range(m):
if A[i][j] != start+7*i+j:
print("No")
exit()
print("Yes")
n,m = map(int,input().split())
A = [list(map(int,input().split())) for _ in range(n)]
start = A[0][0]
r = start- (start//7)*7
if r == 0:
r = 7
if r+m-1>7:
print("No")
exit()
else:
for i in range(n):
for j in range(m):
if A[i][j] != start+7*i+j:
print("No")
exit()
print("Yes")
|
ConDefects/ConDefects/Code/abc225_c/Python/44853585
|
condefects-python_data_1026
|
N, M = map(int, input().split())
B = [ list(map(int, input().split())) for _ in range(N) ]
flag = True
lim = 10**100*7+7
j0 = (B[0][0]-1)%7
if j0 + M-1 >= 7:
flag = False
i0 = (B[0][0])//7
for i in range(N):
for j in range(M):
if B[i][j] != (i+i0)*7 + j + j0 +1 or B[i][j] > lim:
flag = False
if flag:
print("Yes")
else:
print("No")
N, M = map(int, input().split())
B = [ list(map(int, input().split())) for _ in range(N) ]
flag = True
lim = 10**100*7+7
j0 = (B[0][0]-1)%7
if j0 + M-1 >= 7:
flag = False
i0 = (B[0][0])//7
for i in range(N):
for j in range(M):
if B[i][j] != B[0][0] + i*7 + j or B[i][j] > lim:
flag = False
if flag:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc225_c/Python/44146392
|
condefects-python_data_1027
|
import sys
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline().rstrip()
def main():
N, M = map(int, input().split())
B = [list(map(int, input().split())) for _ in range(N)]
for i in range(N):
for j in range(M):
if B[i][j] % 7 > j + 1:
print("No")
return
T = [[0] * M for _ in range(N)]
start = B[0][0]
for i in range(N):
for j in range(M):
if i == 0 and j == 0:
T[0][0] = start
else:
T[i][j] = start + (i * 7) + j
if T == B:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
import sys
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline().rstrip()
def main():
N, M = map(int, input().split())
B = [list(map(int, input().split())) for _ in range(N)]
for i in range(N):
for j in range(M):
if B[i][j] % 7 == 0 and j != M - 1:
print("No")
return
T = [[0] * M for _ in range(N)]
start = B[0][0]
for i in range(N):
for j in range(M):
if i == 0 and j == 0:
T[0][0] = start
else:
T[i][j] = start + (i * 7) + j
if T == B:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc225_c/Python/45469943
|
condefects-python_data_1028
|
N, M = map(int, input().split())
B = [[int(i) for i in input().split()] for _ in range(N)]
flg = True
for i in range(N):
for j in range(M - 1):
if B[i][j] + 1 != B[i][j + 1]:
flg = False
if B[i][j] % 7 + 1 != B[i][j + 1] % 7:
flg = False
for j in range(M):
for i in range(N - 1):
if B[i][j] + 7 != B[i + 1][j]:
flg = False
if flg:
print('Yes')
else:
print('No')
N, M = map(int, input().split())
B = [[int(i) - 1 for i in input().split()] for _ in range(N)]
flg = True
for i in range(N):
for j in range(M - 1):
if B[i][j] + 1 != B[i][j + 1]:
flg = False
if B[i][j] % 7 + 1 != B[i][j + 1] % 7:
flg = False
for j in range(M):
for i in range(N - 1):
if B[i][j] + 7 != B[i + 1][j]:
flg = False
if flg:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc225_c/Python/44435353
|
condefects-python_data_1029
|
N,M = map(int,input().split())
ans = 'Yes'
B = []
for i in range(N):
b = list(map(int,input().split()))
for j in range(M-1):
if ((b[j+1] - 1) % 7) - ((b[j] - 1) % 7) != 1:
ans = 'No'
B.append(b)
for i in range(N-1):
if B[i+1][0] - B[i][0] != 7:
ans = 'No'
print(ans)
N,M = map(int,input().split())
ans = 'Yes'
B = []
for i in range(N):
b = list(map(int,input().split()))
for j in range(M-1):
if ((b[j+1] - 1) % 7) - ((b[j] - 1) % 7) != 1:
ans = 'No'
if b[j+1] - b[j] != 1:
ans = 'No'
B.append(b)
for i in range(N-1):
if B[i+1][0] - B[i][0] != 7:
ans = 'No'
print(ans)
|
ConDefects/ConDefects/Code/abc225_c/Python/44317781
|
condefects-python_data_1030
|
import sys
sys.setrecursionlimit(10 ** 7)
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.val = [0] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
t = self.parents[x]
self.val[x] = self.val[x] + self.val[t]
self.parents[x] = self.find(t)
return self.parents[x]
def union(self, x, y, d): #[x] = [y] + d
x2 = self.find(x)
y2 = self.find(y)
if x2 == y2:
return
if self.parents[x2] > self.parents[y2]:
x2, y2 = y2, x2
x,y = y,x
d *= -1
self.parents[x2] += self.parents[y2]
self.parents[y2] = x2
self.val[y2] = self.v(x) + d - self.v(y)
def v(self,x):
s = 0
while x >= 0:
s += self.val[x]
x = self.parents[x]
return s
n,q = map(int,input().split())
uf = UnionFind(n)
ans = []
for i in range(q):
a,b,d = map(int,input().split())
a -= 1
b -= 1
if uf.find(a) != uf.find(b):
uf.union(a,b,d)
ans.append(str(i + 1))
else:
if uf.v(b) - uf.v(a) == d:
ans.append(str(i + 1))
print(" ".join(ans))
import sys
sys.setrecursionlimit(10 ** 7)
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.val = [0] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
t = self.parents[x]
self.parents[x] = self.find(t)
self.val[x] = self.val[x] + self.val[t]
return self.parents[x]
def union(self, x, y, d): #[x] = [y] + d
x2 = self.find(x)
y2 = self.find(y)
if x2 == y2:
return
if self.parents[x2] > self.parents[y2]:
x2, y2 = y2, x2
x,y = y,x
d *= -1
self.parents[x2] += self.parents[y2]
self.parents[y2] = x2
self.val[y2] = self.v(x) + d - self.v(y)
def v(self,x):
s = 0
while x >= 0:
s += self.val[x]
x = self.parents[x]
return s
n,q = map(int,input().split())
uf = UnionFind(n)
ans = []
for i in range(q):
a,b,d = map(int,input().split())
a -= 1
b -= 1
if uf.find(a) != uf.find(b):
uf.union(a,b,d)
ans.append(str(i + 1))
else:
if uf.v(b) - uf.v(a) == d:
ans.append(str(i + 1))
print(" ".join(ans))
|
ConDefects/ConDefects/Code/abc328_f/Python/50086721
|
condefects-python_data_1031
|
S = input()
S = [ord(s)-ord('a') for s in S]
inf = 1<<30
MOD = 998244353
ans = 0
for i in range(1,len(S)-1):
s = S[:i]
t = S[i:]
ls = len(s)
lt = len(t)
ns = [[inf]*26 for _ in range(ls+1)]
nt = [[inf]*26 for _ in range(lt+1)]
for j in range(ls-1,-1,-1):
for k in range(26):
if s[j] == k:
ns[j][k] = j
else:
ns[j][k] = ns[j+1][k]
for j in range(lt-1,-1,-1):
for k in range(26):
if t[j] == k:
nt[j][k] = j
else:
nt[j][k] = nt[j+1][k]
dp = [[0]*(lt) for _ in range(ls)]
if ns[0][t[0]] != inf:
dp[ns[0][t[0]]][0] = 1
else:
continue
for j in range(ls):
for k in range(lt):
if ns[j+1][t[0]] == inf:
ans += dp[j][k]
ans %= MOD
for m in range(26):
if ns[j+1][m] != inf and nt[k+1][m] != inf:
dp[ns[j+1][m]][nt[k+1][m]] += dp[j][k]
dp[ns[j+1][m]][nt[k+1][m]] %= MOD
print(ans)
S = input()
S = [ord(s)-ord('a') for s in S]
inf = 1<<30
MOD = 998244353
ans = 0
for i in range(1,len(S)):
s = S[:i]
t = S[i:]
ls = len(s)
lt = len(t)
ns = [[inf]*26 for _ in range(ls+1)]
nt = [[inf]*26 for _ in range(lt+1)]
for j in range(ls-1,-1,-1):
for k in range(26):
if s[j] == k:
ns[j][k] = j
else:
ns[j][k] = ns[j+1][k]
for j in range(lt-1,-1,-1):
for k in range(26):
if t[j] == k:
nt[j][k] = j
else:
nt[j][k] = nt[j+1][k]
dp = [[0]*(lt) for _ in range(ls)]
if ns[0][t[0]] != inf:
dp[ns[0][t[0]]][0] = 1
else:
continue
for j in range(ls):
for k in range(lt):
if ns[j+1][t[0]] == inf:
ans += dp[j][k]
ans %= MOD
for m in range(26):
if ns[j+1][m] != inf and nt[k+1][m] != inf:
dp[ns[j+1][m]][nt[k+1][m]] += dp[j][k]
dp[ns[j+1][m]][nt[k+1][m]] %= MOD
print(ans)
|
ConDefects/ConDefects/Code/abc299_f/Python/41069355
|
condefects-python_data_1032
|
import sys
input = sys.stdin.readline
mod = 998244353
S = list(map(lambda c: ord(c)-ord('a'), input().rstrip()))
N = len(S)
ans = 0
for k in range(1, N): # beginning of the second T
l = -1
for i in range(k):
if S[i] == S[k]:
l = i
break
if l == -1:
continue
dp = [[0] * N for _ in range(k)]
last1 = [0] * 26
last1[S[l]] = l
dp[l][k] = 1
cumsum = [[0] * (N+1) for _ in range(k+1)]
for j in range(k+1, N+1):
cumsum[l+1][j] = 1
for i in range(l+1, k):
cumsum[i+1][k+1] = dp[i][k] + cumsum[i][k+1] + \
cumsum[i+1][k] - cumsum[i][k]
last2 = [0] * 26
last2[S[k]] = k
for j in range(k+1, N):
if S[i] == S[j]:
ii = last1[S[i]]
jj = last2[S[j]]
dp[i][j] = cumsum[i][j] - cumsum[ii][j] - \
cumsum[i][jj] + cumsum[ii][jj]
cumsum[i+1][j+1] = dp[i][j] + cumsum[i][j+1] + \
cumsum[i+1][j] - cumsum[i][j]
last2[S[j]] = j
last1[S[i]] = i
ans += cumsum[k][N] - cumsum[last1[S[k]]][N]
print(ans)
import sys
input = sys.stdin.readline
mod = 998244353
S = list(map(lambda c: ord(c)-ord('a'), input().rstrip()))
N = len(S)
ans = 0
for k in range(1, N): # beginning of the second T
l = -1
for i in range(k):
if S[i] == S[k]:
l = i
break
if l == -1:
continue
dp = [[0] * N for _ in range(k)]
last1 = [0] * 26
last1[S[l]] = l
dp[l][k] = 1
cumsum = [[0] * (N+1) for _ in range(k+1)]
for j in range(k+1, N+1):
cumsum[l+1][j] = 1
for i in range(l+1, k):
cumsum[i+1][k+1] = dp[i][k] + cumsum[i][k+1] + \
cumsum[i+1][k] - cumsum[i][k]
last2 = [0] * 26
last2[S[k]] = k
for j in range(k+1, N):
if S[i] == S[j]:
ii = last1[S[i]]
jj = last2[S[j]]
dp[i][j] = cumsum[i][j] - cumsum[ii][j] - \
cumsum[i][jj] + cumsum[ii][jj]
cumsum[i+1][j+1] = dp[i][j] + cumsum[i][j+1] + \
cumsum[i+1][j] - cumsum[i][j]
last2[S[j]] = j
last1[S[i]] = i
ans += cumsum[k][N] - cumsum[last1[S[k]]][N]
print(ans % mod)
|
ConDefects/ConDefects/Code/abc299_f/Python/40872561
|
condefects-python_data_1033
|
a, b = map(int, input().split())
print(round(b / a, 3))
a, b = map(int, input().split())
print("{:.3f}".format(round(b / a, 3)))
|
ConDefects/ConDefects/Code/abc274_a/Python/46147571
|
condefects-python_data_1034
|
from decimal import Decimal, ROUND_UP
a,b = map(int,input().split())
print(Decimal(str(b/a)).quantize(Decimal(10) ** -3,rounding=ROUND_UP))
from decimal import Decimal, ROUND_UP
a,b = map(int,input().split())
print(Decimal(str(b/a)).quantize(Decimal(10) ** -3))
|
ConDefects/ConDefects/Code/abc274_a/Python/45984868
|
condefects-python_data_1035
|
a, b = map(int, input().split())
print(f'{b/a:.08f}')
a, b = map(int, input().split())
print('{:.03f}'.format(round(b/a, 3)))
|
ConDefects/ConDefects/Code/abc274_a/Python/45757801
|
condefects-python_data_1036
|
A, B = map(int, input().split())
print(round(B/A, 3))
A, B = map(int, input().split())
print('{:.03f}'.format(round(B/A, 3)))
|
ConDefects/ConDefects/Code/abc274_a/Python/45467023
|
condefects-python_data_1037
|
a,b=map(int,input().split())
ans=(1000*b+5)//a/1000
print("{:.3f}".format(ans))
a,b=map(int,input().split())
ans=(1000*b+a/2)//a/1000
print("{:.3f}".format(ans))
|
ConDefects/ConDefects/Code/abc274_a/Python/44864361
|
condefects-python_data_1038
|
a, b = map(int,input().split())
s = b / a
print(f"{s:.3}")
a, b = map(int,input().split())
s = b / a
print(f"{s:.3f}")
|
ConDefects/ConDefects/Code/abc274_a/Python/46127383
|
condefects-python_data_1039
|
n=int(input())
S=input()
dp=["2"]*(n+1)
Q=[[] for _ in range(n)]
for l in range(n):
i=0
for r in range(l,min(l+200,n)):
s=S[l:r+1]
while dp[i]<s:
i+=1
Q[r].append((i,s))
for i,s in Q[l]:
dp[i]=min(dp[i],s)
Q[l].clear()
print(dp.index("2"))
n=int(input())
S=input()
dp=["2"]*(n+1)
Q=[[] for _ in range(n)]
for l in range(n):
i=0
for r in range(l,min(l+224,n)):
s=S[l:r+1]
while dp[i]<s:
i+=1
Q[r].append((i,s))
for i,s in Q[l]:
dp[i]=min(dp[i],s)
Q[l].clear()
print(dp.index("2"))
|
ConDefects/ConDefects/Code/abc240_h/Python/29809348
|
condefects-python_data_1040
|
import time
from typing import Generic, Iterable, Iterator, TypeVar, Optional, List
from array import array
from bisect import bisect_left, bisect_right, insort
import collections
import copy
import heapq
import itertools
import decimal
from decimal import Decimal
import math
import string
import sys
sys.setrecursionlimit(10**6)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def LII(H): return [list(map(int, sys.stdin.readline().rstrip().split())) for _ in range(H)]
def ST(): return sys.stdin.readline().rstrip()
def SS(H): return [ST() for _ in range(H)]
def LS(): return list(sys.stdin.readline().rstrip().split())
def ARRAY(L): return array("i", L)
INF = (1 << 63)-1
DIFF = 10 ** -9
DX = [1, 0, -1, 0, 1, 1, -1, -1]
DY = [0, 1, 0, -1, 1, -1, 1, -1]
MOD = 998244353
# 累積和 ans=list(itertools.accumulate(L))
# 順列 ans=list(itertools.permutation(L))
# 直積 ans=list(itertools.product(L,M))
# 重複なし組み合わせ ans=list(itertools.combinations(L,2))
# 重複あり組み合わせ ans=list(itertools.combinations_with_replacement(L,2))
# nCr ans=math.comb(n,r)
# 日付を比較, date1 < date2ならTrue, O(1)
def compare_date(date1, date2):
# date = "2019/04/30"
formatted_date1 = time.strptime(date1, "%Y/%m/%d")
formatted_date2 = time.strptime(date2, "%Y/%m/%d")
return formatted_date1 < formatted_date2
# 四捨五入
def half_up(x):
return Decimal(x).quantize(Decimal('1'), rounding=decimal.ROUND_HALF_UP)
# 切り上げ
def ceiling(x):
return Decimal(x).quantize(Decimal('0.1'), rounding=decimal.ROUND_CEILING)
# 切り捨て
def floor(x):
return Decimal(x).quantize(Decimal('0.1'), rounding=decimal.ROUND_FLOOR)
# Nまでの数を素数かどうか判定（エラトステネスのふるい）
def prime_judge(n: int):
is_prime = [True] * (n + 1)
is_prime[0], is_prime[1] = False, False
for i in range(2, int(math.sqrt(n)) + 1):
if is_prime[i]:
for j in range(2 * i, n + 1, i):
is_prime[j] = False
return is_prime
# 素因数分解
def prime_factorization(N: int):
arr = []
sqrt = int(math.sqrt(N))
for i in range(2, sqrt+1):
if N % i == 0:
cnt = 0
while N % i == 0:
cnt += 1
N //= i
arr.append([i, cnt])
if N != 1:
arr.append([N, 1])
return arr
# 1文字ずつ文字列をずらしたときの最長共通接頭辞の長さ
def z_algorithm(S: string):
n = len(S)
rtn = [-1]*n
rtn[0] = n
i, j = 1, 0
while i < len(S):
while i+j < len(S) and S[j] == S[i+j]:
j += 1
rtn[i] = j
if j == 0:
i += 1
k = 1
while i+k < len(S) and k+rtn[k] < j:
rtn[i+k] = rtn[k]
k += 1
i += k
j -= k
return rtn
# Nまでの積をxで何回割り切れるか
def divide_num(N: int, x: int):
rtn = 0
i = 1
while pow(x, i) <= N:
rtn += N//pow(x, i)
i += 1
return rtn
# 拡張ユークリッド互除法
def xgcd(a, b):
x0, y0, x1, y1 = 1, 0, 0, 1
while b != 0:
q, a, b = a//b, b, a % b
x0, x1 = x1, x0-q*x1
y0, y1 = y1, y0-q*y1
return a, x0, y0
# 逆元を求める
def modinv(a, mod=MOD):
g, x, y = xgcd(a, mod)
if g != 1:
raise Exception("moduler inverse does not exist")
else:
return x % mod
# combinationの逆元を求める
def combination_modinv(n, r, mod=MOD):
if n < 0 or r < 0 or n < r:
return 0
fact = [1]*(n+2)
fact_inv = [1]*(n+2)
for i in range(1, n+2):
fact[i] = (fact[i-1]*i) % mod
fact_inv[n+1] = pow(fact[n+1], mod-2, mod)
for i in range(n, -1, -1):
fact_inv[i] = (fact_inv[i+1]*(i+1)) % mod
return (fact[n]*fact_inv[r] % mod)*fact_inv[n-r] % mod
class BIT:
# 長さN+1の配列を初期化
def __init__(self, N):
self.size = N
self.bit = [0]*(N+1)
# i番目までの和を求める
def sum(self, i):
res = 0
while i > 0:
res += self.bit[i] # フェニック木のi番目の値を加算
i -= -i & i # 最も右にある1の桁を0にする
return res
# i番目の値にxを足して更新する
def add(self, i, x):
while i <= self.size:
self.bit[i] += x # フェニック木のi番目にxを足して更新
i += -i & i # 最も右にある1の桁に1を足す
# N mod p = a, N mod q = b
# px + a = qy + b
# px - qy = b-a
# px = 1 mod q
def crp(a, p, b, q):
x = pow(p, -1, q)
x *= b-a
x %= q
return p*x + a
def Dijkstra(edges, num_node):
""" 経路の表現
[終点, 辺の値]
A, B, C, D, ... → 0, 1, 2, ...とする """
node = [float('inf')] * num_node # スタート地点以外の値は∞で初期化
node[0] = 0 # スタートは0で初期化
node_name = [i for i in range(num_node)] # ノードの名前を0~ノードの数で表す
while len(node_name) > 0:
r = node_name[0]
# 最もコストが小さい頂点を探す
for i in node_name:
if node[i] < node[r]:
r = i # コストが小さい頂点が見つかると更新
# 最もコストが小さい頂点を取り出す
min_point = node_name.pop(node_name.index(r))
# 経路の要素を各変数に格納することで，視覚的に見やすくする
for factor in edges[min_point]:
goal = factor[0] # 終点
cost = factor[1] # コスト
# 更新条件
if node[min_point] + cost < node[goal]:
node[goal] = node[min_point] + cost # 更新
return node
# 行きがけ、帰りがけの順番を取得
def EulerTour(n, graph, root):
"""
(n: int, graph: List[List[int]], root: int) -> Tuple[List[int], List[int], List[int]]:
:param n: the number of vertex points
:param graph: 2D matrix of N vertices given by the edges
:param root: start node index
:return tour: order of visited vertex
:return in_time: first visiting time of each vertex
:return out_time: last visiting time of each vertex
example:
graph = [[] for _ in range(n)]
for _ in range(n):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
tour, in_time, out_time = EulerTour(n, graph, 0)
"""
parent = [-1] * n
stack = [~root, root] # postorder, preorder
curr_time = -1
tour = []
in_time = [-1] * n
out_time = [-1] * n
while stack:
curr_node = stack.pop()
curr_time += 1
if curr_node >= 0: # preorder
tour.append(curr_node)
if in_time[curr_node] == -1:
in_time[curr_node] = curr_time
for next_node in graph[curr_node]:
if next_node != parent[curr_node]:
parent[next_node] = curr_node
stack.append(~next_node)
stack.append(next_node)
elif curr_node < 0: # postorder
out_time[~curr_node] = curr_time
if parent[~curr_node] != -1:
tour.append(parent[~curr_node])
return tour, in_time, out_time
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = collections.defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
def make_kmp_table(t):
i = 2
j = 0
m = len(t)
tbl = [0] * (m + 1)
tbl[0] = -1
while i <= m:
if t[i - 1] == t[j]:
tbl[i] = j + 1
i += 1
j += 1
elif j > 0:
j = tbl[j]
else:
tbl[i] = 0
i += 1
return tbl
# 文字列Sの中に文字列Tが存在するかどうか
def kmp(s, t):
matched_indices = []
tbl = make_kmp_table(t)
i = 0
j = 0
n = len(s)
m = len(t)
while i + j < n:
if t[j] == s[i + j]:
j += 1
if j == m:
matched_indices.append(i)
i += j - tbl[j]
j = tbl[j]
else:
i += j - tbl[j]
if j > 0:
j = tbl[j]
return matched_indices
# 強連結成分分解
class SCC:
def __init__(self, n):
self.n = n
self.graph = [[] for _ in range(n)]
self.rev_graph = [[] for _ in range(n)]
self.labels = [-1] * n
self.lb_cnt = 0
def add_edge(self, v, nxt_v):
self.graph[v].append(nxt_v)
self.rev_graph[nxt_v].append(v)
def build(self):
self.post_order = []
self.used = [False] * self.n
for v in range(self.n):
if not self.used[v]:
self._dfs(v)
for v in reversed(self.post_order):
if self.labels[v] == -1:
self._rev_dfs(v)
self.lb_cnt += 1
def _dfs(self, v):
stack = [v, 0]
while stack:
v, idx = stack[-2:]
if not idx and self.used[v]:
stack.pop()
stack.pop()
else:
self.used[v] = True
if idx < len(self.graph[v]):
stack[-1] += 1
stack.append(self.graph[v][idx])
stack.append(0)
else:
stack.pop()
self.post_order.append(stack.pop())
def _rev_dfs(self, v):
stack = [v]
self.labels[v] = self.lb_cnt
while stack:
v = stack.pop()
for nxt_v in self.rev_graph[v]:
if self.labels[nxt_v] != -1:
continue
stack.append(nxt_v)
self.labels[nxt_v] = self.lb_cnt
def construct(self):
self.dag = [[] for i in range(self.lb_cnt)]
self.groups = [[] for i in range(self.lb_cnt)]
for v, lb in enumerate(self.labels):
for nxt_v in self.graph[v]:
nxt_lb = self.labels[nxt_v]
if lb == nxt_lb:
continue
self.dag[lb].append(nxt_lb)
self.groups[lb].append(v)
return self.dag, self.groups
class SegTree:
""" 点代入/区間総和
操作 segfunc 単位元
最小値 min(x, y) float('inf')
最大値 max(x, y) -float('inf')
区間和 x + y 0
区間積 x * y 1
最大公約数 math.gcd(x, y) 0
segfunc : 和の計算がデフォ、最小値・最大値などのモノイドに置換
add : k番目の値にxを加算
update : k番目の値をxに更新
query : 区間[l,r)のseg_funcモノイドの結果を出力
"""
def __init__(self, init_val: list, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
self.num = 1 << (n-1).bit_length()
self.tree = [ide_ele]*2*self.num
for i in range(n):
self.tree[self.num+i] = init_val[i]
for i in range(self.num-1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def segfunc(self, x, y):
return x+y
def add(self, k, x):
k += self.num
self.tree[k] += x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r-1])
l >>= 1
r >>= 1
return res
class LazySegTree_RAQ:
""" 区間代入/区間総和
seg_func : 和の計算がデフォ、最小値・最大値などのモノイドに置換
add : 区間[l,r)の値にxを加算
query : 区間[l,r)のseg_funcモノイドの結果を出力
"""
def __init__(self, init_val, segfunc=None, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
if segfunc is not None:
self.segfunc = segfunc
self.num = 1 << (n-1).bit_length()
self.tree = [ide_ele]*2*self.num
self.lazy = [0]*2*self.num
for i in range(n):
self.tree[self.num+i] = init_val[i]
for i in range(self.num-1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def segfunc(x, y):
return x+y
def gindex(self, l, r):
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
for i in reversed(ids):
v = self.lazy[i]
if v == 0:
continue
self.lazy[i] = 0
self.lazy[2*i] += v
self.lazy[2*i+1] += v
self.tree[2*i] += v
self.tree[2*i+1] += v
def add(self, l, r, x):
ids = self.gindex(l, r)
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] += x
self.tree[l] += x
l += 1
if r & 1:
self.lazy[r-1] += x
self.tree[r-1] += x
r >>= 1
l >>= 1
for i in ids:
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1]) + self.lazy[i]
def query(self, l, r):
self.propagates(*self.gindex(l, r))
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r-1])
l >>= 1
r >>= 1
return res
class LazySegTree_RUQ:
""" 区間代入/区間総和
seg_func : 和の計算がデフォ、最小値・最大値などのモノイドに置換
update : 区間[l,r)の値をxに加算
query : 区間[l,r)のseg_funcモノイドの結果を出力
"""
def __init__(self, init_val: list, segfunc=None, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
self.num = 1 << (n-1).bit_length()
if segfunc is not None:
self.segfunc = segfunc
self.tree = [ide_ele]*2*self.num
self.lazy = [None]*2*self.num
for i in range(n):
self.tree[self.num+i] = init_val[i]
for i in range(self.num-1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def segfunc(x, y):
return min(x, y)
def gindex(self, l, r):
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
for i in reversed(ids):
v = self.lazy[i]
if v is None:
continue
self.lazy[i] = None
self.lazy[2*i] = v
self.lazy[2*i+1] = v
self.tree[2*i] = v
self.tree[2*i+1] = v
def update(self, l, r, x):
ids = self.gindex(l, r)
self.propagates(*self.gindex(l, r))
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] = x
self.tree[l] = x
l += 1
if r & 1:
self.lazy[r-1] = x
self.tree[r-1] = x
r >>= 1
l >>= 1
for i in ids:
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def query(self, l, r):
ids = self.gindex(l, r)
self.propagates(*self.gindex(l, r))
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r-1])
l >>= 1
r >>= 1
return res
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]:
return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
return False
a.pop(i)
self.size -= 1
if len(a) == 0:
self._build()
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0:
x += self.size
if x < 0:
raise IndexError
for a in self.a:
if x < len(a):
return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(a)
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]:
return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a = self._find_bucket(x)
insort(a, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
return False
a.pop(i)
self.size -= 1
if len(a) == 0:
self._build()
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0:
x += self.size
if x < 0:
raise IndexError
for a in self.a:
if x < len(a):
return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# 配列の転倒数を求める（o(NlogN)）
def inversion_num(L: list):
max_N = max(L)
bit = BIT(max_N)
cnt = 0
for i, l in enumerate(L):
cnt += i-bit.sum(l)
bit.add(l, 1)
return cnt
# 約数列挙
def make_divisors(n):
lower_divisors, upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
# Nまでの素数列挙
# 計算量 O(logN)
def prime_list(N):
H = [False] * (N + 1)
primes = []
for i in range(2, N + 1):
if H[i]:
continue
primes.append(i)
for j in range(i, N + 1, i):
H[j] = True
return primes
class ModInt:
def __init__(self, x, mod=998244353):
self.x = x % mod
self.mod = mod
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x*other.x) if isinstance(other, ModInt) else
ModInt(self.x*other)
)
def __truediv__(self, other):
return (
ModInt(
self.x*pow(other.x, self.mod-2, self.mod)
) if isinstance(other, ModInt) else
ModInt(self.x*pow(other, self.mod-2, self.mod))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, self.mod)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, self.mod))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x-self.x) if isinstance(other, ModInt) else
ModInt(other-self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, self.mod-2, self.mod)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, self.mod-2, self.mod))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, self.mod)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, self.mod))
)
class FFT():
def primitive_root_constexpr(self, m):
if m == 2:
return 1
if m == 167772161:
return 3
if m == 469762049:
return 3
if m == 754974721:
return 11
if m == 998244353:
return 3
divs = [0]*20
divs[0] = 2
cnt = 1
x = (m-1)//2
while (x % 2 == 0):
x //= 2
i = 3
while (i*i <= x):
if (x % i == 0):
divs[cnt] = i
cnt += 1
while (x % i == 0):
x //= i
i += 2
if x > 1:
divs[cnt] = x
cnt += 1
g = 2
while (1):
ok = True
for i in range(cnt):
if pow(g, (m-1)//divs[i], m) == 1:
ok = False
break
if ok:
return g
g += 1
def bsf(self, x):
res = 0
while (x % 2 == 0):
res += 1
x //= 2
return res
rank2 = 0
root = []
iroot = []
rate2 = []
irate2 = []
rate3 = []
irate3 = []
def __init__(self, MOD):
self.mod = MOD
self.g = self.primitive_root_constexpr(self.mod)
self.rank2 = self.bsf(self.mod-1)
self.root = [0 for i in range(self.rank2+1)]
self.iroot = [0 for i in range(self.rank2+1)]
self.rate2 = [0 for i in range(self.rank2)]
self.irate2 = [0 for i in range(self.rank2)]
self.rate3 = [0 for i in range(self.rank2-1)]
self.irate3 = [0 for i in range(self.rank2-1)]
self.root[self.rank2] = pow(self.g, (self.mod-1) >> self.rank2, self.mod)
self.iroot[self.rank2] = pow(self.root[self.rank2], self.mod-2, self.mod)
for i in range(self.rank2-1, -1, -1):
self.root[i] = (self.root[i+1]**2) % self.mod
self.iroot[i] = (self.iroot[i+1]**2) % self.mod
prod = 1
iprod = 1
for i in range(self.rank2-1):
self.rate2[i] = (self.root[i+2]*prod) % self.mod
self.irate2[i] = (self.iroot[i+2]*iprod) % self.mod
prod = (prod*self.iroot[i+2]) % self.mod
iprod = (iprod*self.root[i+2]) % self.mod
prod = 1
iprod = 1
for i in range(self.rank2-2):
self.rate3[i] = (self.root[i+3]*prod) % self.mod
self.irate3[i] = (self.iroot[i+3]*iprod) % self.mod
prod = (prod*self.iroot[i+3]) % self.mod
iprod = (iprod*self.root[i+3]) % self.mod
def butterfly(self, a):
n = len(a)
h = (n-1).bit_length()
LEN = 0
while (LEN < h):
if (h-LEN == 1):
p = 1 << (h-LEN-1)
rot = 1
for s in range(1 << LEN):
offset = s << (h-LEN)
for i in range(p):
l = a[i+offset]
r = a[i+offset+p]*rot
a[i+offset] = (l+r) % self.mod
a[i+offset+p] = (l-r) % self.mod
rot *= self.rate2[(~s & -~s).bit_length()-1]
rot %= self.mod
LEN += 1
else:
p = 1 << (h-LEN-2)
rot = 1
imag = self.root[2]
for s in range(1 << LEN):
rot2 = (rot*rot) % self.mod
rot3 = (rot2*rot) % self.mod
offset = s << (h-LEN)
for i in range(p):
a0 = a[i+offset]
a1 = a[i+offset+p]*rot
a2 = a[i+offset+2*p]*rot2
a3 = a[i+offset+3*p]*rot3
a1na3imag = (a1-a3) % self.mod*imag
a[i+offset] = (a0+a2+a1+a3) % self.mod
a[i+offset+p] = (a0+a2-a1-a3) % self.mod
a[i+offset+2*p] = (a0-a2+a1na3imag) % self.mod
a[i+offset+3*p] = (a0-a2-a1na3imag) % self.mod
rot *= self.rate3[(~s & -~s).bit_length()-1]
rot %= self.mod
LEN += 2
def butterfly_inv(self, a):
n = len(a)
h = (n-1).bit_length()
LEN = h
while (LEN):
if (LEN == 1):
p = 1 << (h-LEN)
irot = 1
for s in range(1 << (LEN-1)):
offset = s << (h-LEN+1)
for i in range(p):
l = a[i+offset]
r = a[i+offset+p]
a[i+offset] = (l+r) % self.mod
a[i+offset+p] = (l-r)*irot % self.mod
irot *= self.irate2[(~s & -~s).bit_length()-1]
irot %= self.mod
LEN -= 1
else:
p = 1 << (h-LEN)
irot = 1
iimag = self.iroot[2]
for s in range(1 << (LEN-2)):
irot2 = (irot*irot) % self.mod
irot3 = (irot*irot2) % self.mod
offset = s << (h-LEN+2)
for i in range(p):
a0 = a[i+offset]
a1 = a[i+offset+p]
a2 = a[i+offset+2*p]
a3 = a[i+offset+3*p]
a2na3iimag = (a2-a3)*iimag % self.mod
a[i+offset] = (a0+a1+a2+a3) % self.mod
a[i+offset+p] = (a0-a1+a2na3iimag)*irot % self.mod
a[i+offset+2*p] = (a0+a1-a2-a3)*irot2 % self.mod
a[i+offset+3*p] = (a0-a1-a2na3iimag)*irot3 % self.mod
irot *= self.irate3[(~s & -~s).bit_length()-1]
irot %= self.mod
LEN -= 2
def convolution(self, a, b):
n = len(a)
m = len(b)
if not (a) or not (b):
return []
if min(n, m) <= 40:
res = [0]*(n+m-1)
for i in range(n):
for j in range(m):
res[i+j] += a[i]*b[j]
res[i+j] %= self.mod
return res
z = 1 << ((n+m-2).bit_length())
a = a+[0]*(z-n)
b = b+[0]*(z-m)
self.butterfly(a)
self.butterfly(b)
c = [(a[i]*b[i]) % self.mod for i in range(z)]
self.butterfly_inv(c)
iz = pow(z, self.mod-2, self.mod)
for i in range(n+m-1):
c[i] = (c[i]*iz) % self.mod
return c[:n+m-1]
class mf_graph:
n = 1
g = [[] for i in range(1)]
pos = []
def __init__(self, N):
self.n = N
self.g = [[] for i in range(N)]
self.pos = []
def add_edge(self, From, To, cap):
assert 0 <= From and From < self.n
assert 0 <= To and To < self.n
assert 0 <= cap
m = len(self.pos)
from_id = len(self.g[From])
self.pos.append([From, from_id])
to_id = len(self.g[To])
if From == To:
to_id += 1
self.g[From].append([To, to_id, cap])
self.g[To].append([From, from_id, 0])
return m
def get_edge(self, i):
m = len(self.pos)
assert 0 <= i and i < m
_e = self.g[self.pos[i][0]][self.pos[i][1]]
_re = self.g[_e[0]][_e[1]]
return [self.pos[i][0], _e[0], _e[2]+_re[2], _re[2]]
def edges(self):
m = len(self.pos)
result = []
for i in range(m):
a, b, c, d = self.get_edge(i)
result.append({"from": a, "to": b, "cap": c, "flow": d})
return result
def change_edge(self, i, new_cap, new_flow):
m = len(self.pos)
assert 0 <= i and i < m
assert 0 <= new_flow and new_flow <= new_cap
_e = self.g[self.pos[i][0]][self.pos[i][1]]
_re = self.g[_e[0]][_e[1]]
_e[2] = new_cap-new_flow
_re[2] = new_flow
def flow(self, s, t, flow_limit=(1 << 63)-1):
assert 0 <= s and s < self.n
assert 0 <= t and t < self.n
assert s != t
def bfs():
level = [-1 for i in range(self.n)]
level[s] = 0
que = collections.deque([])
que.append(s)
while (que):
v = que.popleft()
for to, rev, cap in self.g[v]:
if cap == 0 or level[to] >= 0:
continue
level[to] = level[v]+1
if to == t:
return level
que.append(to)
return level
def dfs(v, up):
if (v == s):
return up
res = 0
level_v = level[v]
for i in range(Iter[v], len(self.g[v])):
Iter[v] = i
to, rev, cap = self.g[v][i]
if (level_v <= level[to] or self.g[to][rev][2] == 0):
continue
d = dfs(to, min(up-res, self.g[to][rev][2]))
if d <= 0:
continue
self.g[v][i][2] += d
self.g[to][rev][2] -= d
res += d
if res == up:
return res
level[v] = self.n
return res
flow = 0
while (flow < flow_limit):
level = bfs()
if level[t] == -1:
break
Iter = [0 for i in range(self.n)]
f = dfs(t, flow_limit-flow)
if not (f):
break
flow += f
return flow
def min_cut(self, s):
visited = [False for i in range(self.n)]
que = collections.deque([])
que.append(s)
while (len(que) > 0):
p = que.popleft()
visited[p] = True
for to, rev, cap in self.g[p]:
if cap and not (visited[to]):
visited[to] = True
que.append(to)
return visited
# 最長増加部分列（LIS）
def lis(L: list):
dp = [float('inf')]*len(L)
for l in L:
dp[bisect_left(dp, l)] = l
return bisect_left(dp, float('inf'))
# Floor Sum
def floor_sum(n, m, a, b):
ret = 0
while n > 0 and m > 0:
ret += (a // m) * n * (n-1) // 2 + (b // m) * n
a, b = a % m, b % m
last = a * n + b
n, m, a, b = last // m, a, m, last % m
return ret
def main():
sx,sy,tx,ty,ux,uy=map(int,input().split())
# 平行移動と反転により、目的地を原点、荷物を第一象限にする
sx-=ux
sy-=uy
tx-=ux
ty-=uy
if tx<0:
sx*=-1
tx*=-1
if ty<0:
sy*=-1
ty*=-1
def push_down(sx,sy,tx,ty):
# 高橋君が(sx,sy),荷物が(tx,ty)にあるとき、荷物を(tx,0)に移動するまでの最小行動回数と、移動後の高橋君の座標、荷物の座標を返す
# ty==0なら何もしない
if ty==0:
return 0, sx,sy, tx,ty
# (tx,ty+1)に行く
step=abs(sx-tx)+abs(sy-(ty+1))
# 荷物を迂回する必要があるなら+2
if sx==tx and sy<ty:
step+=2
# 下に押す
return step+ty, tx,1, tx,0
ans=[]
for _ in range(2):
# 荷物を下→左の順に押す
# 荷物を下に押す
step1,a,b,c,d=push_down(sx,sy,tx,ty)
# 軸を入れ替えることで左に押すことを下に押すことに帰着
step2,*_=push_down(b,a,d,c)
ans.append(step1+step2)
# 軸を入れ替えることで左→下のケースを下→左に帰着
sx,sy=sy,sx
tx,ty=ty,tx
print(min(ans))
if __name__ == "__main__":
main()
import time
from typing import Generic, Iterable, Iterator, TypeVar, Optional, List
from array import array
from bisect import bisect_left, bisect_right, insort
import collections
import copy
import heapq
import itertools
import decimal
from decimal import Decimal
import math
import string
import sys
sys.setrecursionlimit(10**6)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int, sys.stdin.readline().rstrip().split())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def LII(H): return [list(map(int, sys.stdin.readline().rstrip().split())) for _ in range(H)]
def ST(): return sys.stdin.readline().rstrip()
def SS(H): return [ST() for _ in range(H)]
def LS(): return list(sys.stdin.readline().rstrip().split())
def ARRAY(L): return array("i", L)
INF = (1 << 63)-1
DIFF = 10 ** -9
DX = [1, 0, -1, 0, 1, 1, -1, -1]
DY = [0, 1, 0, -1, 1, -1, 1, -1]
MOD = 998244353
# 累積和 ans=list(itertools.accumulate(L))
# 順列 ans=list(itertools.permutation(L))
# 直積 ans=list(itertools.product(L,M))
# 重複なし組み合わせ ans=list(itertools.combinations(L,2))
# 重複あり組み合わせ ans=list(itertools.combinations_with_replacement(L,2))
# nCr ans=math.comb(n,r)
# 日付を比較, date1 < date2ならTrue, O(1)
def compare_date(date1, date2):
# date = "2019/04/30"
formatted_date1 = time.strptime(date1, "%Y/%m/%d")
formatted_date2 = time.strptime(date2, "%Y/%m/%d")
return formatted_date1 < formatted_date2
# 四捨五入
def half_up(x):
return Decimal(x).quantize(Decimal('1'), rounding=decimal.ROUND_HALF_UP)
# 切り上げ
def ceiling(x):
return Decimal(x).quantize(Decimal('0.1'), rounding=decimal.ROUND_CEILING)
# 切り捨て
def floor(x):
return Decimal(x).quantize(Decimal('0.1'), rounding=decimal.ROUND_FLOOR)
# Nまでの数を素数かどうか判定（エラトステネスのふるい）
def prime_judge(n: int):
is_prime = [True] * (n + 1)
is_prime[0], is_prime[1] = False, False
for i in range(2, int(math.sqrt(n)) + 1):
if is_prime[i]:
for j in range(2 * i, n + 1, i):
is_prime[j] = False
return is_prime
# 素因数分解
def prime_factorization(N: int):
arr = []
sqrt = int(math.sqrt(N))
for i in range(2, sqrt+1):
if N % i == 0:
cnt = 0
while N % i == 0:
cnt += 1
N //= i
arr.append([i, cnt])
if N != 1:
arr.append([N, 1])
return arr
# 1文字ずつ文字列をずらしたときの最長共通接頭辞の長さ
def z_algorithm(S: string):
n = len(S)
rtn = [-1]*n
rtn[0] = n
i, j = 1, 0
while i < len(S):
while i+j < len(S) and S[j] == S[i+j]:
j += 1
rtn[i] = j
if j == 0:
i += 1
k = 1
while i+k < len(S) and k+rtn[k] < j:
rtn[i+k] = rtn[k]
k += 1
i += k
j -= k
return rtn
# Nまでの積をxで何回割り切れるか
def divide_num(N: int, x: int):
rtn = 0
i = 1
while pow(x, i) <= N:
rtn += N//pow(x, i)
i += 1
return rtn
# 拡張ユークリッド互除法
def xgcd(a, b):
x0, y0, x1, y1 = 1, 0, 0, 1
while b != 0:
q, a, b = a//b, b, a % b
x0, x1 = x1, x0-q*x1
y0, y1 = y1, y0-q*y1
return a, x0, y0
# 逆元を求める
def modinv(a, mod=MOD):
g, x, y = xgcd(a, mod)
if g != 1:
raise Exception("moduler inverse does not exist")
else:
return x % mod
# combinationの逆元を求める
def combination_modinv(n, r, mod=MOD):
if n < 0 or r < 0 or n < r:
return 0
fact = [1]*(n+2)
fact_inv = [1]*(n+2)
for i in range(1, n+2):
fact[i] = (fact[i-1]*i) % mod
fact_inv[n+1] = pow(fact[n+1], mod-2, mod)
for i in range(n, -1, -1):
fact_inv[i] = (fact_inv[i+1]*(i+1)) % mod
return (fact[n]*fact_inv[r] % mod)*fact_inv[n-r] % mod
class BIT:
# 長さN+1の配列を初期化
def __init__(self, N):
self.size = N
self.bit = [0]*(N+1)
# i番目までの和を求める
def sum(self, i):
res = 0
while i > 0:
res += self.bit[i] # フェニック木のi番目の値を加算
i -= -i & i # 最も右にある1の桁を0にする
return res
# i番目の値にxを足して更新する
def add(self, i, x):
while i <= self.size:
self.bit[i] += x # フェニック木のi番目にxを足して更新
i += -i & i # 最も右にある1の桁に1を足す
# N mod p = a, N mod q = b
# px + a = qy + b
# px - qy = b-a
# px = 1 mod q
def crp(a, p, b, q):
x = pow(p, -1, q)
x *= b-a
x %= q
return p*x + a
def Dijkstra(edges, num_node):
""" 経路の表現
[終点, 辺の値]
A, B, C, D, ... → 0, 1, 2, ...とする """
node = [float('inf')] * num_node # スタート地点以外の値は∞で初期化
node[0] = 0 # スタートは0で初期化
node_name = [i for i in range(num_node)] # ノードの名前を0~ノードの数で表す
while len(node_name) > 0:
r = node_name[0]
# 最もコストが小さい頂点を探す
for i in node_name:
if node[i] < node[r]:
r = i # コストが小さい頂点が見つかると更新
# 最もコストが小さい頂点を取り出す
min_point = node_name.pop(node_name.index(r))
# 経路の要素を各変数に格納することで，視覚的に見やすくする
for factor in edges[min_point]:
goal = factor[0] # 終点
cost = factor[1] # コスト
# 更新条件
if node[min_point] + cost < node[goal]:
node[goal] = node[min_point] + cost # 更新
return node
# 行きがけ、帰りがけの順番を取得
def EulerTour(n, graph, root):
"""
(n: int, graph: List[List[int]], root: int) -> Tuple[List[int], List[int], List[int]]:
:param n: the number of vertex points
:param graph: 2D matrix of N vertices given by the edges
:param root: start node index
:return tour: order of visited vertex
:return in_time: first visiting time of each vertex
:return out_time: last visiting time of each vertex
example:
graph = [[] for _ in range(n)]
for _ in range(n):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
tour, in_time, out_time = EulerTour(n, graph, 0)
"""
parent = [-1] * n
stack = [~root, root] # postorder, preorder
curr_time = -1
tour = []
in_time = [-1] * n
out_time = [-1] * n
while stack:
curr_node = stack.pop()
curr_time += 1
if curr_node >= 0: # preorder
tour.append(curr_node)
if in_time[curr_node] == -1:
in_time[curr_node] = curr_time
for next_node in graph[curr_node]:
if next_node != parent[curr_node]:
parent[next_node] = curr_node
stack.append(~next_node)
stack.append(next_node)
elif curr_node < 0: # postorder
out_time[~curr_node] = curr_time
if parent[~curr_node] != -1:
tour.append(parent[~curr_node])
return tour, in_time, out_time
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = collections.defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
def make_kmp_table(t):
i = 2
j = 0
m = len(t)
tbl = [0] * (m + 1)
tbl[0] = -1
while i <= m:
if t[i - 1] == t[j]:
tbl[i] = j + 1
i += 1
j += 1
elif j > 0:
j = tbl[j]
else:
tbl[i] = 0
i += 1
return tbl
# 文字列Sの中に文字列Tが存在するかどうか
def kmp(s, t):
matched_indices = []
tbl = make_kmp_table(t)
i = 0
j = 0
n = len(s)
m = len(t)
while i + j < n:
if t[j] == s[i + j]:
j += 1
if j == m:
matched_indices.append(i)
i += j - tbl[j]
j = tbl[j]
else:
i += j - tbl[j]
if j > 0:
j = tbl[j]
return matched_indices
# 強連結成分分解
class SCC:
def __init__(self, n):
self.n = n
self.graph = [[] for _ in range(n)]
self.rev_graph = [[] for _ in range(n)]
self.labels = [-1] * n
self.lb_cnt = 0
def add_edge(self, v, nxt_v):
self.graph[v].append(nxt_v)
self.rev_graph[nxt_v].append(v)
def build(self):
self.post_order = []
self.used = [False] * self.n
for v in range(self.n):
if not self.used[v]:
self._dfs(v)
for v in reversed(self.post_order):
if self.labels[v] == -1:
self._rev_dfs(v)
self.lb_cnt += 1
def _dfs(self, v):
stack = [v, 0]
while stack:
v, idx = stack[-2:]
if not idx and self.used[v]:
stack.pop()
stack.pop()
else:
self.used[v] = True
if idx < len(self.graph[v]):
stack[-1] += 1
stack.append(self.graph[v][idx])
stack.append(0)
else:
stack.pop()
self.post_order.append(stack.pop())
def _rev_dfs(self, v):
stack = [v]
self.labels[v] = self.lb_cnt
while stack:
v = stack.pop()
for nxt_v in self.rev_graph[v]:
if self.labels[nxt_v] != -1:
continue
stack.append(nxt_v)
self.labels[nxt_v] = self.lb_cnt
def construct(self):
self.dag = [[] for i in range(self.lb_cnt)]
self.groups = [[] for i in range(self.lb_cnt)]
for v, lb in enumerate(self.labels):
for nxt_v in self.graph[v]:
nxt_lb = self.labels[nxt_v]
if lb == nxt_lb:
continue
self.dag[lb].append(nxt_lb)
self.groups[lb].append(v)
return self.dag, self.groups
class SegTree:
""" 点代入/区間総和
操作 segfunc 単位元
最小値 min(x, y) float('inf')
最大値 max(x, y) -float('inf')
区間和 x + y 0
区間積 x * y 1
最大公約数 math.gcd(x, y) 0
segfunc : 和の計算がデフォ、最小値・最大値などのモノイドに置換
add : k番目の値にxを加算
update : k番目の値をxに更新
query : 区間[l,r)のseg_funcモノイドの結果を出力
"""
def __init__(self, init_val: list, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
self.num = 1 << (n-1).bit_length()
self.tree = [ide_ele]*2*self.num
for i in range(n):
self.tree[self.num+i] = init_val[i]
for i in range(self.num-1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def segfunc(self, x, y):
return x+y
def add(self, k, x):
k += self.num
self.tree[k] += x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r-1])
l >>= 1
r >>= 1
return res
class LazySegTree_RAQ:
""" 区間代入/区間総和
seg_func : 和の計算がデフォ、最小値・最大値などのモノイドに置換
add : 区間[l,r)の値にxを加算
query : 区間[l,r)のseg_funcモノイドの結果を出力
"""
def __init__(self, init_val, segfunc=None, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
if segfunc is not None:
self.segfunc = segfunc
self.num = 1 << (n-1).bit_length()
self.tree = [ide_ele]*2*self.num
self.lazy = [0]*2*self.num
for i in range(n):
self.tree[self.num+i] = init_val[i]
for i in range(self.num-1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def segfunc(x, y):
return x+y
def gindex(self, l, r):
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
for i in reversed(ids):
v = self.lazy[i]
if v == 0:
continue
self.lazy[i] = 0
self.lazy[2*i] += v
self.lazy[2*i+1] += v
self.tree[2*i] += v
self.tree[2*i+1] += v
def add(self, l, r, x):
ids = self.gindex(l, r)
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] += x
self.tree[l] += x
l += 1
if r & 1:
self.lazy[r-1] += x
self.tree[r-1] += x
r >>= 1
l >>= 1
for i in ids:
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1]) + self.lazy[i]
def query(self, l, r):
self.propagates(*self.gindex(l, r))
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r-1])
l >>= 1
r >>= 1
return res
class LazySegTree_RUQ:
""" 区間代入/区間総和
seg_func : 和の計算がデフォ、最小値・最大値などのモノイドに置換
update : 区間[l,r)の値をxに加算
query : 区間[l,r)のseg_funcモノイドの結果を出力
"""
def __init__(self, init_val: list, segfunc=None, ide_ele: int = 0):
n = len(init_val)
self.ide_ele = ide_ele
self.num = 1 << (n-1).bit_length()
if segfunc is not None:
self.segfunc = segfunc
self.tree = [ide_ele]*2*self.num
self.lazy = [None]*2*self.num
for i in range(n):
self.tree[self.num+i] = init_val[i]
for i in range(self.num-1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def segfunc(x, y):
return min(x, y)
def gindex(self, l, r):
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
for i in reversed(ids):
v = self.lazy[i]
if v is None:
continue
self.lazy[i] = None
self.lazy[2*i] = v
self.lazy[2*i+1] = v
self.tree[2*i] = v
self.tree[2*i+1] = v
def update(self, l, r, x):
ids = self.gindex(l, r)
self.propagates(*self.gindex(l, r))
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] = x
self.tree[l] = x
l += 1
if r & 1:
self.lazy[r-1] = x
self.tree[r-1] = x
r >>= 1
l >>= 1
for i in ids:
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def query(self, l, r):
ids = self.gindex(l, r)
self.propagates(*self.gindex(l, r))
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r-1])
l >>= 1
r >>= 1
return res
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]:
return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
return False
a.pop(i)
self.size -= 1
if len(a) == 0:
self._build()
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0:
x += self.size
if x < 0:
raise IndexError
for a in self.a:
if x < len(a):
return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(a)
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]:
return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a = self._find_bucket(x)
insort(a, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
return False
a.pop(i)
self.size -= 1
if len(a) == 0:
self._build()
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0:
x += self.size
if x < 0:
raise IndexError
for a in self.a:
if x < len(a):
return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# 配列の転倒数を求める（o(NlogN)）
def inversion_num(L: list):
max_N = max(L)
bit = BIT(max_N)
cnt = 0
for i, l in enumerate(L):
cnt += i-bit.sum(l)
bit.add(l, 1)
return cnt
# 約数列挙
def make_divisors(n):
lower_divisors, upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
# Nまでの素数列挙
# 計算量 O(logN)
def prime_list(N):
H = [False] * (N + 1)
primes = []
for i in range(2, N + 1):
if H[i]:
continue
primes.append(i)
for j in range(i, N + 1, i):
H[j] = True
return primes
class ModInt:
def __init__(self, x, mod=998244353):
self.x = x % mod
self.mod = mod
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x*other.x) if isinstance(other, ModInt) else
ModInt(self.x*other)
)
def __truediv__(self, other):
return (
ModInt(
self.x*pow(other.x, self.mod-2, self.mod)
) if isinstance(other, ModInt) else
ModInt(self.x*pow(other, self.mod-2, self.mod))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, self.mod)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, self.mod))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x-self.x) if isinstance(other, ModInt) else
ModInt(other-self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, self.mod-2, self.mod)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, self.mod-2, self.mod))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, self.mod)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, self.mod))
)
class FFT():
def primitive_root_constexpr(self, m):
if m == 2:
return 1
if m == 167772161:
return 3
if m == 469762049:
return 3
if m == 754974721:
return 11
if m == 998244353:
return 3
divs = [0]*20
divs[0] = 2
cnt = 1
x = (m-1)//2
while (x % 2 == 0):
x //= 2
i = 3
while (i*i <= x):
if (x % i == 0):
divs[cnt] = i
cnt += 1
while (x % i == 0):
x //= i
i += 2
if x > 1:
divs[cnt] = x
cnt += 1
g = 2
while (1):
ok = True
for i in range(cnt):
if pow(g, (m-1)//divs[i], m) == 1:
ok = False
break
if ok:
return g
g += 1
def bsf(self, x):
res = 0
while (x % 2 == 0):
res += 1
x //= 2
return res
rank2 = 0
root = []
iroot = []
rate2 = []
irate2 = []
rate3 = []
irate3 = []
def __init__(self, MOD):
self.mod = MOD
self.g = self.primitive_root_constexpr(self.mod)
self.rank2 = self.bsf(self.mod-1)
self.root = [0 for i in range(self.rank2+1)]
self.iroot = [0 for i in range(self.rank2+1)]
self.rate2 = [0 for i in range(self.rank2)]
self.irate2 = [0 for i in range(self.rank2)]
self.rate3 = [0 for i in range(self.rank2-1)]
self.irate3 = [0 for i in range(self.rank2-1)]
self.root[self.rank2] = pow(self.g, (self.mod-1) >> self.rank2, self.mod)
self.iroot[self.rank2] = pow(self.root[self.rank2], self.mod-2, self.mod)
for i in range(self.rank2-1, -1, -1):
self.root[i] = (self.root[i+1]**2) % self.mod
self.iroot[i] = (self.iroot[i+1]**2) % self.mod
prod = 1
iprod = 1
for i in range(self.rank2-1):
self.rate2[i] = (self.root[i+2]*prod) % self.mod
self.irate2[i] = (self.iroot[i+2]*iprod) % self.mod
prod = (prod*self.iroot[i+2]) % self.mod
iprod = (iprod*self.root[i+2]) % self.mod
prod = 1
iprod = 1
for i in range(self.rank2-2):
self.rate3[i] = (self.root[i+3]*prod) % self.mod
self.irate3[i] = (self.iroot[i+3]*iprod) % self.mod
prod = (prod*self.iroot[i+3]) % self.mod
iprod = (iprod*self.root[i+3]) % self.mod
def butterfly(self, a):
n = len(a)
h = (n-1).bit_length()
LEN = 0
while (LEN < h):
if (h-LEN == 1):
p = 1 << (h-LEN-1)
rot = 1
for s in range(1 << LEN):
offset = s << (h-LEN)
for i in range(p):
l = a[i+offset]
r = a[i+offset+p]*rot
a[i+offset] = (l+r) % self.mod
a[i+offset+p] = (l-r) % self.mod
rot *= self.rate2[(~s & -~s).bit_length()-1]
rot %= self.mod
LEN += 1
else:
p = 1 << (h-LEN-2)
rot = 1
imag = self.root[2]
for s in range(1 << LEN):
rot2 = (rot*rot) % self.mod
rot3 = (rot2*rot) % self.mod
offset = s << (h-LEN)
for i in range(p):
a0 = a[i+offset]
a1 = a[i+offset+p]*rot
a2 = a[i+offset+2*p]*rot2
a3 = a[i+offset+3*p]*rot3
a1na3imag = (a1-a3) % self.mod*imag
a[i+offset] = (a0+a2+a1+a3) % self.mod
a[i+offset+p] = (a0+a2-a1-a3) % self.mod
a[i+offset+2*p] = (a0-a2+a1na3imag) % self.mod
a[i+offset+3*p] = (a0-a2-a1na3imag) % self.mod
rot *= self.rate3[(~s & -~s).bit_length()-1]
rot %= self.mod
LEN += 2
def butterfly_inv(self, a):
n = len(a)
h = (n-1).bit_length()
LEN = h
while (LEN):
if (LEN == 1):
p = 1 << (h-LEN)
irot = 1
for s in range(1 << (LEN-1)):
offset = s << (h-LEN+1)
for i in range(p):
l = a[i+offset]
r = a[i+offset+p]
a[i+offset] = (l+r) % self.mod
a[i+offset+p] = (l-r)*irot % self.mod
irot *= self.irate2[(~s & -~s).bit_length()-1]
irot %= self.mod
LEN -= 1
else:
p = 1 << (h-LEN)
irot = 1
iimag = self.iroot[2]
for s in range(1 << (LEN-2)):
irot2 = (irot*irot) % self.mod
irot3 = (irot*irot2) % self.mod
offset = s << (h-LEN+2)
for i in range(p):
a0 = a[i+offset]
a1 = a[i+offset+p]
a2 = a[i+offset+2*p]
a3 = a[i+offset+3*p]
a2na3iimag = (a2-a3)*iimag % self.mod
a[i+offset] = (a0+a1+a2+a3) % self.mod
a[i+offset+p] = (a0-a1+a2na3iimag)*irot % self.mod
a[i+offset+2*p] = (a0+a1-a2-a3)*irot2 % self.mod
a[i+offset+3*p] = (a0-a1-a2na3iimag)*irot3 % self.mod
irot *= self.irate3[(~s & -~s).bit_length()-1]
irot %= self.mod
LEN -= 2
def convolution(self, a, b):
n = len(a)
m = len(b)
if not (a) or not (b):
return []
if min(n, m) <= 40:
res = [0]*(n+m-1)
for i in range(n):
for j in range(m):
res[i+j] += a[i]*b[j]
res[i+j] %= self.mod
return res
z = 1 << ((n+m-2).bit_length())
a = a+[0]*(z-n)
b = b+[0]*(z-m)
self.butterfly(a)
self.butterfly(b)
c = [(a[i]*b[i]) % self.mod for i in range(z)]
self.butterfly_inv(c)
iz = pow(z, self.mod-2, self.mod)
for i in range(n+m-1):
c[i] = (c[i]*iz) % self.mod
return c[:n+m-1]
class mf_graph:
n = 1
g = [[] for i in range(1)]
pos = []
def __init__(self, N):
self.n = N
self.g = [[] for i in range(N)]
self.pos = []
def add_edge(self, From, To, cap):
assert 0 <= From and From < self.n
assert 0 <= To and To < self.n
assert 0 <= cap
m = len(self.pos)
from_id = len(self.g[From])
self.pos.append([From, from_id])
to_id = len(self.g[To])
if From == To:
to_id += 1
self.g[From].append([To, to_id, cap])
self.g[To].append([From, from_id, 0])
return m
def get_edge(self, i):
m = len(self.pos)
assert 0 <= i and i < m
_e = self.g[self.pos[i][0]][self.pos[i][1]]
_re = self.g[_e[0]][_e[1]]
return [self.pos[i][0], _e[0], _e[2]+_re[2], _re[2]]
def edges(self):
m = len(self.pos)
result = []
for i in range(m):
a, b, c, d = self.get_edge(i)
result.append({"from": a, "to": b, "cap": c, "flow": d})
return result
def change_edge(self, i, new_cap, new_flow):
m = len(self.pos)
assert 0 <= i and i < m
assert 0 <= new_flow and new_flow <= new_cap
_e = self.g[self.pos[i][0]][self.pos[i][1]]
_re = self.g[_e[0]][_e[1]]
_e[2] = new_cap-new_flow
_re[2] = new_flow
def flow(self, s, t, flow_limit=(1 << 63)-1):
assert 0 <= s and s < self.n
assert 0 <= t and t < self.n
assert s != t
def bfs():
level = [-1 for i in range(self.n)]
level[s] = 0
que = collections.deque([])
que.append(s)
while (que):
v = que.popleft()
for to, rev, cap in self.g[v]:
if cap == 0 or level[to] >= 0:
continue
level[to] = level[v]+1
if to == t:
return level
que.append(to)
return level
def dfs(v, up):
if (v == s):
return up
res = 0
level_v = level[v]
for i in range(Iter[v], len(self.g[v])):
Iter[v] = i
to, rev, cap = self.g[v][i]
if (level_v <= level[to] or self.g[to][rev][2] == 0):
continue
d = dfs(to, min(up-res, self.g[to][rev][2]))
if d <= 0:
continue
self.g[v][i][2] += d
self.g[to][rev][2] -= d
res += d
if res == up:
return res
level[v] = self.n
return res
flow = 0
while (flow < flow_limit):
level = bfs()
if level[t] == -1:
break
Iter = [0 for i in range(self.n)]
f = dfs(t, flow_limit-flow)
if not (f):
break
flow += f
return flow
def min_cut(self, s):
visited = [False for i in range(self.n)]
que = collections.deque([])
que.append(s)
while (len(que) > 0):
p = que.popleft()
visited[p] = True
for to, rev, cap in self.g[p]:
if cap and not (visited[to]):
visited[to] = True
que.append(to)
return visited
# 最長増加部分列（LIS）
def lis(L: list):
dp = [float('inf')]*len(L)
for l in L:
dp[bisect_left(dp, l)] = l
return bisect_left(dp, float('inf'))
# Floor Sum
def floor_sum(n, m, a, b):
ret = 0
while n > 0 and m > 0:
ret += (a // m) * n * (n-1) // 2 + (b // m) * n
a, b = a % m, b % m
last = a * n + b
n, m, a, b = last // m, a, m, last % m
return ret
def main():
sx,sy,tx,ty,ux,uy=map(int,input().split())
# 平行移動と反転により、目的地を原点、荷物を第一象限にする
sx-=ux
sy-=uy
tx-=ux
ty-=uy
if tx<0:
sx*=-1
tx*=-1
if ty<0:
sy*=-1
ty*=-1
def push_down(sx,sy,tx,ty):
# 高橋君が(sx,sy),荷物が(tx,ty)にあるとき、荷物を(tx,0)に移動するまでの最小行動回数と、移動後の高橋君の座標、荷物の座標を返す
# ty==0なら何もしない
if ty==0:
return 0, sx,sy, tx,ty
# (tx,ty+1)に行く
step=abs(sx-tx)+abs(sy-(ty+1))
# 荷物を迂回する必要があるなら+2
if sx==tx and sy<ty:
step+=2
# 下に押す
return step+ty, tx,1, tx,0
ans=[]
for _ in range(2):
# 荷物を下→左の順に押す
# 荷物を下に押す
step1,a,b,c,d=push_down(sx,sy,tx,ty)
# 軸を入れ替えることで左に押すことを下に押すことに帰着
step2,*_=push_down(b,a,d,c)
ans.append(step1+step2)
# 軸を入れ替えることで左→下のケースを下→左に帰着
sx,sy=sy,sx
tx,ty=ty,tx
print(min(ans))
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc323_f/Python/50030718
|
condefects-python_data_1041
|
def push_down(sx, sy, tx, ty):
times = abs(tx - sx) + abs(ty + 1 - sy) + ty
if sx == tx and sy < ty:
times += 2
return times, tx, 1, tx, 0
sx, sy, tx, ty, gx, gy = map(int, input().split())
sx -= gx
sy -= gy
tx -= gx
ty -= gy
if tx < 0:
tx *= -1
sx *= -1
if ty < 0:
ty *= -1
sy *= -1
ans = []
for _ in range(2):
times_1, sx_2, sy_2, tx_2, ty_2 = push_down(sx, sy, tx, ty)
times_2, *_ = push_down(sy_2, sx_2, ty_2, tx_2)
ans.append(times_1 + times_2)
sx, sy, tx, ty = sy, sx, ty, tx
print(min(ans))
def push_down(sx, sy, tx, ty):
if ty == 0:
return 0, sx, sy, tx, ty
times = abs(tx - sx) + abs(ty + 1 - sy) + ty
if sx == tx and sy < ty:
times += 2
return times, tx, 1, tx, 0
sx, sy, tx, ty, gx, gy = map(int, input().split())
sx -= gx
sy -= gy
tx -= gx
ty -= gy
if tx < 0:
tx *= -1
sx *= -1
if ty < 0:
ty *= -1
sy *= -1
ans = []
for _ in range(2):
times_1, sx_2, sy_2, tx_2, ty_2 = push_down(sx, sy, tx, ty)
times_2, *_ = push_down(sy_2, sx_2, ty_2, tx_2)
ans.append(times_1 + times_2)
sx, sy, tx, ty = sy, sx, ty, tx
print(min(ans))
|
ConDefects/ConDefects/Code/abc323_f/Python/53065562
|
condefects-python_data_1042
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
def II(): return int(input())
def MI(): return map(int,input().split())
def LM(): return list(MI())
def LL(n): return [LM() for _ in range(n)]
def LS(n,remove_br=False): return [list(input())[:-1] if remove_br else list(input()) for _ in range(n)]
def MI_1(): return map(lambda x:int(x)-1,input().split())
def LM_1(): return list(MI_1())
def LL_1(n): return [LM_1() for _ in range(n)]
def bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
# clockwise from top.
DIRECTION_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIRECTION_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
MOD = 998244353
INF = float("inf")
def DB(*x):
global DEBUG_MODE
if DEBUG_MODE: print(*x)
############
DEBUG_MODE=1
############
def rot(x,y): return (-y,x)
ax,ay,bx,by,cx,cy = MI()
ppl = (ax-bx,ay-by)
goal = (cx-bx,cy-by)
while not (goal[0] > 0 and goal[1] >= 0):
ppl = rot(*ppl)
goal = rot(*goal)
x,y = ppl
h,w = goal
if h == 0:
if x>0 and y==0:
print(x+3+w)
else:
print(abs(x+1)+abs(y)+w)
elif w == 0:
if y>0 and x==0:
print(y+3+w)
else:
print(abs(x)+abs(y+1)+h)
elif y<0:
print(abs(x)+abs(y+1)+h+w+2)
elif x<0:
print(abs(x+1)+abs(y)+h+w+2)
else:
print(abs(x)+abs(y)+1+h+w+2)
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
def II(): return int(input())
def MI(): return map(int,input().split())
def LM(): return list(MI())
def LL(n): return [LM() for _ in range(n)]
def LS(n,remove_br=False): return [list(input())[:-1] if remove_br else list(input()) for _ in range(n)]
def MI_1(): return map(lambda x:int(x)-1,input().split())
def LM_1(): return list(MI_1())
def LL_1(n): return [LM_1() for _ in range(n)]
def bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
# clockwise from top.
DIRECTION_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIRECTION_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
MOD = 998244353
INF = float("inf")
def DB(*x):
global DEBUG_MODE
if DEBUG_MODE: print(*x)
############
DEBUG_MODE=1
############
def rot(x,y): return (-y,x)
ax,ay,bx,by,cx,cy = MI()
ppl = (ax-bx,ay-by)
goal = (cx-bx,cy-by)
while not (goal[0] > 0 and goal[1] >= 0):
ppl = rot(*ppl)
goal = rot(*goal)
x,y = ppl
w,h = goal
if h == 0:
if x>0 and y==0:
print(x+3+w)
else:
print(abs(x+1)+abs(y)+w)
elif w == 0:
if y>0 and x==0:
print(y+3+w)
else:
print(abs(x)+abs(y+1)+h)
elif y<0:
print(abs(x)+abs(y+1)+h+w+2)
elif x<0:
print(abs(x+1)+abs(y)+h+w+2)
else:
print(abs(x)+abs(y)+1+h+w+2)
|
ConDefects/ConDefects/Code/abc323_f/Python/50223990
|
condefects-python_data_1043
|
# +-----------+--------------------------------------------------------------+
# | main | |
# +-----------+--------------------------------------------------------------+
def main():
XA, YA, XB, YB, XC, YC = map(int, input().split())
XB -= XA
XC -= XA
XA = 0
YB -= YA
YC -= YA
YA = 0
if XC < XB:
XC *= -1
XB *= -1
if YC < YB:
YC *= -1
YB *= -1
__print(XB, YB, XC, YC, XB < XC, YB < YC)
ans = abs(XC - XB) + abs(YC - YB) + abs(XB - XA) + abs(YB - YA) - 1
if XB < 0:
if XB < XC:
ans += 2
if YB == 0:
ans += 2
elif YB < 0 and YB < YC:
ans += 2
elif XB == XA:
if YB < 0 and YB < YC:
ans += 4
elif XB < XC:
ans += 2
else:
# ここに問題がある
if YB == YC:
pass
elif YB < YC:
if XB == XC:
if YB == 0:
ans += 2
else:
ans += 2
print(ans)
# +-----------+--------------------------------------------------------------+
# | library | See Also : https://github.com/nodashin6/atcoder |
# +-----------+--------------------------------------------------------------+
# +-----------+--------------------------------------------------------------+
# | other | |
# +-----------+--------------------------------------------------------------+
import sys
input = lambda: sys.stdin.readline().rstrip()
__print = lambda *args, **kwargs: print(*args, **kwargs) if __debug else None
if __name__ == '__main__':
# for test on local PC
try:
__file = open('./input.txt')
input = lambda: __file.readline().rstrip()
__debug = True
except:
__debug = False
main()
# +-----------+--------------------------------------------------------------+
# | main | |
# +-----------+--------------------------------------------------------------+
def main():
XA, YA, XB, YB, XC, YC = map(int, input().split())
XB -= XA
XC -= XA
XA = 0
YB -= YA
YC -= YA
YA = 0
if XC < XB:
XC *= -1
XB *= -1
if YC < YB:
YC *= -1
YB *= -1
__print(XB, YB, XC, YC, XB < XC, YB < YC)
ans = abs(XC - XB) + abs(YC - YB) + abs(XB - XA) + abs(YB - YA) - 1
if XB < 0:
if XB < XC:
ans += 2
if YB == 0:
ans += 2
elif YB < 0 and YB < YC:
ans += 2
elif XB == XA:
if YB < 0 and YB < YC:
ans += 4
elif XB < XC:
ans += 2
else:
# ここに問題がある
if YB == YC:
pass
elif YB < YC:
if XB == XC:
if YB <= 0:
ans += 2
else:
ans += 2
print(ans)
# +-----------+--------------------------------------------------------------+
# | library | See Also : https://github.com/nodashin6/atcoder |
# +-----------+--------------------------------------------------------------+
# +-----------+--------------------------------------------------------------+
# | other | |
# +-----------+--------------------------------------------------------------+
import sys
input = lambda: sys.stdin.readline().rstrip()
__print = lambda *args, **kwargs: print(*args, **kwargs) if __debug else None
if __name__ == '__main__':
# for test on local PC
try:
__file = open('./input.txt')
input = lambda: __file.readline().rstrip()
__debug = True
except:
__debug = False
main()
|
ConDefects/ConDefects/Code/abc323_f/Python/50628101
|
condefects-python_data_1044
|
from io import BytesIO, IOBase
import os
from random import getrandbits, randrange
from string import ascii_lowercase, ascii_uppercase
import sys
from math import ceil, floor, sqrt, pi, factorial, gcd, log, log10, log2, inf, cos, sin
from copy import deepcopy, copy
from collections import Counter, deque, defaultdict
from heapq import heapify, heappop, heappush
from itertools import (
accumulate,
product,
combinations,
combinations_with_replacement,
permutations,
)
from bisect import bisect, bisect_left, bisect_right
from functools import lru_cache, reduce
from decimal import Decimal, getcontext
from typing import List, Tuple, Optional
inf = float("inf")
def ceil_div(a, b):
return (a + b - 1) // b
def isqrt(x):
return int(sqrt(x))
def int1(s):
return int(s) - 1
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input():
return sys.stdin.readline().rstrip("\r\n")
print = lambda *args, end="\n", sep=" ": sys.stdout.write(
sep.join(map(str, args)) + end
)
def yes(res):
return print("Yes" if res else "No")
def YES(res):
return print("YES" if res else "NO")
class Debug:
def __init__(self, debug=False):
self.debug = debug
def get_ic(self):
if self.debug:
from icecream import ic
return ic
else:
return lambda *args, **kwargs: ...
def pairwise(a):
n = len(a)
for i in range(n - 1):
yield a[i], a[i + 1]
def factorial(n):
return reduce(lambda x, y: x * y, range(1, n + 1))
ic = Debug(False).get_ic()
def solve(N: int, L: int, W: int, a: "List[int]"):
pre = 0
a.append(L)
res = 0
for ai in a:
if ai > pre + 1:
res += ceil_div(ai - pre, W)
pre = ai + W
return res
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens))
L = int(next(tokens))
W = int(next(tokens))
a = [int(next(tokens)) for _ in range(N)]
print(solve(N, L, W, a))
if __name__ == "__main__":
main()
from io import BytesIO, IOBase
import os
from random import getrandbits, randrange
from string import ascii_lowercase, ascii_uppercase
import sys
from math import ceil, floor, sqrt, pi, factorial, gcd, log, log10, log2, inf, cos, sin
from copy import deepcopy, copy
from collections import Counter, deque, defaultdict
from heapq import heapify, heappop, heappush
from itertools import (
accumulate,
product,
combinations,
combinations_with_replacement,
permutations,
)
from bisect import bisect, bisect_left, bisect_right
from functools import lru_cache, reduce
from decimal import Decimal, getcontext
from typing import List, Tuple, Optional
inf = float("inf")
def ceil_div(a, b):
return (a + b - 1) // b
def isqrt(x):
return int(sqrt(x))
def int1(s):
return int(s) - 1
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input():
return sys.stdin.readline().rstrip("\r\n")
print = lambda *args, end="\n", sep=" ": sys.stdout.write(
sep.join(map(str, args)) + end
)
def yes(res):
return print("Yes" if res else "No")
def YES(res):
return print("YES" if res else "NO")
class Debug:
def __init__(self, debug=False):
self.debug = debug
def get_ic(self):
if self.debug:
from icecream import ic
return ic
else:
return lambda *args, **kwargs: ...
def pairwise(a):
n = len(a)
for i in range(n - 1):
yield a[i], a[i + 1]
def factorial(n):
return reduce(lambda x, y: x * y, range(1, n + 1))
ic = Debug(False).get_ic()
def solve(N: int, L: int, W: int, a: "List[int]"):
pre = 0
a.append(L)
res = 0
for ai in a:
if ai > pre:
res += ceil_div(ai - pre, W)
pre = ai + W
return res
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens))
L = int(next(tokens))
W = int(next(tokens))
a = [int(next(tokens)) for _ in range(N)]
print(solve(N, L, W, a))
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/arc134_a/Python/45479683
|
condefects-python_data_1045
|
import sys
sys.setrecursionlimit(10**9)
from collections import defaultdict
from collections import deque
import heapq
import math
import bisect
import itertools
def MI():return map(int,input().split())
def II():return int(input())
N,L,W=MI()
A=list(MI())
A.append(L+1)
now=0
ans=0
for a in A:
if now<a:
k=(a-now)//W+((a-now)%W>0)
ans+=k
now=a+W
print(ans)
import sys
sys.setrecursionlimit(10**9)
from collections import defaultdict
from collections import deque
import heapq
import math
import bisect
import itertools
def MI():return map(int,input().split())
def II():return int(input())
N,L,W=MI()
A=list(MI())
A.append(L)
now=0
ans=0
for a in A:
if now<a:
k=(a-now)//W+((a-now)%W>0)
ans+=k
now=a+W
print(ans)
|
ConDefects/ConDefects/Code/arc134_a/Python/43954461
|
condefects-python_data_1046
|
n,l,w=map(int,input().split())
a=list(map(int,input().split()))
tmp=0
ans=0
for i in a:
ans+=max(0,(i-tmp+w-1)//w)
tmp=i+l
ans+=max(0,(l-tmp+w-1)//w)
print (ans)
n,l,w=map(int,input().split())
a=list(map(int,input().split()))
tmp=0
ans=0
for i in a:
ans+=max(0,(i-tmp+w-1)//w)
tmp=i+w
ans+=max(0,(l-tmp+w-1)//w)
print (ans)
|
ConDefects/ConDefects/Code/arc134_a/Python/45282634
|
condefects-python_data_1047
|
import sys
readline = sys.stdin.readline
n,m = map(int,readline().split())
g = [[] for _ in range(n)]
for _ in range(m):
a,b = map(int,readline().split())
g[a-1].append(b-1)
g[b-1].append(a-1)
dist = [-1]*n
dp = [0]*n
dist[0] = 0
dp[0] = 1
MOD = 998244353
num = 1 # dist = d-1 となる点の個数
val = 1 # dist = d-1 となる点への最短路の個数の合計
for d in range(1,452):
newnum = newval = 0
for i in range(n):
if dist[i] != -1: continue
nn = num
vv = val
for v in g[i]:
if dist[v] == d-1:
nn -= 1
vv -= dp[v]
if nn:
dist[i] = d
dp[i] = vv%MOD
newnum += 1
newval += vv
if newnum == 0:
break
num = newnum
val = newval%MOD
#print(dist)
#print(dp)
print(-1 if dist[-1] == -1 else dp[-1])
import sys
readline = sys.stdin.readline
n,m = map(int,readline().split())
g = [[] for _ in range(n)]
for _ in range(m):
a,b = map(int,readline().split())
g[a-1].append(b-1)
g[b-1].append(a-1)
dist = [-1]*n
dp = [0]*n
dist[0] = 0
dp[0] = 1
MOD = 998244353
num = 1 # dist = d-1 となる点の個数
val = 1 # dist = d-1 となる点への最短路の個数の合計
for d in range(1,1000):
newnum = newval = 0
for i in range(n):
if dist[i] != -1: continue
nn = num
vv = val
for v in g[i]:
if dist[v] == d-1:
nn -= 1
vv -= dp[v]
if nn:
dist[i] = d
dp[i] = vv%MOD
newnum += 1
newval += vv
if newnum == 0:
break
num = newnum
val = newval%MOD
#print(dist)
#print(dp)
print(-1 if dist[-1] == -1 else dp[-1])
|
ConDefects/ConDefects/Code/abc319_g/Python/46211313
|
condefects-python_data_1048
|
N, M = map(int, input().split())
ans = [N] * N
for i in map(int, input().split()):
ans[i-1] = 0
for i in range(N-2, 0, -1):
ans[i-1] = min(ans[i-1], ans[i]+1)
print('\n'.join(map(str, ans)))
N, M = map(int, input().split())
ans = [N] * N
for i in map(int, input().split()):
ans[i-1] = 0
for i in range(N-1, 0, -1):
ans[i-1] = min(ans[i-1], ans[i]+1)
print('\n'.join(map(str, ans)))
|
ConDefects/ConDefects/Code/abc322_c/Python/46201794
|
condefects-python_data_1049
|
import collections
n = int(input())
a = list(map(int, input().split()))
c = collections.Counter(a)
cnt = 0
for v in c.values():
if v == 2:
cnt += (n-1)*v*(v-1)//2 * (n-2)
if v >= 3:
cnt += v*(v-1)*(v-2)//6
cnt += (n-v)*v*(v-1)//2
ans = n*(n-1)*(n-2)//6 - cnt
print(ans)
import collections
n = int(input())
a = list(map(int, input().split()))
c = collections.Counter(a)
cnt = 0
for v in c.values():
if v == 2:
cnt += (n-2)*v*(v-1)//2
if v >= 3:
cnt += v*(v-1)*(v-2)//6
cnt += (n-v)*v*(v-1)//2
ans = n*(n-1)*(n-2)//6 - cnt
print(ans)
|
ConDefects/ConDefects/Code/abc252_d/Python/45257814
|
condefects-python_data_1050
|
N = int(input())
A = list(map(int,input().split()))
B=[]
for i in range(1000000):
B.append(0)
for i in A:
B[i]+=1
ans = N*(N-1)*(N-2)/6
for i in B:
ans -= i*(i-1)/2*(N-i)
ans -= i*(i-1)*(i-2)/6
print(ans)
N = int(input())
A = list(map(int,input().split()))
B=[]
for i in range(1000000):
B.append(0)
for i in A:
B[i]+=1
ans = N*(N-1)*(N-2)/6
for i in B:
ans -= i*(i-1)/2*(N-i)
ans -= i*(i-1)*(i-2)/6
print(int(ans))
|
ConDefects/ConDefects/Code/abc252_d/Python/45497724
|
condefects-python_data_1051
|
from sortedcontainers import SortedList
import math
n=int(input())
s=input()
sl=[0]*10
for i in range(n):
sl[int(s[i])]+=1
max=math.ceil(math.sqrt(10**n))
ans=0
for i in range(1,max):
ii=str(i*i)
now=[0]*10
for j in ii:
now[int(j)]+=1
now[0]+=n-len(ii)
# print(now)
if now==sl:
ans+=1
print(ans)
from sortedcontainers import SortedList
import math
n=int(input())
s=input()
sl=[0]*10
for i in range(n):
sl[int(s[i])]+=1
max=math.ceil(math.sqrt(10**n))
ans=0
for i in range(max):
ii=str(i*i)
now=[0]*10
for j in ii:
now[int(j)]+=1
now[0]+=n-len(ii)
# print(now)
if now==sl:
ans+=1
print(ans)
|
ConDefects/ConDefects/Code/abc324_d/Python/54149573
|
condefects-python_data_1052
|
from math import isqrt
n = int(input())
s = input()
S = [int(s[i]) for i in range(n)]
S.sort(reverse=True)
max_perfect = 10**n
ans = 0
i = 1
while i**2 < max_perfect:
st = str(i**2)
j = [int(z) for z in str(i**2)]
j.sort(reverse=True)
if len(j) < n:
j += [0]*(n-len(j))
if S == j:
ans += 1
i+=1
print(ans)
from math import isqrt
n = int(input())
s = input()
S = [int(s[i]) for i in range(n)]
S.sort(reverse=True)
max_perfect = 10**n
ans = 0
i = 0
while i**2 < max_perfect:
st = str(i**2)
j = [int(z) for z in str(i**2)]
j.sort(reverse=True)
if len(j) < n:
j += [0]*(n-len(j))
if S == j:
ans += 1
i+=1
print(ans)
|
ConDefects/ConDefects/Code/abc324_d/Python/54743756
|
condefects-python_data_1053
|
import sys, math
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, product
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import Fraction
from decimal import Decimal
from heapq import heapify, heappop, heappush, heappushpop
from functools import cache
input = sys.stdin.readline
MI = lambda: map(int, input().split())
LI = lambda: list(map(int, input().split()))
II = lambda: int(input())
IR = lambda: input().rstrip()
LIR = lambda: list(input().rstrip())
LIRS = lambda: list(input().rstrip().split())
INF = math.inf
n=II()
s=list(map(int,LIR()))
s=sorted(s,reverse=True)
check=''.join(map(str,s))
temp=0
for i in s:
temp*=10
temp+=i
i=1
cnt=0
while i*i<=temp:
if check==''.join(sorted(str(i*i)+'0'*(n-len(str(i*i))),reverse=True)):
cnt+=1
i+=1
print(cnt)
import sys, math
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, product
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import Fraction
from decimal import Decimal
from heapq import heapify, heappop, heappush, heappushpop
from functools import cache
input = sys.stdin.readline
MI = lambda: map(int, input().split())
LI = lambda: list(map(int, input().split()))
II = lambda: int(input())
IR = lambda: input().rstrip()
LIR = lambda: list(input().rstrip())
LIRS = lambda: list(input().rstrip().split())
INF = math.inf
n=II()
s=list(map(int,LIR()))
s=sorted(s,reverse=True)
check=''.join(map(str,s))
temp=0
for i in s:
temp*=10
temp+=i
i=0
cnt=0
while i*i<=temp:
if check==''.join(sorted(str(i*i)+'0'*(n-len(str(i*i))),reverse=True)):
cnt+=1
i+=1
print(cnt)
|
ConDefects/ConDefects/Code/abc324_d/Python/53953051
|
condefects-python_data_1054
|
from collections import deque
import sys
import bisect
import math
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
li = lambda: list(map(int, input().split()))
INF = 2**63 - 1
MOD = 998244353
move = ((1, 0), (0, 1), (-1, 0), (0, -1))
move_diag = ((0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1))
# ---------------------------------------------- Template END ---------------------------------------------- #
N = int(input())
S = input()
# count number of occurances for each number in S
count = [0 for _ in range(10)] # count for 0 - 9
for c in S:
count[int(c)] += 1
# number of squared number we can create
ans = 0
# for all possible squared numbers, check if it is possible to create by rearraning S
for i in range(1, math.ceil(math.sqrt(10**N))):
squared = i * i
count_squared = [0] * 10
for c in str(squared):
count_squared[int(c)] += 1
# only for 0s, we don't need an exact match, but equal or more 0s in S
if count_squared[0] < count[0]:
count_squared[0] = count[0] # enough 0s so set equal to pass
if count_squared == count:
ans += 1
print(ans)
from collections import deque
import sys
import bisect
import math
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
li = lambda: list(map(int, input().split()))
INF = 2**63 - 1
MOD = 998244353
move = ((1, 0), (0, 1), (-1, 0), (0, -1))
move_diag = ((0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1))
# ---------------------------------------------- Template END ---------------------------------------------- #
N = int(input())
S = input()
# count number of occurances for each number in S
count = [0 for _ in range(10)] # count for 0 - 9
for c in S:
count[int(c)] += 1
# number of squared number we can create
ans = 0
# for all possible squared numbers, check if it is possible to create by rearraning S
for i in range(math.ceil(math.sqrt(10**N))):
squared = i * i
count_squared = [0] * 10
for c in str(squared):
count_squared[int(c)] += 1
# only for 0s, we don't need an exact match, but equal or more 0s in S
if count_squared[0] < count[0]:
count_squared[0] = count[0] # enough 0s so set equal to pass
if count_squared == count:
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/abc324_d/Python/54739961
|
condefects-python_data_1055
|
#4
#4320
N=int(input())
S=list(input())
S.sort()
ans=0
num1=1
num2=N
for i in S:
if i=="0":
num2-=1
while len(str(num1**2))<=len(S):
s=list(str(num1**2))
s.sort()
num3=len(s)
for i in s:
if i=="0":
num3-=1
if num3==num2 and s==S[len(S)-len(s):]:
ans+=1
num1+=1
print(ans)
#4
#4320
N=int(input())
S=list(input())
S.sort()
ans=0
num1=0
num2=N
for i in S:
if i=="0":
num2-=1
while len(str(num1**2))<=len(S):
s=list(str(num1**2))
s.sort()
num3=len(s)
for i in s:
if i=="0":
num3-=1
if num3==num2 and s==S[len(S)-len(s):]:
ans+=1
num1+=1
print(ans)
|
ConDefects/ConDefects/Code/abc324_d/Python/54958173
|
condefects-python_data_1056
|
n = int(input())
s = [int(x) for x in input()]
s.sort()
ans = 0
for x in range(1, 10**7):
t = [int(c) for c in str(x * x)]
if len(t) > n:
break
while len(t) < n:
t.append(0)
t.sort()
if s == t:
ans += 1
print(ans)
n = int(input())
s = [int(x) for x in input()]
s.sort()
ans = 0
for x in range(10**7):
t = [int(c) for c in str(x * x)]
if len(t) > n:
break
while len(t) < n:
t.append(0)
t.sort()
if s == t:
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/abc324_d/Python/53183863
|
condefects-python_data_1057
|
# D - Square Permutation
import copy
from collections import Counter
N, dic = None, None
def main():
global N, dic
N = int(input())
S = list(input())
dic = Counter(S)
upper = get_upper_limit(S)
i = 1
ans = 0
while i**2 <= upper:
if can_sort(i**2):
ans += 1
#print(i**2, ans)
i += 1
print(ans)
def get_upper_limit(S):
arr = copy.deepcopy(S)
arr.sort(reverse=True)
s = ''.join(arr)
return int(s)
def can_sort(n):
s = str(n).zfill(N)
c = Counter(list(s))
if len(c) == len(dic):
for k, v in c.items():
matches = False
if k in dic.keys():
if v == dic[k]:
matches = True
if not matches:
return
else:
return
return True
if __name__ == '__main__':
main()
# D - Square Permutation
import copy
from collections import Counter
N, dic = None, None
def main():
global N, dic
N = int(input())
S = list(input())
dic = Counter(S)
upper = get_upper_limit(S)
i = 0
ans = 0
while i**2 <= upper:
if can_sort(i**2):
ans += 1
#print(i**2, ans)
i += 1
print(ans)
def get_upper_limit(S):
arr = copy.deepcopy(S)
arr.sort(reverse=True)
s = ''.join(arr)
return int(s)
def can_sort(n):
s = str(n).zfill(N)
c = Counter(list(s))
if len(c) == len(dic):
for k, v in c.items():
matches = False
if k in dic.keys():
if v == dic[k]:
matches = True
if not matches:
return
else:
return
return True
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc324_d/Python/54390162
|
condefects-python_data_1058
|
N = int(input())
S = input()
S = ''.join(sorted(S,reverse=True))
pos = 1
cnt = 0
while pos**2 < 10**N:
tmp = str(pos*pos)
tmp = ''.join(sorted(tmp,reverse=True))
for i in range(len(tmp)):
if tmp[i] != S[i]:
break
else:
if len(tmp) < N:
if S[len(tmp)] == '0':
cnt += 1
else:
cnt +=1
pos += 1
print(cnt)
N = int(input())
S = input()
S = ''.join(sorted(S,reverse=True))
pos = 0
cnt = 0
while pos**2 < 10**N:
tmp = str(pos*pos)
tmp = ''.join(sorted(tmp,reverse=True))
for i in range(len(tmp)):
if tmp[i] != S[i]:
break
else:
if len(tmp) < N:
if S[len(tmp)] == '0':
cnt += 1
else:
cnt +=1
pos += 1
print(cnt)
|
ConDefects/ConDefects/Code/abc324_d/Python/53944042
|
condefects-python_data_1059
|
from collections import defaultdict
N = int(input())
dic = defaultdict(int)
S = input()
S_cnt = [0]*10
for i in S:
S_cnt[int(i)] += 1
ans = 0
for i in range(1,int(10**6.5) + 1):
tmp = list(str(i**2))
cnt = [0]*10
for j in tmp:
cnt[int(j)] += 1
flag = True
if S_cnt[0] < cnt[0]:
flag = False
else:
for j in range(1,10):
if cnt[j] != S_cnt[j]:
flag = False
break
if flag:
ans += 1
print(ans)
from collections import defaultdict
N = int(input())
dic = defaultdict(int)
S = input()
S_cnt = [0]*10
for i in S:
S_cnt[int(i)] += 1
ans = 0
for i in range(int(10**6.5) + 1):
tmp = list(str(i**2))
cnt = [0]*10
for j in tmp:
cnt[int(j)] += 1
flag = True
if S_cnt[0] < cnt[0]:
flag = False
else:
for j in range(1,10):
if cnt[j] != S_cnt[j]:
flag = False
break
if flag:
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/abc324_d/Python/54432109
|
condefects-python_data_1060
|
import sys
def main():
input = sys.stdin.readline
n = int(input())
s = sorted(input()[:-1])
max_val = int("".join(s[::-1]))
s = list(map(int, s))
cnt = 0
for i in range(1,10**8+1):
if i*i > max_val:
break
lst = list(map(int, str(i*i)))
if len(lst) < n:
lst += [0] * (n - len(lst))
if sorted(lst) == s:
cnt += 1
print(cnt)
main()
import sys
def main():
input = sys.stdin.readline
n = int(input())
s = sorted(input()[:-1])
max_val = int("".join(s[::-1]))
s = list(map(int, s))
cnt = 0
for i in range(0,10**7):
if i*i > max_val:
break
lst = list(map(int, str(i*i)))
if len(lst) < n:
lst += [0] * (n - len(lst))
if sorted(lst) == s:
cnt += 1
print(cnt)
main()
|
ConDefects/ConDefects/Code/abc324_d/Python/53028745
|
condefects-python_data_1061
|
class UnionFind():
def __init__(self, n):
self.par = [-1] * n
self.rank = [0] * n
self.siz = [1] * n
def find(self, x):
if self.par[x] == -1: return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
rx = self.find(x)
ry = self.find(y)
if rx == ry: return False
if self.rank[rx] < self.rank[ry]:
rx, ry = ry, rx
self.par[ry] = rx
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
self.siz[rx] += self.siz[ry]
return True
def size(self, x):
return self.siz[self.find(x)]
H, W = map(int, input().split())
vers = [[0] * W for i in range(H)]
cnt = 0
color = [list(input()) for i in range(H)]
for i in range(H):
for j in range(W):
vers[i][j] = cnt
cnt += 1
uf = UnionFind(H*W)
for i in range(H):
for j in range(W):
if color[i][j] == ".":continue
for ii, jj in [(1, 0),(-1, 0),(0, 1),(0, -1)]:
if 0 <= i + ii < H and 0 <= j + jj < W:
if color[i+ii][j+jj] == "#":
uf.union(vers[i][j], vers[i+ii][j+jj])
greenset = set()
greencnt = 0
bunbo = 0
for i in range(H):
for j in range(W):
if color[i][j] == "#":
greenset.add(uf.find(vers[i][j]))
else:
bunbo += 1
greencnt = len(greenset)
ans = 0
for i in range(H):
for j in range(W):
if color[i][j] == "#":continue
se = set()
for ii, jj in [(1, 0),(-1, 0),(0, 1),(0, -1)]:
if 0 <= i + ii < H and 0 <= j + jj < W:
if color[i+ii][j+jj] == "#":
se.add(uf.find(vers[i+ii][j+jj]))
ans += greencnt - len(se) + 1
mod = 998244353
print(ans)
print(bunbo)
print(ans * pow(bunbo, -1, mod) % mod)
class UnionFind():
def __init__(self, n):
self.par = [-1] * n
self.rank = [0] * n
self.siz = [1] * n
def find(self, x):
if self.par[x] == -1: return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same(self, x, y):
return self.find(x) == self.find(y)
def union(self, x, y):
rx = self.find(x)
ry = self.find(y)
if rx == ry: return False
if self.rank[rx] < self.rank[ry]:
rx, ry = ry, rx
self.par[ry] = rx
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
self.siz[rx] += self.siz[ry]
return True
def size(self, x):
return self.siz[self.find(x)]
H, W = map(int, input().split())
vers = [[0] * W for i in range(H)]
cnt = 0
color = [list(input()) for i in range(H)]
for i in range(H):
for j in range(W):
vers[i][j] = cnt
cnt += 1
uf = UnionFind(H*W)
for i in range(H):
for j in range(W):
if color[i][j] == ".":continue
for ii, jj in [(1, 0),(-1, 0),(0, 1),(0, -1)]:
if 0 <= i + ii < H and 0 <= j + jj < W:
if color[i+ii][j+jj] == "#":
uf.union(vers[i][j], vers[i+ii][j+jj])
greenset = set()
greencnt = 0
bunbo = 0
for i in range(H):
for j in range(W):
if color[i][j] == "#":
greenset.add(uf.find(vers[i][j]))
else:
bunbo += 1
greencnt = len(greenset)
ans = 0
for i in range(H):
for j in range(W):
if color[i][j] == "#":continue
se = set()
for ii, jj in [(1, 0),(-1, 0),(0, 1),(0, -1)]:
if 0 <= i + ii < H and 0 <= j + jj < W:
if color[i+ii][j+jj] == "#":
se.add(uf.find(vers[i+ii][j+jj]))
ans += greencnt - len(se) + 1
mod = 998244353
print(ans * pow(bunbo, -1, mod) % mod)
|
ConDefects/ConDefects/Code/abc334_e/Python/52777689
|
condefects-python_data_1062
|
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))
self.count = n
def find(self, i):
if self.parent[i] == i:
return i
self.parent[i] = self.find(self.parent[i])
return self.parent[i]
def unite(self, i, j):
i, j = self.find(i), self.find(j)
if i == j:
return
if i > j:
i, j = j, i
self.parent[j] = i
self.count -= 1
def same(self, i, j):
return self.find(i) == self.find(j)
MOD = 998244353
H, W = map(int, input().split())
S = [input() for _ in range(H)]
uf = UnionFind(H * W)
dot = 0
for i in range(H):
for j in range(W):
if S[i][j] == ".":
dot += 1
continue
if i + 1 < H and S[i + 1][j] == "#":
uf.unite(i * W + j, (i + 1) * W + j)
if j + 1 < W and S[i][j + 1] == "#":
uf.unite(i * W + j, i * W + j + 1)
num = 0
den = 0
cnt = uf.count - dot
for i in range(H):
for j in range(W):
if S[i][j] == "#":
continue
den += 1
s = set()
if i - 1 >= 0 and S[i - 1][j] == "#":
s.add(uf.find((i - 1) * W + j))
if i + 1 < H and S[i + 1][j] == "#":
s.add(uf.find((i + 1) * W + j))
if j - 1 >= 0 and S[i][j - 1] == "#":
s.add(uf.find(i * W + j - 1))
if j + 1 < W and S[i][j + 1] == "#":
s.add(uf.find(i * W + j + 1))
num += 1 - len(s)
print(num * pow(den, MOD - 2, MOD) % MOD)
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))
self.count = n
def find(self, i):
if self.parent[i] == i:
return i
self.parent[i] = self.find(self.parent[i])
return self.parent[i]
def unite(self, i, j):
i, j = self.find(i), self.find(j)
if i == j:
return
if i > j:
i, j = j, i
self.parent[j] = i
self.count -= 1
def same(self, i, j):
return self.find(i) == self.find(j)
MOD = 998244353
H, W = map(int, input().split())
S = [input() for _ in range(H)]
uf = UnionFind(H * W)
dot = 0
for i in range(H):
for j in range(W):
if S[i][j] == ".":
dot += 1
continue
if i + 1 < H and S[i + 1][j] == "#":
uf.unite(i * W + j, (i + 1) * W + j)
if j + 1 < W and S[i][j + 1] == "#":
uf.unite(i * W + j, i * W + j + 1)
num = 0
den = 0
cnt = uf.count - dot
for i in range(H):
for j in range(W):
if S[i][j] == "#":
continue
den += 1
s = set()
if i - 1 >= 0 and S[i - 1][j] == "#":
s.add(uf.find((i - 1) * W + j))
if i + 1 < H and S[i + 1][j] == "#":
s.add(uf.find((i + 1) * W + j))
if j - 1 >= 0 and S[i][j - 1] == "#":
s.add(uf.find(i * W + j - 1))
if j + 1 < W and S[i][j + 1] == "#":
s.add(uf.find(i * W + j + 1))
num += cnt + 1 - len(s)
print(num * pow(den, MOD - 2, MOD) % MOD)
|
ConDefects/ConDefects/Code/abc334_e/Python/52492868
|
condefects-python_data_1063
|
from collections import deque, defaultdict
from bisect import bisect_left, bisect_right
from atcoder.segtree import SegTree
from atcoder.lazysegtree import LazySegTree
from atcoder.dsu import DSU
from itertools import permutations, combinations
import math, sys
sys.setrecursionlimit(10**7)
MOD = 998244353
INF = 10**20
Yes, No = "Yes", "No"
N, Q = map(int, input().split())
C = list(map(int, input().split()))
S = [set([C[i]]) for i in range(N)]
for _ in range(Q):
a, b = map(lambda x: int(x)-1, input().split())
swap = False
if len(S[a]) > len(S[b]):
swap = True
a, b = b, a
S[b] |= S[a]
S[a].clear()
if swap:
S[b], S[a] = S[a], S[b]
print(len(S[b]))
from collections import deque, defaultdict
from bisect import bisect_left, bisect_right
from atcoder.segtree import SegTree
from atcoder.lazysegtree import LazySegTree
from atcoder.dsu import DSU
from itertools import permutations, combinations
import math, sys
sys.setrecursionlimit(10**7)
MOD = 998244353
INF = 10**20
Yes, No = "Yes", "No"
N, Q = map(int, input().split())
C = list(map(int, input().split()))
S = [set([C[i]]) for i in range(N)]
for _ in range(Q):
a, b = map(lambda x: int(x)-1, input().split())
swap = False
if len(S[a]) > len(S[b]):
swap = True
a, b = b, a
S[b] |= S[a]
S[a].clear()
print(len(S[b]))
if swap:
S[b], S[a] = S[a], S[b]
|
ConDefects/ConDefects/Code/abc329_f/Python/52733588
|
condefects-python_data_1064
|
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(n):
ans2=ans>>a[i]+1
ans2=(ans2|1)<<a[i]
ans=ans2
print (ans)
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(n):
ans2=(ans>>a[i])+1
ans2=(ans2|1)<<a[i]
ans=ans2
print (ans)
|
ConDefects/ConDefects/Code/arc139_a/Python/45429015
|
condefects-python_data_1065
|
n=int(input())
a=[0]+list(map(int,input().split()))
f=1
for i in range(1,n+1):
if a[i]<a[i-1]:
f|=1<<a[i]
if a[i]>=a[i-1]:
ok=1<<100
ng=-1
while ok-ng>1:
m=(ok+ng)//2
if (m<<(a[i]+1))+(1<<a[i])>f:
ok=m
else:
ng=m
f=(ok<<(a[i]+1))+(1<<a[i])
print(f)
n=int(input())
a=[0]+list(map(int,input().split()))
f=0
for i in range(1,n+1):
if a[i]<a[i-1]:
f|=1<<a[i]
if a[i]>=a[i-1]:
ok=1<<100
ng=-1
while ok-ng>1:
m=(ok+ng)//2
if (m<<(a[i]+1))+(1<<a[i])>f:
ok=m
else:
ng=m
f=(ok<<(a[i]+1))+(1<<a[i])
print(f)
|
ConDefects/ConDefects/Code/arc139_a/Python/41107434
|
condefects-python_data_1066
|
n = int(input())
t = list(map(int, input().split()))
p = 2**t[0]
for i in range(1, n):
d = 2**t[i]
w = d
if w <= p:
kz = (p-w+d)//d
w += kz*d
p = w
print(p)
n = int(input())
t = list(map(int, input().split()))
p = 2**t[0]
for i in range(1, n):
d = 2**t[i]
w = d
if w <= p:
kz = (p-w+d)//d
w += kz*d
if w%(d*2)==0:
w += d
p = w
print(p)
|
ConDefects/ConDefects/Code/arc139_a/Python/43325170
|
condefects-python_data_1067
|
from collections import defaultdict
N,K = map(int,input().split())
A = list(map(int,input().split()))
B = set((map(int,input().split())))
D = defaultdict(set)
for i in range(N):
D[A[i]].add(i)
m = max(A)
if len(B&D[m]) == 0:
print("No")
else:
print("Yes")
from collections import defaultdict
N,K = map(int,input().split())
A = list(map(int,input().split()))
B = set((map(int,input().split())))
D = defaultdict(set)
for i in range(N):
D[A[i]].add(i+1)
m = max(A)
if len(B&D[m]) == 0:
print("No")
else:
print("Yes")
|
ConDefects/ConDefects/Code/abc252_b/Python/45103207
|
condefects-python_data_1068
|
import sys
import copy
from collections import deque,defaultdict
import math
import heapq
from itertools import accumulate
import itertools
from functools import reduce
#import pypyjit
#pypyjit.set_param('max_unroll_recursion=-1')
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = math.inf
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
from functools import lru_cache #@lru_cache(maxsize=None)
def main():
N,K = mi()
A = [(j,i) for i,j in enumerate(li())]
B = set(li())
A.sort(reverse=True)
M = A[0][0]
for i in range(N):
if A[i][0] == M:
if A[i][1] in B:
print("Yes")
return
print("No")
if __name__=="__main__":
main()
import sys
import copy
from collections import deque,defaultdict
import math
import heapq
from itertools import accumulate
import itertools
from functools import reduce
#import pypyjit
#pypyjit.set_param('max_unroll_recursion=-1')
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = math.inf
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
from functools import lru_cache #@lru_cache(maxsize=None)
def main():
N,K = mi()
A = [(j,i) for i,j in enumerate(li())]
B = set(li())
A.sort(reverse=True)
M = A[0][0]
for i in range(N):
if A[i][0] == M:
if A[i][1]+1 in B:
print("Yes")
return
print("No")
if __name__=="__main__":
main()
|
ConDefects/ConDefects/Code/abc252_b/Python/45243368
|
condefects-python_data_1069
|
from sys import stdin
N,Q = map(int, stdin.readline().split())
S = list(stdin.readline()[:-1])
TF = [0]*(N+10)
BIT = [0]*(N+10)
def get(pos):
s = 0
while pos > 0:
s += BIT[pos]
pos -= pos & -pos
return s
def add(pos,val):
while pos <= N+5:
BIT[pos] += val
pos += pos & -pos
return
for i,v in enumerate(S):
if i == 0:
continue
if S[i] == S[i-1]:
add(i+1,1)
TF[i+1] = 1
for i in range(Q):
que,left,right = map(int, stdin.readline().split())
if que == 2:
if left == 1:
tmp = get(right)
else:
tmp = get(right)-get(left-1)
if tmp == 0:
print("Yes")
else:
print("No")
else:
if right != N:
if TF[right+1] == 1:
TF[right+1] = 0
add(right+1,-1)
else:
TF[right+1] = 1
add(right+1,1)
if left != 1:
if TF[left] == 1:
TF[left] = 0
add(left,-1)
else:
TF[left] = 1
add(left,1)
from sys import stdin
N,Q = map(int, stdin.readline().split())
S = list(stdin.readline()[:-1])
TF = [0]*(N+10)
BIT = [0]*(N+10)
def get(pos):
s = 0
while pos > 0:
s += BIT[pos]
pos -= pos & -pos
return s
def add(pos,val):
while pos <= N+5:
BIT[pos] += val
pos += pos & -pos
return
for i,v in enumerate(S):
if i == 0:
continue
if S[i] == S[i-1]:
add(i+1,1)
TF[i+1] = 1
for i in range(Q):
que,left,right = map(int, stdin.readline().split())
if que == 2:
if left == 1:
tmp = get(right)
else:
tmp = get(right)-get(left)
if tmp == 0:
print("Yes")
else:
print("No")
else:
if right != N:
if TF[right+1] == 1:
TF[right+1] = 0
add(right+1,-1)
else:
TF[right+1] = 1
add(right+1,1)
if left != 1:
if TF[left] == 1:
TF[left] = 0
add(left,-1)
else:
TF[left] = 1
add(left,1)
|
ConDefects/ConDefects/Code/abc341_e/Python/53935483
|
condefects-python_data_1070
|
from atcoder.segtree import SegTree
n,q=map(int,input().split())
S=input()
L=[0]*(n+1)
for i in range(1,n-1):
if S[i]!=S[i-1]:
L[i]=1
def op(a,b):
return a+b
st=SegTree(op,0,L)
# print(1)
for i in range(q):
num,l,r=map(int,input().split())
if num==1:
st.set(l-1,(st.get(l-1)+1)%2)
st.set(r,(st.get(r)+1)%2)
else:
temp=st.prod(l,r)
if temp==r-l:
print('Yes')
else:
print('No')
from atcoder.segtree import SegTree
n,q=map(int,input().split())
S=input()
L=[0]*(n+1)
for i in range(1,n):
if S[i]!=S[i-1]:
L[i]=1
def op(a,b):
return a+b
st=SegTree(op,0,L)
# print(1)
for i in range(q):
num,l,r=map(int,input().split())
if num==1:
st.set(l-1,(st.get(l-1)+1)%2)
st.set(r,(st.get(r)+1)%2)
else:
temp=st.prod(l,r)
if temp==r-l:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc341_e/Python/54316816
|
condefects-python_data_1071
|
from atcoder.segtree import SegTree
def op(x,y):
return max(x,y)
N,Q = map(int,input().split())
S = input()
check = SegTree(op,-float("inf"),[0 for i in range(N-1)])
for i in range(N-1):
if S[i]==S[i+1]:
check.set(i,1)
for i in range(Q):
query = list(map(int,input().split()))
q = query.pop(0)
if q == 1:
if query[0]!=1:
hoge = check.get(query[0]-2)
check.set(query[0]-2,(hoge+1)%2)
if query[1]!=N:
hoge = check.get(query[1]-1)
check.set(query[1]-1,(hoge+1)%2)
else:
if N == 1:
print("Yes")
else:
hoge = check.prod(query[0]-1,query[1]-1)
if hoge == 0:
print("Yes")
else:
print("No")
from atcoder.segtree import SegTree
def op(x,y):
return max(x,y)
N,Q = map(int,input().split())
S = input()
check = SegTree(op,-float("inf"),[0 for i in range(N-1)])
for i in range(N-1):
if S[i]==S[i+1]:
check.set(i,1)
for i in range(Q):
query = list(map(int,input().split()))
q = query.pop(0)
if q == 1:
if query[0]!=1:
hoge = check.get(query[0]-2)
check.set(query[0]-2,(hoge+1)%2)
if query[1]!=N:
hoge = check.get(query[1]-1)
check.set(query[1]-1,(hoge+1)%2)
else:
if query[0]==query[1]:
print("Yes")
else:
hoge = check.prod(query[0]-1,query[1]-1)
if hoge == 0:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc341_e/Python/54515840
|
condefects-python_data_1072
|
from heapq import heappop,heappush
INF=1<<60
N,M=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
dp=[0]
for i in range(N):
ndp=[INF]*((i+1)*(i+2)//2+1)
for j in range(len(dp)):
ndp[j]=min(ndp[j],dp[j])
ndp[j+i+1]=min(ndp[j+i+1],dp[j]+A[i])
dp=ndp
box=[(INF,-1)]
bsum=0
jsum=0
for i in range(M):
heappush(box,((B[i]+i)//(i+1),i))
jsum+=i+1
ans=INF
for i in range(len(dp)):
if box[0][0]<=i:
_,j=heappop(box)
bsum+=B[j]
jsum-=j+1
ans=min(ans,dp[-i-1]+bsum+jsum*i)
print(ans)
from heapq import heappop,heappush
INF=1<<60
N,M=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
dp=[0]
for i in range(N):
ndp=[INF]*((i+1)*(i+2)//2+1)
for j in range(len(dp)):
ndp[j]=min(ndp[j],dp[j])
ndp[j+i+1]=min(ndp[j+i+1],dp[j]+A[i])
dp=ndp
box=[(INF,-1)]
bsum=0
jsum=0
for i in range(M):
heappush(box,((B[i]+i)//(i+1),i))
jsum+=i+1
ans=INF
for i in range(len(dp)):
while box[0][0]<=i:
_,j=heappop(box)
bsum+=B[j]
jsum-=j+1
ans=min(ans,dp[-i-1]+bsum+jsum*i)
print(ans)
|
ConDefects/ConDefects/Code/abc332_g/Python/52980637
|
condefects-python_data_1073
|
s = input()
n = len(s)
answer = -1
for i in range(n):
if s[i] == 'a':
answer = i
print(answer)
s = input()
n = len(s)
answer = -1
for i in range(n):
if s[i] == 'a':
answer = i+1
print(answer)
|
ConDefects/ConDefects/Code/abc276_a/Python/45247098
|
condefects-python_data_1074
|
a=input()
b=len(a)
for i in range(b-1,0,-1):
if a[i]=="a":
print(i+1)
quit()
print(-1)
a=input()
b=len(a)
for i in range(b-1,-1,-1):
if a[i]=="a":
print(i+1)
quit()
print(-1)
|
ConDefects/ConDefects/Code/abc276_a/Python/45957302
|
condefects-python_data_1075
|
s=input()
for i in range(len(s)):
if s[-i-1]=="a":
print((len(s))-i)
break
print(-1)
break
s=input()
for i in range(len(s)):
if s[-i-1]=="a":
print((len(s))-i)
break
else:
print(-1)
|
ConDefects/ConDefects/Code/abc276_a/Python/45481761
|
condefects-python_data_1076
|
h, m = map(int, input().split())
while True:
if h // 10 * 10 + m // 10 < 24 and h % 10 * 10 + m % 10 < 60:
exit(print(h, m))
m += 1
if m % 60 == 0:
h += 1
m = 0
h, m = map(int, input().split())
while True:
if h // 10 * 10 + m // 10 < 24 and h % 10 * 10 + m % 10 < 60:
exit(print(h, m))
m += 1
if m % 60 == 0:
h += 1
m = 0
if h == 24:
h = 0
|
ConDefects/ConDefects/Code/abc278_b/Python/45695932
|
condefects-python_data_1077
|
def f(h , m) :
a = h // 10
b = h % 10
c = m // 10
d = m % 10
h2 = a * 10 + c
m2 = b * 10 + d
if 0 <= h2 <= 23 and 0 <= m2 <= 59 :
print(a * 10 + b , c * 10 + d)
exit()
h , m = map(int,input().split())
while True :
f(h , m)
total = h * 60 + m + 1
h = total // 60
m = total % 60
def f(h , m) :
a = h // 10
b = h % 10
c = m // 10
d = m % 10
h2 = a * 10 + c
m2 = b * 10 + d
if 0 <= h2 <= 23 and 0 <= m2 <= 59 :
print(a * 10 + b , c * 10 + d)
exit()
h , m = map(int,input().split())
while True :
f(h , m)
total = h * 60 + m + 1
h = total // 60 % 24
m = total % 60
|
ConDefects/ConDefects/Code/abc278_b/Python/45297542
|
condefects-python_data_1078
|
h, m = map(int, input().split())
def check(h, m):
b = h % 10
c = m // 10
newm = (m-c*10)+b*10
add = ((m-c*10)+b*10) // 60
newh = (h-b)+c+add
return 0 <= newm < 60 and 0 <= newh < 23
while True:
if check(h, m): break
m += 1
h += m//60
m %= 60
h %= 24
print(h, m)
h, m = map(int, input().split())
def check(h, m):
b = h % 10
c = m // 10
newm = (m-c*10)+b*10
add = ((m-c*10)+b*10) // 60
newh = (h-b)+c+add
return 0 <= newm < 60 and 0 <= newh < 24
while True:
if check(h, m): break
m += 1
h += m//60
m %= 60
h %= 24
print(h, m)
|
ConDefects/ConDefects/Code/abc278_b/Python/45484239
|
condefects-python_data_1079
|
#!/usr/bin/env python3
ch, cm = [int(x) for x in input().split()]
while True:
while cm < 60:
if (0 <= ch // 10 * 10 + cm // 10 <= 23) and (
0 <= (ch % 10) * 10 + cm % 10 <= 59
):
print(ch, cm)
exit()
cm += 1
ch += 1
cm = 0
#!/usr/bin/env python3
ch, cm = [int(x) for x in input().split()]
while True:
while cm < 60:
if (0 <= ch // 10 * 10 + cm // 10 <= 23) and (
0 <= (ch % 10) * 10 + cm % 10 <= 59
):
print(ch, cm)
exit()
cm += 1
ch = (ch + 1) % 24
cm = 0
|
ConDefects/ConDefects/Code/abc278_b/Python/45512302
|
condefects-python_data_1080
|
H, M = map(int, input().split())
while True:
if H < 20:
if int(str(H)[-1]) < 6:
print(H,M)
exit()
else:
M += 1
if M == 60:
H += 1
H = H % 24
M = 0
else:
if int(str(M)[0]) < 4:
print(H,M)
exit()
else:
M += 1
if M == 60:
H += 1
H = H % 24
M = 0
H, M = map(int, input().split())
while True:
if H < 20:
if int(str(H)[-1]) < 6:
print(H,M)
exit()
else:
M += 1
if M == 60:
H += 1
H = H % 24
M = 0
else:
if int(((str(M)).zfill(2))[0]) < 4:
print(H,M)
exit()
else:
M += 1
if M == 60:
H += 1
H = H % 24
M = 0
|
ConDefects/ConDefects/Code/abc278_b/Python/45108856
|
condefects-python_data_1081
|
S = list(map(int, input().split()))
S_sort = S.copy()
S_sort.sort()
bad=0
for i in range(8):
if S==S_sort:
if S[i]>=675 or S[i]<=100:
bad+=1
else:
for j in range(8):
if not S[j]%25==0:
bad+=1
else:
bad+=1
if bad==0:
print('Yes')
else:
print('No')
S = list(map(int, input().split()))
S_sort = S.copy()
S_sort.sort()
bad=0
for i in range(8):
if S==S_sort:
if S[i]>675 or S[i]<100:
bad+=1
else:
for j in range(8):
if not S[j]%25==0:
bad+=1
else:
bad+=1
if bad==0:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc308_a/Python/46165457
|
condefects-python_data_1082
|
arr = list(map(int, input().split()))
fl = True
for i in range(1, 8):
if arr[i - 1] > arr[i]:
fl = False
if arr[i - 1] % 25 != 0 or arr[i] % 25 != 0:
fl = False
print("Yes" if fl else "No")
arr = list(map(int, input().split()))
fl = True
if arr[0] < 100 or arr[-1] > 675:
fl = False
for i in range(1, 8):
if arr[i - 1] > arr[i]:
fl = False
if arr[i - 1] % 25 != 0 or arr[i] % 25 != 0:
fl = False
print("Yes" if fl else "No")
|
ConDefects/ConDefects/Code/abc308_a/Python/45959405
|
condefects-python_data_1083
|
S = list(map(int, input().split()))
res = 'Yes'
for i in range(len(S) - 1):
if S[i] >= S[i + 1]:
res = 'No'
break
for i in range(len(S)):
if S[i] % 25 or not 100 <= S[i] <= 675:
res = 'No'
break
print(res)
S = list(map(int, input().split()))
res = 'Yes'
for i in range(len(S) - 1):
if S[i] > S[i + 1]:
res = 'No'
break
for i in range(len(S)):
if S[i] % 25 or not 100 <= S[i] <= 675:
res = 'No'
break
print(res)
|
ConDefects/ConDefects/Code/abc308_a/Python/46165135
|
condefects-python_data_1084
|
S = list(map(int,input().split()))
ans = "Yes"
for i in range(len(S)-1):
if not(S[i] <= S[i+1]):
ans = "No"
for j in range(len(S)):
if not(S[i] % 25 == 0 and 100 <= S[i] <= 675):
ans = "No"
print(ans)
S = list(map(int,input().split()))
ans = "Yes"
for i in range(len(S)-1):
if not(S[i] <= S[i+1]):
ans = "No"
for j in range(len(S)):
if not(S[j] % 25 == 0 and 100 <= S[j] <= 675):
ans = "No"
print(ans)
|
ConDefects/ConDefects/Code/abc308_a/Python/45947529
|
condefects-python_data_1085
|
s=list(map(int,input().split()))
ss=sorted(s)
pack=[]
if s==ss and s[0] >100 and s[-1]<675:
for i in s:
if i%25==0:
pack.append(i)
print("Yes" if len(pack)==8 else "No")
s=list(map(int,input().split()))
ss=sorted(s)
pack=[]
if s==ss and s[0]>=100 and s[-1]<=675:
for i in s:
if i%25==0:
pack.append(i)
print("Yes" if len(pack)==8 else "No")
|
ConDefects/ConDefects/Code/abc308_a/Python/46170943
|
condefects-python_data_1086
|
S = list(map(int,input().split()))
for i in range(len(S)-1):
if S[i] >= S[i+1] or S[i] % 25 or S[i] < 100 or S[i] > 675:
print("No")
exit()
if S[-1] % 25 or S[-1] < 100 or S[-1] > 675:
print("No")
else: print("Yes")
S = list(map(int,input().split()))
for i in range(len(S)-1):
if S[i] > S[i+1] or S[i] % 25 or S[i] < 100 or S[i] > 675:
print("No")
exit()
if S[-1] % 25 or S[-1] < 100 or S[-1] > 675:
print("No")
else: print("Yes")
|
ConDefects/ConDefects/Code/abc308_a/Python/45931202
|
condefects-python_data_1087
|
S = list(map(int, input().split()))
N = len(S)
for i in range(N):
if sorted(S) == S or not(100 <= S[i] <= 675) or S[i]%25 != 0:
print('No')
exit()
else:
print('Yes')
S = list(map(int, input().split()))
N = len(S)
for i in range(N):
if sorted(S) != S or not(100 <= S[i] <= 675) or S[i]%25 != 0:
print('No')
exit()
else:
print('Yes')
|
ConDefects/ConDefects/Code/abc308_a/Python/46000754
|
condefects-python_data_1088
|
S=list(map(int,input().split()))
check_S=sorted(S)
check="True"
check_num=0
for i in range (len(S)):
if check_num<S[i] and 100<=S[i]<=675 and S[i]%25==0:
check_num=S[i]
else:
check="False"
if check=="True":
print("Yes")
else:
print("No")
S=list(map(int,input().split()))
check_S=sorted(S)
check="True"
check_num=0
for i in range (len(S)):
if check_num<=S[i] and 100<=S[i]<=675 and S[i]%25==0:
check_num=S[i]
else:
check="False"
if check=="True":
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc308_a/Python/46023709
|
condefects-python_data_1089
|
N,M,S = map(int,input().split())
a = list(map(int,input().split()))
b = [0]
for i in range(N-1,-1,-1):
b.append(b[-1]+a[i])
ans = 0
for j in range(N+1):
for i in range(N+1):
if i == j:
continue
yi = S - (N-j)*M
yi /= j-i
yj = S - (N-i)*M
yj /= i-j
if yi > 0 and yj > 0:
tmp = b[N-i]*yi + b[N-j]*yj
else:
continue
if ans < tmp:
ans = tmp
print(ans)
N,M,S = map(int,input().split())
a = list(map(int,input().split()))
b = [0]
for i in range(N-1,-1,-1):
b.append(b[-1]+a[i])
ans = 0
for j in range(N+1):
for i in range(N+1):
if i == j:
continue
yi = S - (N-j)*M
yi /= j-i
yj = S - (N-i)*M
yj /= i-j
if yi >= 0 and yj >= 0:
tmp = b[N-i]*yi + b[N-j]*yj
else:
continue
if ans < tmp:
ans = tmp
print(ans)
|
ConDefects/ConDefects/Code/arc128_c/Python/41096330
|
condefects-python_data_1090
|
N,M,S=map(int,input().split())
A=list(map(int,input().split()))
sums=0
C=[0]*N
for i in range(N-1,-1,-1):
sums+=A[i]
C[i]=sums/(N-i)
ans=0
#print(C)
for i in range(N):
for j in range(N):
#print(i,j,ans)
if i==j:
continue
if C[i]<C[j]:
continue
if S/(N-i)<=M:
ans=max(ans,S*C[i])
elif S/(N-j)<=M:
ans=max(ans,S*C[j])
if C[j]!=C[i]:
t=(M-(S/(N-j)))*(N-i)*(N-j)/(i-j)
#print(t,S-t,i,j)
ans=max(ans,t*C[i]+(S-t)*C[j])
print(ans)
N,M,S=map(int,input().split())
A=list(map(int,input().split()))
sums=0
C=[0]*N
for i in range(N-1,-1,-1):
sums+=A[i]
C[i]=sums/(N-i)
ans=0
#print(C)
for i in range(N):
for j in range(N):
#print(i,j,ans)
if C[i]<C[j]:
continue
if S/(N-i)<=M:
ans=max(ans,S*C[i])
elif S/(N-j)<=M:
ans=max(ans,S*C[j])
if C[j]!=C[i]:
t=(M-(S/(N-j)))*(N-i)*(N-j)/(i-j)
#print(t,S-t,i,j)
ans=max(ans,t*C[i]+(S-t)*C[j])
print(ans)
|
ConDefects/ConDefects/Code/arc128_c/Python/33842964
|
condefects-python_data_1091
|
n, m, S = map(int,input().split())
a = list(map(int,input().split()))
asum = [0] * (n + 1)
for i in range(n):
asum[i + 1] += asum[i] + a[i]
ans = 0
for i in range(n + 1):
for j in range(i, n + 1):
s = S
s -= m * (n - j)
if s < 0:
continue
if j - i == 0:
ans = max(ans, s * (n - j))
continue
one = s / (j - i)
if one > m:
continue
now = (asum[j] - asum[i]) * one + m * (asum[n] - asum[j])
ans = max(ans, now)
print(ans)
n, m, S = map(int,input().split())
a = list(map(int,input().split()))
asum = [0] * (n + 1)
for i in range(n):
asum[i + 1] += asum[i] + a[i]
ans = 0
for i in range(n + 1):
for j in range(i, n + 1):
s = S
s -= m * (n - j)
if s < 0:
continue
if j - i == 0:
ans = max(ans, m * (asum[n] - asum[j]))
continue
one = s / (j - i)
if one > m:
continue
now = (asum[j] - asum[i]) * one + m * (asum[n] - asum[j])
ans = max(ans, now)
print(ans)
|
ConDefects/ConDefects/Code/arc128_c/Python/28766899
|
condefects-python_data_1092
|
import sys
input = lambda :sys.stdin.readline()[:-1]
ni = lambda :int(input())
na = lambda :list(map(int,input().split()))
yes = lambda :print("yes");Yes = lambda :print("Yes");YES = lambda : print("YES")
no = lambda :print("no");No = lambda :print("No");NO = lambda : print("NO")
#######################################################################
N,M,S = na()
A = na()
B = [0]
for i in range(N):
B.append(B[-1]+A[i])
ans = 0
#[0,L),[L,R),[R,N)
for L in range(N+1):
for R in range(L, N+1):
if S-(N-R)*M<=0 or (S-(N-R)*M) >= M*(R-L):
continue
if R==L:
z = (B[N]-B[R])*M
else:
z = (B[N]-B[R])*M+(B[R]-B[L])*(S-(N-R)*M)/(R-L)
#print(L,R,z,(S-(N-R)*M)/(R-L),M,0<(S-(N-R)*M)/(R-L)<M)
ans = max(ans,z)
print(ans)
import sys
input = lambda :sys.stdin.readline()[:-1]
ni = lambda :int(input())
na = lambda :list(map(int,input().split()))
yes = lambda :print("yes");Yes = lambda :print("Yes");YES = lambda : print("YES")
no = lambda :print("no");No = lambda :print("No");NO = lambda : print("NO")
#######################################################################
N,M,S = na()
A = na()
B = [0]
for i in range(N):
B.append(B[-1]+A[i])
ans = 0
#[0,L),[L,R),[R,N)
for L in range(N+1):
for R in range(L, N+1):
if S-(N-R)*M<0 or (S-(N-R)*M) > M*(R-L):
continue
if R==L:
z = (B[N]-B[R])*M
else:
z = (B[N]-B[R])*M+(B[R]-B[L])*(S-(N-R)*M)/(R-L)
#print(L,R,z,(S-(N-R)*M)/(R-L),M,0<(S-(N-R)*M)/(R-L)<M)
ans = max(ans,z)
print(ans)
|
ConDefects/ConDefects/Code/arc128_c/Python/29987786
|
condefects-python_data_1093
|
N, L, R = map(int, input().split())
A = list(map(int, input().split()))
for a in A:
if a <= L:
print(L, end = ' ')
else:
print(R, end = ' ')
N, L, R = map(int, input().split())
A = list(map(int, input().split()))
for a in A:
if a <= L:
print(L, end = ' ')
elif L < a < R:
print(a, end = ' ')
else:
print(R, end = ' ')
|
ConDefects/ConDefects/Code/abc330_b/Python/54726392
|
condefects-python_data_1094
|
N, L, R = map(int, input().split())
A = sorted([*map(int, input().split())])
for a in A:
if a <= L:
print(L, end=' ')
elif a >= R:
print(R, end=' ')
else:
print(a, end=' ')
N, L, R = map(int, input().split())
A = [*map(int, input().split())]
for a in A:
if a <= L:
print(L, end=' ')
elif a >= R:
print(R, end=' ')
else:
print(a, end=' ')
|
ConDefects/ConDefects/Code/abc330_b/Python/55040608
|
condefects-python_data_1095
|
N, L, R = map(int, input().split())
a = list(map(int, input().split()))
ans = []
for i in a:
if i < L:
ans.append(L)
elif i > L and i < R:
ans.append(i)
else:
ans.append(R)
print(*ans)
N, L, R = map(int, input().split())
a = list(map(int, input().split()))
ans = []
for i in a:
if i <= L:
ans.append(L)
elif i > L and i < R:
ans.append(i)
else:
ans.append(R)
print(*ans)
|
ConDefects/ConDefects/Code/abc330_b/Python/54214263
|
condefects-python_data_1096
|
A, B = input().split()
A, B = int(A), int(B)
res = A^B + B^A
print(res)
A, B = input().split()
A, B = int(A), int(B)
res = (A**B) + (B**A)
print(res)
|
ConDefects/ConDefects/Code/abc320_a/Python/55169721
|
condefects-python_data_1097
|
a, b, c = map(int,input().split())
l = [a,b,c]
l_2 = sorted(l)
if b == l_2[1]:
print("Yes")
else:
print("no")
a, b, c = map(int,input().split())
l = [a,b,c]
l_2 = sorted(l)
if b == l_2[1]:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc253_a/Python/45454292
|
condefects-python_data_1098
|
a, b, c = map(int, input().split())
if (a + c) // 2 == b:
print('Yes')
else:
print('No')
a, b, c = map(int, input().split())
if a <= b <= c or c <= b <= a:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc253_a/Python/45510646
|
condefects-python_data_1099
|
n,m,e=map(int,input().split())
s=[list(map(int,input().split())) for i in range(e)]
q=int(input())
event=[int(input()) for i in range(q)]
p=set()
for i in range(e):
s[i][0]-=1
s[i][1]-=1
for i in range(q):
event[i]-=1
for k in event:
p.add(k)
#unionfind#
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self,x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def size(self, x):
return -self.parents[self.find(x)]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.size(x)< self.size(y):
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
r=UnionFind(m+n)
for i in range(e):
if i not in p:
r.union(s[i][0],s[i][1])
ans=[0]*q
now=0
elect=set()
for i in range(n,m+n):
x=r.find(i)
if x not in elect:
elect.add(x)
for i in range(n):
if r.find(i) in elect:
ans[-1]+=1
le=[0]*(n+m)
for i in range(n+m):
le[r.find(i)]+=1
for i in range(1,q):
ans[-i-1]=ans[-i]
j=event[-i]
x,y=r.find(s[j][0]),r.find(s[j][1])
if x not in elect:
if y in elect:
ans[-i-1]+=le[x]
elect.add(x)
if x in elect:
if y not in elect:
ans[-i-1]+=le[y]
elect.add(y)
r.union(s[j][0],s[j][1])
if x!=r.find(x):
le[y]+=le[x]
elif y!=r.find(y):
le[y]+=le[x]
for i in range(q):
print(ans[i])
n,m,e=map(int,input().split())
s=[list(map(int,input().split())) for i in range(e)]
q=int(input())
event=[int(input()) for i in range(q)]
p=set()
for i in range(e):
s[i][0]-=1
s[i][1]-=1
for i in range(q):
event[i]-=1
for k in event:
p.add(k)
#unionfind#
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self,x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def size(self, x):
return -self.parents[self.find(x)]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.size(x)< self.size(y):
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
r=UnionFind(m+n)
for i in range(e):
if i not in p:
r.union(s[i][0],s[i][1])
ans=[0]*q
now=0
elect=set()
for i in range(n,m+n):
x=r.find(i)
if x not in elect:
elect.add(x)
for i in range(n):
if r.find(i) in elect:
ans[-1]+=1
le=[0]*(n+m)
for i in range(n+m):
le[r.find(i)]+=1
for i in range(1,q):
ans[-i-1]=ans[-i]
j=event[-i]
x,y=r.find(s[j][0]),r.find(s[j][1])
if x not in elect:
if y in elect:
ans[-i-1]+=le[x]
elect.add(x)
if x in elect:
if y not in elect:
ans[-i-1]+=le[y]
elect.add(y)
r.union(s[j][0],s[j][1])
if x!=r.find(x):
le[y]+=le[x]
elif y!=r.find(y):
le[x]+=le[y]
for i in range(q):
print(ans[i])
|
ConDefects/ConDefects/Code/abc264_e/Python/45504321
|
condefects-python_data_1100
|
import bisect, collections, copy, heapq, itertools, math, sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
# P = 10**9+7
P = 998244353
N, M = map(int, input().split())
S = [list(map(int, input().split())) for _ in range(N+M)]
dp = [[10**20]*(N+M) for _ in range(1<<(N+M))]
q = collections.deque([])
for i in range(N+M):
x, y = S[i]
dp[1<<i][i] = (x**2+y**2)**0.5
q.append((1<<i, i))
ans = 10**20
while q:
bit, u = q.popleft()
s = 1
for i in range(N, N+M):
if bit&(1<<i):
s *= 2
xu, yu = S[u]
d = dp[bit][u]
for v in range(N+M):
if bit&(1<<v):
continue
xv, yv = S[v]
if dp[bit+(1<<v)][v] == 10**20:
q.append((bit+(1<<v), v))
if d + ((xu-xv)**2+(yu-yv)**2)**0.5 < dp[bit+(1<<v)][v]:
dp[bit+(1<<v)][v] = d + ((xu-xv)**2+(yu-yv)**2)**0.5/s
if bit&((1<<N)-1) == (1<<N)-1 and d + (xu**2+yu**2)**0.5/s < ans:
ans = d + (xu**2+yu**2)**0.5/s
print(ans)
import bisect, collections, copy, heapq, itertools, math, sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
# P = 10**9+7
P = 998244353
N, M = map(int, input().split())
S = [list(map(int, input().split())) for _ in range(N+M)]
dp = [[10**20]*(N+M) for _ in range(1<<(N+M))]
q = collections.deque([])
for i in range(N+M):
x, y = S[i]
dp[1<<i][i] = (x**2+y**2)**0.5
q.append((1<<i, i))
ans = 10**20
while q:
bit, u = q.popleft()
s = 1
for i in range(N, N+M):
if bit&(1<<i):
s *= 2
xu, yu = S[u]
d = dp[bit][u]
for v in range(N+M):
if bit&(1<<v):
continue
xv, yv = S[v]
if dp[bit+(1<<v)][v] == 10**20:
q.append((bit+(1<<v), v))
if d + ((xu-xv)**2+(yu-yv)**2)**0.5/s < dp[bit+(1<<v)][v]:
dp[bit+(1<<v)][v] = d + ((xu-xv)**2+(yu-yv)**2)**0.5/s
if bit&((1<<N)-1) == (1<<N)-1 and d + (xu**2+yu**2)**0.5/s < ans:
ans = d + (xu**2+yu**2)**0.5/s
print(ans)
|
ConDefects/ConDefects/Code/abc274_e/Python/45512531
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.