input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
# -*- coding: utf-8 -*-
class HashTable(list):
def __init__(self, length):
list.__init__(self)
self.length = length
self[:] = [None] * length
def h1(self, key):
return key % self.length
def h2(self, key):
return 1 + (key % (self.length - 1))
def h(self, key, i):
return (self.h1(key) + i*self.h2(key)) % self.length
def insert(self, key):
i = 0
while True:
j = self.h(key, i)
if self[j] is None:
self[j] = key
return j
else:
i += 1
def search(self, key):
i = 0
while True:
j = self.h(key, i)
if self[j] == key:
return j
elif self[j] is None or i >= self.length:
return None
else:
i += 1
def getNum(char):
char2num = str.maketrans("ACGT", "1234")
return int(char.translate(char2num), 5)
if __name__ == '__main__':
n = int(eval(input()))
T = HashTable(1046527)
C = [input().split(" ") for i in range(n)]
#C = map(lambda x:(x[0], getNum(x[1])), C)
for command, char in C:
num = getNum(char)
if command == "insert":
T.insert(num)
else:
if T.search(num) is None:
print("no")
else:
print("yes")
| # -*- coding: utf-8 -*-
class HashTable(list):
def __init__(self, length):
list.__init__(self)
self.length = length
self[:] = [None] * length
def h1(self, key):
return key % self.length
def h2(self, key):
return 1 + (key % (self.length - 1))
def h(self, key, i):
return (self.h1(key) + i*self.h2(key)) % self.length
def insert(self, key):
i = 0
while True:
j = self.h(key, i)
if self[j] is None:
self[j] = key
return j
else:
i += 1
def search(self, key):
i = 0
while True:
j = self.h(key, i)
if self[j] == key:
return j
elif self[j] is None or i >= self.length:
return None
else:
i += 1
def getNum(char):
char2num = str.maketrans("ACGT", "1234")
return int(char.translate(char2num), 5)
if __name__ == '__main__':
n = int(eval(input()))
T = HashTable(1046527)
C = [input().split(" ") for i in range(n)]
for command, char in C:
num = getNum(char)
if command[0] == "i":
T.insert(num)
else:
if T.search(num) is None:
print("no")
else:
print("yes")
| p02269 |
# -*- coding: utf-8 -*-
class HashTable(list):
def __init__(self, length):
list.__init__(self)
self.length = length
self[:] = [None] * length
def h1(self, key):
return key % self.length
def h2(self, key):
return 1 + (key % (self.length - 1))
def h(self, key, i):
return (self.h1(key) + i*self.h2(key)) % self.length
def insert(self, key):
i = 0
while True:
j = self.h(key, i)
if self[j] is None:
self[j] = key
return j
else:
i += 1
def search(self, key):
i = 0
while True:
j = self.h(key, i)
if self[j] == key:
return j
elif self[j] is None or i >= self.length:
return None
else:
i += 1
def getNum(char):
char2num = str.maketrans("ACGT", "1234")
return int(char.translate(char2num), 5)
if __name__ == '__main__':
n = int(eval(input()))
T = HashTable(1046527)
C = [input().split(" ") for i in range(n)]
for command, char in C:
num = getNum(char)
if command[0] == "i":
T.insert(num)
else:
if T.search(num) is None:
print("no")
else:
print("yes")
| # -*- coding: utf-8 -*-
class HashTable(list):
def __init__(self, length):
list.__init__(self)
self.length = length
self[:] = [None] * length
def h(self, key, i):
h1 = key % self.length
h2 = 1 + (key % (self.length - 1))
return (h1 + i*h2) % self.length
def insert(self, key):
i = 0
while True:
#print(i)
j = self.h(key, i)
if self[j] is None:
self[j] = key
return j
else:
i += 1
def search(self, key):
i = 0
while True:
#print(i)
j = self.h(key, i)
if self[j] == key:
return j
elif self[j] is None or i >= self.length:
return None
else:
i += 1
def getNum(char):
char2num = str.maketrans("ACGT", "1234")
return int(char.translate(char2num), 5)
if __name__ == '__main__':
n = int(eval(input()))
T = HashTable(1046527)
C = [input().split(" ") for i in range(n)]
for command, char in C:
num = getNum(char)
if command[0] == "i":
T.insert(num)
else:
if T.search(num) is None:
print("no")
else:
print("yes")
| p02269 |
# -*- coding: utf-8 -*-
class HashTable(list):
def __init__(self, length):
list.__init__(self)
self.length = length
self[:] = [None] * length
def h(self, key, i):
h1 = key % self.length
h2 = 1 + (key % (self.length - 1))
return (h1 + i*h2) % self.length
def insert(self, key):
i = 0
while True:
#print(i)
j = self.h(key, i)
if self[j] is None:
self[j] = key
return j
else:
i += 1
def search(self, key):
i = 0
while True:
#print(i)
j = self.h(key, i)
if self[j] == key:
return j
elif self[j] is None or i >= self.length:
return None
else:
i += 1
def getNum(char):
char2num = str.maketrans("ACGT", "1234")
return int(char.translate(char2num), 5)
if __name__ == '__main__':
n = int(eval(input()))
T = HashTable(1046527)
C = [input().split(" ") for i in range(n)]
for command, char in C:
num = getNum(char)
if command[0] == "i":
T.insert(num)
else:
if T.search(num) is None:
print("no")
else:
print("yes")
| # -*- coding: utf-8 -*-
class HashTable(list):
def __init__(self, length):
list.__init__(self)
self.length = length
self[:] = [None] * length
def h(self, key, i):
h1 = key % self.length
h2 = 1 + (key % (self.length - 1))
return (h1 + i*h2) % self.length
def insert(self, key):
i = 0
while True:
h1 = key % self.length
h2 = 1 + (key % (self.length - 1))
j = (h1 + i*h2) % self.length
#j = self.h(key, i)
if self[j] is None:
self[j] = key
return j
else:
i += 1
def search(self, key):
i = 0
while True:
h1 = key % self.length
h2 = 1 + (key % (self.length - 1))
j = (h1 + i*h2) % self.length
#j = self.h(key, i)
if self[j] == key:
return j
elif self[j] is None or i >= self.length:
return None
else:
i += 1
def getNum(char):
char2num = str.maketrans("ACGT", "1234")
return int(char.translate(char2num), 5)
if __name__ == '__main__':
n = int(eval(input()))
T = HashTable(1046527)
C = [input().split(" ") for i in range(n)]
for command, char in C:
num = getNum(char)
if command[0] == "i":
T.insert(num)
else:
if T.search(num) is None:
print("no")
else:
print("yes")
| p02269 |
import sys
n = int(eval(input()))
dct = []
for line in sys.stdin:
cmd, val = line.strip().split()
if cmd == 'insert':
dct.append(val)
else:
if val in dct:
print('yes')
else:
print('no')
| import sys
n = int(eval(input()))
dct = set()
for line in sys.stdin:
cmd, val = line.strip().split()
if cmd == 'insert':
dct.add(val)
else:
if val in dct:
print('yes')
else:
print('no')
| p02269 |
import sys
n = int(eval(input()))
htable = [0 for _ in range(16777216)]
def to_int(s):
if s == 'A':
return 1
elif s == 'C':
return 2
elif s == 'G':
return 3
else:
return 4
def to_hash(string):
h = 0
for i, s in enumerate(string):
ints = to_int(s)
h += 4**i * ints
return h
def insert(string):
h = to_hash(string)
htable[h] = 1
def find(string):
h = to_hash(string)
if htable[h]:
print('yes')
else:
print('no')
for line in sys.stdin:
cmd, string = line.strip().split()
if cmd == 'insert':
insert(string)
else:
find(string)
| import sys
htable = [0] * 16777216
def to_int(s):
if s == 'A':
return 1
elif s == 'C':
return 2
elif s == 'G':
return 3
else:
return 4
def to_hash(string):
h = 0
for i, s in enumerate(string):
ints = to_int(s)
h += 4**i * ints
return h
def insert(string):
h = to_hash(string)
htable[h] = 1
def find(string):
h = to_hash(string)
if htable[h]:
print('yes')
else:
print('no')
if __name__ == '__main__':
n = int(eval(input()))
for line in sys.stdin:
cmd, string = line.strip().split()
if cmd == 'insert':
insert(string)
else:
find(string)
| p02269 |
from collections import deque
import bisect
n = int(eval(input()))
d = []
for i in range(n):
c, s = input().split()
if c == "insert":
d.insert(bisect.bisect_left(d, s), s)
else:
j = bisect.bisect_left(d, s)
if j < len(d) and d[j] == s:
print("yes")
else:
print("no")
| n = int(eval(input()))
d = {}
for i in range(n):
c, s = input().split()
if c == "insert":
d[s] = 0
else:
if s in d:
print("yes")
else:
print("no")
| p02269 |
def binary_search(dic, word, imin, imax):
if imax < imin:
return "no"
imid = imin + (imax - imin) // 2
if dic[imid] > word:
return binary_search(dic, word, imin, imid - 1)
elif dic[imid] < word:
return binary_search(dic, word, imid + 1, imax)
else:
return "yes"
n = int(eval(input()))
dictionary = []
for _ in range(n):
cmd, arg = input().split()
if cmd == "insert":
dictionary.append(arg)
dictionary.sort()
elif cmd == "find":
print((binary_search(dictionary, arg, 0, len(dictionary) - 1))) | n = int(eval(input()))
dictionary = set()
for _ in range(n):
cmd, arg = input().split()
if cmd == "insert":
dictionary.add(arg)
elif cmd == "find":
if arg in dictionary:
print("yes")
else:
print("no") | p02269 |
#http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_4_C&lang=jp
#??????
if __name__ == "__main__":
n_line = int(eval(input()))
input_list = [tuple(input().split()) for i in range(n_line)]
l = []
for c, s in input_list:
if c == "insert":
l.append(s)
else:
if s in l:
print("yes")
else:
print("no") | #http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_4_C&lang=jp
#??????
if __name__ == "__main__":
n_line = int(eval(input()))
input_list = [tuple(input().split()) for i in range(n_line)]
l = set([])
for c, s in input_list:
if c == "insert":
l.add(s)
else:
if s in l:
print("yes")
else:
print("no") | p02269 |
#http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_4_C&lang=jp
#??????
if __name__ == "__main__":
n_line = int(eval(input()))
input_list = [tuple(input().split()) for i in range(n_line)]
dict_list = [s if c == "insert" else "" for c, s in input_list ]
search_list = [(i,l[1]) for i,l in enumerate(input_list) if l[0] == "find"]
ans_list = ["yes" if s in dict_list[:i] else "no" for i, s in search_list]
print(("\n".join(ans_list))) | #http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_4_C&lang=jp
#??????
if __name__ == "__main__":
n_line = int(eval(input()))
input_list = [tuple(input().split()) for i in range(n_line)]
l = set([])
for c, s in input_list:
if c == "insert":
l.add(s)
else:
if s in l:
print("yes")
else:
print("no") | p02269 |
class Dict(object):
m1 = 2 ** 24 - 1
m2 = 3
def __init__(self):
self._dict = ["" for _ in range(self.m1)]
def insert(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == "":
self._dict[ix] = k
return
else:
i += 1
def find(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == k:
return ix
elif self._dict[ix] == "":
return -1
else:
i += 1
def _h(self, k, i):
return self._h1(k) + i * self._h2(k)
def _h1(self, k):
return k % self.m1
def _h2(self, k):
return k % self.m2 + 1
def to_int(s):
_s = s[::]
ret = 0
i = 1
for e in _s:
if e == 'A':
ret += 1 * i
elif e == 'C':
ret += 2 * i
elif e == 'G':
ret += 3 * i
elif e == 'T':
ret += 4 * i
i *= 4
return ret
if __name__ == '__main__':
n = int(eval(input()))
d = Dict()
for _ in range(n):
cmd, val = input().split()
if cmd == "insert":
d.insert(to_int(val))
else:
ans = "yes" if d.find(to_int(val)) != -1 else "no"
print(ans) | class Dict(object):
m1 = 2 ** 24 - 1
m2 = m1 - 1
def __init__(self):
self._dict = ["" for _ in range(self.m1)]
def insert(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == "":
self._dict[ix] = k
return
else:
i += 1
def find(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == k:
return ix
elif self._dict[ix] == "":
return -1
else:
i += 1
def _h(self, k, i):
return self._h1(k) + i * self._h2(k)
def _h1(self, k):
return k % self.m1
def _h2(self, k):
return k % self.m2 + 1
def to_int(s):
_s = s[::]
ret = 0
i = 1
for e in _s:
if e == 'A':
ret += 1 * i
elif e == 'C':
ret += 2 * i
elif e == 'G':
ret += 3 * i
elif e == 'T':
ret += 4 * i
i *= 4
return ret
if __name__ == '__main__':
n = int(eval(input()))
d = Dict()
for _ in range(n):
cmd, val = input().split()
if cmd == "insert":
d.insert(to_int(val))
else:
ans = "yes" if d.find(to_int(val)) != -1 else "no"
print(ans) | p02269 |
class Dict(object):
m1 = 1046527
m2 = m1 - 1
def __init__(self):
self._dict = ["" for _ in range(self.m1)]
def insert(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == "":
self._dict[ix] = k
return
else:
i += 1
def find(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == k:
return ix
elif self._dict[ix] == "":
return -1
else:
i += 1
def _h(self, k, i):
return (self._h1(k) + i * self._h2(k)) % self.m1
def _h1(self, k):
return k % self.m1
def _h2(self, k):
return k % self.m2 + 1
def to_int(s):
ret = 0
i = 1
for j in range(len(s)):
e = s[len(s) - j - 1]
if e == 'A':
ret += 1 * i
elif e == 'C':
ret += 2 * i
elif e == 'G':
ret += 3 * i
elif e == 'T':
ret += 4 * i
i *= 4
return ret
if __name__ == '__main__':
n = int(eval(input()))
d = Dict()
for _ in range(n):
cmd, val = input().split()
if cmd == "insert":
d.insert(to_int(val))
else:
ans = "yes" if d.find(to_int(val)) != -1 else "no"
print(ans) | class Dict(object):
m1 = 1046527
m2 = m1 - 1
def __init__(self):
self._dict = ["" for _ in range(self.m1)]
def insert(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == "":
self._dict[ix] = k
return
else:
i += 1
def find(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == k:
return ix
elif self._dict[ix] == "":
return -1
else:
i += 1
def _h(self, k, i):
return (self._h1(k) + i * self._h2(k)) % self.m1
def _h1(self, k):
return k % self.m1
def _h2(self, k):
return k % self.m2 + 1
def to_int(s):
ret = 0
i = 1
for j in range(len(s)):
e = s[len(s) - j - 1]
if e == 'A':
ret += 1 * i
elif e == 'C':
ret += 2 * i
elif e == 'G':
ret += 3 * i
elif e == 'T':
ret += 4 * i
i *= 5
return ret
if __name__ == '__main__':
n = int(eval(input()))
d = Dict()
for _ in range(n):
cmd, val = input().split()
if cmd == "insert":
d.insert(to_int(val))
else:
ans = "yes" if d.find(to_int(val)) != -1 else "no"
print(ans) | p02269 |
class Dict(object):
m1 = 1046527
m2 = m1 - 1
def __init__(self):
self._dict = [""] * self.m1
def insert(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == "":
self._dict[ix] = k
return
else:
i += 1
def find(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == k:
return True
elif self._dict[ix] == "":
return False
else:
i += 1
return False
def _h(self, k, i):
return (self._h1(k) + i * self._h2(k)) % self.m1
def _h1(self, k):
return k % self.m1
def _h2(self, k):
return k % self.m2 + 1
def to_int(s):
ret = 0
i = 1
for j in range(len(s)):
e = s[len(s) - j - 1]
if e == 'A':
ret += 1 * i
elif e == 'C':
ret += 2 * i
elif e == 'G':
ret += 3 * i
elif e == 'T':
ret += 4 * i
i *= 5
return ret
if __name__ == '__main__':
n = int(eval(input()))
d = Dict()
for _ in range(n):
cmd, val = input().split()
if cmd == "insert":
d.insert(to_int(val))
else:
ans = "yes" if d.find(to_int(val)) else "no"
print(ans) | class Dict(object):
m1 = 1046527
m2 = m1 - 1
def __init__(self):
self._dict = [""] * self.m1
def insert(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == "":
self._dict[ix] = k
return
else:
i += 1
def find(self, k):
i = 0
while True:
ix = self._h(k, i)
if self._dict[ix] == k:
return True
elif self._dict[ix] == "":
return False
else:
i += 1
return False
def _h(self, k, i):
return (self._h1(k) + i * self._h2(k)) % self.m1
def _h1(self, k):
return k % self.m1
def _h2(self, k):
return k % self.m2 + 1
def to_int(s):
ret = 0
i = 1
for j in range(len(s)):
e = s[len(s) - j - 1]
if e == 'A':
ret += 1 * i
elif e == 'C':
ret += 2 * i
elif e == 'G':
ret += 3 * i
elif e == 'T':
ret += 4 * i
i *= 5
return ret
if __name__ == '__main__':
n = int(eval(input()))
d = Dict()
for _ in range(n):
cmd, val = input().split()
if cmd[0] == "i":
d.insert(to_int(val))
else:
ans = "yes" if d.find(to_int(val)) else "no"
print(ans) | p02269 |
m1 = 1046527
m2 = m1 - 1
_dict = [""] * m1
def insert(k):
i = 0
while True:
ix = _h(k, i)
if _dict[ix] == "":
_dict[ix] = k
return
else:
i += 1
def find(k):
i = 0
while True:
ix = _h(k, i)
if _dict[ix] == k:
return True
elif _dict[ix] == "":
return False
else:
i += 1
return False
def _h(k, i):
return (_h1(k) + i * _h2(k)) % m1
def _h1(k):
return k % m1
def _h2(k):
return k % m2 + 1
def to_int(s):
ret = 0
i = 1
for j in range(len(s)):
e = s[len(s) - j - 1]
if e == 'A':
ret += 1 * i
elif e == 'C':
ret += 2 * i
elif e == 'G':
ret += 3 * i
elif e == 'T':
ret += 4 * i
i *= 5
return ret
if __name__ == '__main__':
n = int(eval(input()))
for _ in range(n):
cmd, val = input().split()
if cmd[0] == "i":
insert(to_int(val))
else:
ans = "yes" if find(to_int(val)) else "no"
print(ans) | m1 = 1046527
_dict = [""] * m1
def insert(k):
i = 0
while True:
ix = _h(k, i)
if _dict[ix] == "":
_dict[ix] = k
return
else:
i += 1
def find(k):
i = 0
while True:
ix = _h(k, i)
if _dict[ix] == k:
return True
elif _dict[ix] == "":
return False
else:
i += 1
return False
def _h(k, i):
return ((k % m1) + i * (1 + k % (m1 - 1))) % m1
def to_int(s):
ret = 0
i = 1
for j in range(len(s)):
e = s[len(s) - j - 1]
if e == 'A':
ret += 1 * i
elif e == 'C':
ret += 2 * i
elif e == 'G':
ret += 3 * i
elif e == 'T':
ret += 4 * i
i *= 5
return ret
if __name__ == '__main__':
n = int(eval(input()))
for _ in range(n):
cmd, val = input().split()
if cmd[0] == "i":
insert(to_int(val))
else:
ans = "yes" if find(to_int(val)) else "no"
print(ans) | p02269 |
m1 = 1046527
_dict = [""] * m1
def insert(k):
i = 0
while True:
ix = _h(k, i)
if _dict[ix] == "":
_dict[ix] = k
return
else:
i += 1
def find(k):
i = 0
while True:
ix = _h(k, i)
if _dict[ix] == k:
return True
elif _dict[ix] == "":
return False
else:
i += 1
return False
def _h(k, i):
return ((k % m1) + i * (1 + k % (m1 - 1))) % m1
def getChar(ch):
if ch == 'A':
return 1
elif ch == 'C':
return 2
elif ch == 'G':
return 3
elif ch == 'T':
return 4
else:
return 0
def getKey(strings):
Sum = 0
p = 1
for i in range(len(strings)):
Sum += p * getChar(strings[i])
p *= 5
return Sum
def to_int(s):
ret = 0
i = 1
for j in range(len(s)):
e = s[len(s) - j - 1]
if e == 'A':
ret += 1 * i
elif e == 'C':
ret += 2 * i
elif e == 'G':
ret += 3 * i
elif e == 'T':
ret += 4 * i
i *= 5
return ret
if __name__ == '__main__':
n = int(eval(input()))
for _ in range(n):
cmd, val = input().split()
if cmd[0] == "i":
insert(getKey(val))
else:
ans = "yes" if find(getKey(val)) else "no"
print(ans) | M = 1046527
L = 14
H = [""] * M
def getChar(ch):
if ch == 'A':
return 1
elif ch == 'C':
return 2
elif ch == 'G':
return 3
elif ch == 'T':
return 4
else:
return 0
def getKey(strings):
Sum = 0
p = 1
for i in range(len(strings)):
Sum += p * getChar(strings[i])
p *= 5
return Sum
def h1(key):
return key % M
def h2(key):
return 1 + (key % (M-1))
def find(strings):
key = getKey(strings)
i = 0
while True:
h = (h1(key) + i * h2(key)) % M
if H[h] == strings:
return 1
elif len(H[h]) == 0:
return 0
else:
i += 1
return 0
def insert(strings):
key = getKey(strings)
i = 0
while True:
h = (h1(key) + i * h2(key)) % M
if H[h] == strings:
return 1
elif len(H[h]) == 0:
H[h] = strings
return 0
else:
i += 1
return 0
def main():
n = eval(input())
for i in range(n):
com = input().split()
if com[0][0] == 'i':
insert(com[1])
else:
if find(com[1]):
print('yes')
else:
print('no')
return 0
main() | p02269 |
class Node():
def __init__(self, data):
# string
self.data = data
self.children = dict()
class Tries():
def __init__(self):
self.head = Node("*")
def add(self, string):
nodelist = [Node(char) for char in string]
cur_node = self.head
for node in nodelist:
char = node.data
if char not in cur_node.children:
cur_node.children[char] = node
cur_node = cur_node.children[char]
else:
cur_node = cur_node.children[char]
cur_node.children["*"] = 0
def _add(self, string):
'''
deprecated
'''
nodelist = [Node(char) for char in string]
cur_node = self.head
i = 0
while(i < len(nodelist)):
node = nodelist[i]
char = node.data
if char not in cur_node.children:
cur_node.children[char] = nodelist[i]
cur_node = cur_node.children[char]
else:
# cur_node.children[char]
cur_node = cur_node.children[char]
i += 1
def find(self, string):
i = 0
cur_node = self.head
while(i <= len(string)-1):
char = string[i]
if char in cur_node.children:
cur_node = cur_node.children[char]
i += 1
else:
return False
if cur_node.children.get("*") == None:
return False
return True
if __name__ == "__main__":
n = int(eval(input()))
ops = []
words = []
for _ in range(n):
op, word = input().split()
ops.append(op)
words.append(word)
tries = Tries()
for op, word in zip(ops, words):
if op=='insert':
tries.add(word)
else:
if tries.find(word)==True:
print("yes")
else:
print("no")
| if __name__ == "__main__":
n = int(eval(input()))
ops = []
words = []
for _ in range(n):
op, word = input().split()
ops.append(op)
words.append(word)
db = set()
for op, word in zip(ops, words):
if op=='insert':
db.add(word)
else:
if word in db:
print("yes")
else:
print("no")
| p02269 |
class Hash:
def __init__(self):
self.size = 1046527
self.l = [0] * self.size
def insert_key(self, st):
i = 0
while True:
j = self.h(st, i)
if self.l[j] == 0:
self.l[j] = st
#print("inserted")
return
else:
i = i+1
def find_key(self, st):
i = 0
while True:
j = self.h(st, i)
if self.l[j] == st:
return "yes"
elif self.l[j] == 0 or (i >= self.size):
return "no"
else:
i += 1
def h1(self, key):
return sum([ord(c) for c in key]) % self.size
def h2(self, key):
return 1 + sum([ord(c) for c in key]) % ( self.size - 1 )
def h (self, key, i):
return (self.h1(key) + i* self.h2(key)) % self.size
#main
n = int(eval(input()))
hash = Hash()
for _ in range(n):
ope, st = input().split()
if ope == "insert":
hash.insert_key(st)
elif ope == "find":
print((hash.find_key(st))) | dic ={}
n = int(eval(input()))
for _ in range(n):
com, word = input().split()
if com =="insert":
dic[word] = True
elif com =='find':
print(("yes" if word in dic else "no"))
| p02269 |
def main():
n = int(eval(input()))
dictionary = set()
for _ in range(n):
order, code = input().split()
if order == 'insert':
dictionary.add(code)
elif order == 'find':
if code in dictionary:
print('yes')
else:
print('no')
else:
raise Exception('InputError')
if __name__ == '__main__':
main() | def main():
n = int(eval(input()))
dictionary = {}
for _ in range(n):
order, code = input().split()
if order == 'insert':
dictionary[code] = 1
elif order == 'find':
if code in dictionary:
print('yes')
else:
print('no')
else:
raise Exception('InputError')
if __name__ == '__main__':
main() | p02269 |
n=eval(input())
d=[]
for x in range(n):
cmd, st = list(map(str, input().split()))
if cmd == "insert":
d.append(st)
elif cmd == "find":
print('yes' if st in d else 'no') | n=eval(input())
d=set()
for x in range(n):
cmd, st = list(map(str, input().split()))
if cmd == "insert":
d.add(st)
elif cmd == "find":
print('yes' if st in d else 'no') | p02269 |
N=int(eval(input()))
dict=[]
for i in range(N):
a=input().split()
if a[0]=="insert":
dict.append(a[1])
elif a[0]=="find":
if a[1] in dict:
print("yes")
else:
print("no") | # coding: utf-8
# Here your code !
N=int(eval(input()))
dict={}
for i in range(N):
a,b=input().split()
if a=="insert":
dict[b]=i
else:
if b in dict:
print("yes")
else:
print("no") | p02269 |
import sys
from collections import deque
n = int(eval(input()))
command = sys.stdin.readlines()
Q = deque()
for i in range(n):
a,b = command[i].split()
if a == "insert":
Q.append(b)
else:
if b in Q:
print("yes")
else:
print("no") | import sys
n = int(eval(input()))
command = sys.stdin.readlines()
Q = {}
for i in range(n):
a,b = command[i].split()
if a == "insert":
Q[b] = 0
else:
if b in list(Q.keys()):
print("yes")
else:
print("no") | p02269 |
import sys
n = int(eval(input()))
command = sys.stdin.readlines()
Q = {}
for i in range(n):
a,b = command[i].split()
if a == "insert":
Q[b] = 0
else:
if b in set(Q.keys()):
print("yes")
else:
print("no") | n = int(eval(input()))
dictionary = {}
for i in range(n):
a = input().split()
if a[0] == "insert":
dictionary[a[1]] = 0
if a[0] == "find":
if a[1] in dictionary:
print("yes")
else:
print("no") | p02269 |
n = int(eval(input()))
dictionary = {}
for i in range(n):
a = input().split()
if a[0] == "insert":
dictionary[a[1]] = 0
if a[0] == "find":
if a[1] in dictionary:
print("yes")
else:
print("no") | import sys
n = int(eval(input()))
dictionary = {}
k = sys.stdin.readlines()
for j in k:
i = j.split()
if i[0] == "insert":
dictionary[i[1]] = 0
else:
if i[1] in dictionary:
print("yes")
else:
print("no")
| p02269 |
n = int(input())
a_dict = [[],[],[],[],[]]
c_dict = [[],[],[],[],[]]
t_dict = [[],[],[],[],[]]
g_dict = [[],[],[],[],[]]
for i in range(n):
cmd = input().split()
char = cmd[1]
if cmd[0] == "insert":
if char[0] == "A":
if len(char) == 1:
a_dict[0].append(char)
elif char[1] == "A":
a_dict[1].append(char)
elif char[1] == "T":
a_dict[2].append(char)
elif char[1] == "C":
a_dict[3].append(char)
else:
a_dict[4].append(char)
elif char[0] == "T":
if len(char) == 1:
t_dict[0].append(char)
elif char[1] == "A":
t_dict[1].append(char)
elif char[1] == "T":
t_dict[2].append(char)
elif char[1] == "C":
t_dict[3].append(char)
else:
t_dict[4].append(char)
elif char[0] == "C":
if len(char) == 1:
c_dict[0].append(char)
elif char[1] == "A":
c_dict[1].append(char)
elif char[1] == "T":
c_dict[2].append(char)
elif char[1] == "C":
c_dict[3].append(char)
else:
c_dict[4].append(char)
else:
if len(char) == 1:
g_dict[0].append(char)
elif char[1] == "A":
g_dict[1].append(char)
elif char[1] == "T":
g_dict[2].append(char)
elif char[1] == "C":
g_dict[3].append(char)
else:
g_dict[4].append(char)
else:
if char[0] == "A":
if len(char) == 1:
if char in a_dict[0]:
print("yes")
else:
print("no")
elif char[1] == "A":
if char in a_dict[1]:
print("yes")
else:
print("no")
elif char[1] == "T":
if char in a_dict[2]:
print("yes")
else:
print("no")
elif char[1] == "C":
if char in a_dict[3]:
print("yes")
else:
print("no")
else:
if char in a_dict[4]:
print("yes")
else:
print("no")
elif char[0] == "T":
if len(char) == 1:
if char in t_dict[0]:
print("yes")
else:
print("no")
elif char[1] == "A":
if char in t_dict[1]:
print("yes")
else:
print("no")
elif char[1] == "T":
if char in t_dict[2]:
print("yes")
else:
print("no")
elif char[1] == "C":
if char in t_dict[3]:
print("yes")
else:
print("no")
else:
if char in t_dict[4]:
print("yes")
else:
print("no")
elif char[0] == "C":
if len(char) == 1:
if char in c_dict[0]:
print("yes")
else:
print("no")
elif char[1] == "A":
if char in c_dict[1]:
print("yes")
else:
print("no")
elif char[1] == "T":
if char in c_dict[2]:
print("yes")
else:
print("no")
elif char[1] == "C":
if char in c_dict[3]:
print("yes")
else:
print("no")
else:
if char in c_dict[4]:
print("yes")
else:
print("no")
else:
if len(char) == 1:
if char in g_dict[0]:
print("yes")
else:
print("no")
elif char[1] == "A":
if char in g_dict[1]:
print("yes")
else:
print("no")
elif char[1] == "T":
if char in g_dict[2]:
print("yes")
else:
print("no")
elif char[1] == "C":
if char in g_dict[3]:
print("yes")
else:
print("no")
else:
if char in g_dict[4]:
print("yes")
else:
print("no")
| n = int(input())
dic = {}
for i in range(n):
line = input().split()
cmd = line[0]
ope = line[1]
if cmd == "insert":
dic[ope] = 1
else:
try:
dic[ope] == 1
except:
print("no")
else:
print("yes") | p02269 |
from collections import deque
dictionary = deque()
for making in range(int(eval(input()))) :
action = input().split()
if action[0] == 'insert' : dictionary.append(action[1])
else :
if action[1] in dictionary : print('yes')
else : print('no') | from collections import deque
dictionary = set()
for making in range(int(eval(input()))) :
action = input().split()
if action[0] == 'insert' : dictionary.add(action[1])
else :
if action[1] in dictionary : print('yes')
else : print('no') | p02269 |
m = 10000000
NIL = -1
def h1(key):
return key % m
def h2(key):
return 1 + (key % (m - 1))
def h(key, i):
return (h1(key) + i * h2(key)) % m
def insert(t, key):
i = 0
while True:
j = h(key, i)
if t[j] == NIL:
t[j] = key
return j
else:
i += 1
def find(t, key):
i = 0
while True:
j = h(key, i)
if t[j] == key:
return j
elif t[j] == NIL or i >= m:
return NIL
else:
i += 1
def convert(word):
result = ""
for i in word:
if i == "A":
result += "1"
elif i == "T":
result += "2"
elif i == "G":
result += "3"
else:
result += "4"
return int(result)
t = [NIL]*m
n = int(eval(input()))
for i in range(n):
com = input().split()
key = convert(com[1])
if com[0] == "insert":
insert(t, key)
else:
if find(t, key) != NIL:
print("yes")
else:
print("no")
| n = int(eval(input()))
d = set()
for i in range(n):
com = input().split()
if com[0] == "insert":
d.add(com[1])
else:
print(("yes" if com[1] in d else "no"))
| p02269 |
dic=[]
n=int(eval(input()))
cmd=[list(input().split()) for i in range(n)]
for c, l in cmd:
if c=="insert":
dic.append(l)
if c=="find":
if l in dic:
print("yes")
else:
print("no") | dic=set()
n=int(eval(input()))
cmd=[list(input().split()) for i in range(n)]
for c, l in cmd:
if c=="insert":
dic.add(l)
if c=="find":
if l in dic:
print("yes")
else:
print("no") | p02269 |
import sys
from collections import ChainMap
eval(input())
rp = sys.stdin.readlines()
cm = ChainMap()
for i in rp:
if i[0] == 'i':
cm[i[7:]] = 0
else:
if i[5:] in cm:
print('yes')
else:
print('no') | import sys
#from collections import ChainMap
eval(input())
rp = sys.stdin.readlines()
cm = {}#ChainMap()
for i in rp:
if i[0] == 'i':
cm[i[7:]] = 0
else:
if i[5:] in cm:
print('yes')
else:
print('no') | p02269 |
import sys
eval(input())
r = sys.stdin.readlines()
d = {}
for i in r:
if i[0] == 'i':
d[i[7:]] = 0
else:
print(('yes' if i[5:] in d else 'no')) | import sys
eval(input())
r = sys.stdin.readlines()
d = {}
for i in r:
if i[0] == 'i':
d[i[7:]] = 0
else:
if i[5:] in d:
print('yes')
else:
print('no')
#print('yes' if i[5:] in d else 'no') | p02269 |
import sys
eval(input())
r = sys.stdin.readlines()
d = {}
for i in r:
if i[0] == 'i':
d[i[7:]] = 0
else:
if i[5:] in d:
print('yes')
else:
print('no')
#print('yes' if i[5:] in d else 'no') | import sys
eval(input())
r = sys.stdin.readlines()
d = {}
for i in r:
if i[0] == 'i':
d[i[7:]] = 0
else:
if i[5:] in d:
print('yes')
else:
print('no') | p02269 |
n = int(eval(input()))
d = []
for i in range(n):
order = input().split()
if order[0] == 'insert':
d.append(order[1])
else:
if order[1] in d:
print("yes")
else:
print("no") | n = int(eval(input()))
d = {}
for i in range(n):
order = input().split()
if order[0] == 'insert':
d[order[1]] = i
else:
if order[1] in d:
print("yes")
else:
print("no") | p02269 |
n = int(eval(input()))
dic = set()
for i in range(n):
cmd = input().split()
if cmd[0] == "insert":
dic.add(cmd[1])
else:
print(("yes" if cmd[1] in dic else "no")) | import sys
n = int(eval(input()))
dic = set()
for i in range(n):
cmd = sys.stdin.readline().split()
if cmd[0] == "insert":
dic.add(cmd[1])
else:
print(("yes" if cmd[1] in dic else "no")) | p02269 |
#coding:utf-8
#1_4_C
n = int(eval(input()))
dic = []
for i in range(n):
cmd, word = input().split()
if cmd == "find":
if word in dic:
print("yes")
else:
print("no")
else:
dic.append(word) | #coding:utf-8
#1_4_C
n = int(eval(input()))
dic = set()
for i in range(n):
cmd, word = input().split()
if cmd == "find":
if word in dic:
print("yes")
else:
print("no")
else:
dic.add(word) | p02269 |
# -*- coding:utf-8 -*-
import sys
class Hash(object):
def __init__(self, size):
self._array = [None] * size
self._size = size
def _h1(self, key):
return key % self._size
def _h2(self, key):
return 1 + (key % (self._size - 1))
def _hash(self, key, i):
return (self._h1(key) + i * self._h2(key)) % self._size
def insert(self, key, value):
i = 0
while 1:
j = self._hash(key, i)
if self._array[j] is None:
self._array[j] = value
break
else:
i += 1
def find(self, key, value):
i = 0
while 1:
j = self._hash(key, i)
if self._array[j] == value:
return True
elif self._array[j] is None or i >= self._size:
return False
else:
i += 1
def stoi(s):
ret = 0
p = 1
ctoi = {"A": 1, "C": 2, "G": 3, "T": 4}
for c in s:
ret += ctoi[c] * p
p *= 5
return ret
def dictionary(lst):
h = Hash(1046527)
ret = []
for val in lst:
if val[0] == "insert":
h.insert(stoi(val[1]), val[1])
elif val[0] == "find":
if h.find(stoi(val[1]), val[1]):
ret.append("yes")
else:
ret.append("no")
else:
raise ValueError
return ret
if __name__ == "__main__":
lst = [val.split() for val in sys.stdin.read().splitlines()]
n = int(lst.pop(0)[0])
print(("\n".join(dictionary(lst)))) | # -*- coding:utf-8 -*-
import sys
class Hash(object):
def __init__(self, size):
self._array = [None] * size
self._size = size
def _hash(self, key):
return key % self._size
def insert(self, key, value):
j = self._hash(key)
if self._array[j] is None:
self._array[j] = [value]
else:
self._array[j].append(value)
def find(self, key, value):
j = self._hash(key)
if self._array[j] is None:
return False
elif value in self._array[j]:
return True
else:
return False
def stoi(s):
ret = 0
p = 1
ctoi = {"A": 1, "C": 2, "G": 3, "T": 4}
for c in s:
ret += ctoi[c] * p
p *= 7
return ret
def dictionary(lst):
h = Hash(1046527)
ret = []
for val in lst:
if val[0] == "insert":
h.insert(stoi(val[1]), val[1])
elif val[0] == "find":
if h.find(stoi(val[1]), val[1]):
ret.append("yes")
else:
ret.append("no")
else:
raise ValueError
return ret
if __name__ == "__main__":
lst = [val.split() for val in sys.stdin.read().splitlines()]
n = int(lst.pop(0)[0])
print(("\n".join(dictionary(lst)))) | p02269 |
# -*- conding:utf-8 -*-
from collections import deque
q_list = deque()
n = int(eval(input()))
tmp = [input().split() for i in range(n)]
for i in tmp:
cmd, v = i
if cmd == "find":
if v in q_list:
print("yes")
else:
print ("no")
else:
q_list.append(v) | # -*- conding:utf-8 -*-
se = set()
n = int(eval(input()))
tmp = [input().split() for i in range(n)]
for i in tmp:
cmd, v = i
if cmd == "find":
if v in se:
print("yes")
else:
print ("no")
else:
se.add(v) | p02269 |
count=int(input())
l=[]
n=[]
for i in range(count):
a,b=input().split()
if a=='insert':
l.append(b)
elif a=='find':
if b in l:
n.append('yes')
else:
n.append('no')
for i in n:
print(i) | count=int(input())
l=set()
for i in range(count):
a,b=input().split()
if a=='insert':
l.add(b)
elif b in l:
print('yes')
else:
print('no') | p02269 |
import sys
sys.setrecursionlimit(10**6)
# グラフの最長経路が-1か-2かを選べる
N = int(eval(input()))
edge = [[] for _ in range(N)]
INF = 10**18
for _ in range(N-1):
a,b = list(map(int,input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
opposite = 0
max_dist = 0
def f(d,x):
global max_dist,opposite
dx = d[x]
if dx > max_dist:
opposite = x
max_dist = dx
for y in edge[x]:
if d[y] == INF:
d[y] = dx + 1
f(d,y)
# 0からの距離
d = [INF] * N
d[0] = 0
f(d,0)
v = opposite
d = [INF] * N
d[v] = 0
f(d,v)
X = max_dist
ans = 'First' if max_dist%3 != 1 else 'Second'
print(ans) | import sys
sys.setrecursionlimit(10**6)
# グラフの最長経路が-1か-2かを選べる
N = int(eval(input()))
edge = [[] for _ in range(N)]
INF = 10**18
for _ in range(N-1):
a,b = list(map(int,input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
opposite = 0
max_dist = 0
def f(d,x):
global max_dist,opposite
dx = d[x]
if dx > max_dist:
opposite = x
max_dist = dx
for y in edge[x]:
if d[y] == INF:
d[y] = dx + 1
f(d,y)
if N != 1:
# 0からの距離
d = [INF] * N
d[0] = 0
f(d,0)
v = opposite
d = [INF] * N
d[v] = 0
f(d,v)
X = max_dist
ans = 'First' if max_dist%3 != 1 else 'Second'
print(ans)
else:
print('First')
| p03055 |
import sys
sys.setrecursionlimit(10**6)
# グラフの最長経路が-1か-2かを選べる
N = int(eval(input()))
edge = [[] for _ in range(N)]
INF = 10**18
for _ in range(N-1):
a,b = list(map(int,input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
opposite = 0
max_dist = 0
def f(d,x):
global max_dist,opposite
dx = d[x]
if dx > max_dist:
opposite = x
max_dist = dx
for y in edge[x]:
if d[y] == INF:
d[y] = dx + 1
f(d,y)
if N != 1:
# 0からの距離
d = [INF] * N
d[0] = 0
f(d,0)
v = opposite
d = [INF] * N
d[v] = 0
f(d,v)
X = max_dist
ans = 'First' if max_dist%3 != 1 else 'Second'
print(ans)
else:
print('First')
| import sys
sys.setrecursionlimit(10**6)
# グラフの最長経路が-1か-2かを選べる
N = int(eval(input()))
edge = [[] for _ in range(N)]
for _ in range(N-1):
a,b = list(map(int,input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def f(x):
opposite = 0
max_dist = 0
# 最離点と距離とを返す
d = [None]*N
q = [(x,0)]
while q:
x,dx = q.pop()
d[x] = dx
if dx > max_dist:
max_dist = dx
opposite = x
for y in edge[x]:
if d[y] is None:
q.append((y,dx+1))
return opposite,max_dist
if N != 1:
# 0からの距離
v,_ = f(0)
_,max_dist = f(v)
ans = 'First' if max_dist%3 != 1 else 'Second'
print(ans)
else:
print('First')
| p03055 |
###############################################################################
from bisect import bisect_left as binl
def intin():
input_tuple = input().split()
if len(input_tuple) <= 1:
return int(input_tuple[0])
return tuple(map(int, input_tuple))
def intina():
return [int(i) for i in input().split()]
def intinl(count):
return [intin() for _ in range(count)]
def modadd(x, y):
global mod
return (x + y) % mod
def modmlt(x, y):
global mod
return (x * sy) % mod
def lcm(x, y):
while y != 0:
z = x % y
x = y
y = z
return x
def make_linklist(xylist):
linklist = {}
for a, b in xylist:
linklist.setdefault(a, [])
linklist.setdefault(b, [])
linklist[a].append(b)
linklist[b].append(a)
return linklist
def calc_longest_distance(linklist, v=1):
distance_list = {}
distance_count = 0
distance = 0
vlist_previous = set()
vlist = set([v])
nodecount = len(linklist)
while distance_count < nodecount:
vlist_next = set()
for v in vlist:
distance_list[v] = distance
distance_count += 1
vlist_next = vlist_next | ((set(linklist[v]) - vlist_previous))
distance += 1
vlist_previous = vlist
vlist = vlist_next
max_distance = -1
max_v = None
for v, distance in list(distance_list.items()):
if distance > max_distance:
max_distance = distance
max_v = v
return (max_distance, max_v)
def calc_tree_diameter(linklist, v=1):
_, u = calc_longest_distance(linklist, v)
distance, _ = calc_longest_distance(linklist, u)
return distance
###############################################################################
def main():
n = intin()
ablist = intinl(n-1)
linklist = make_linklist(ablist)
diameter = calc_tree_diameter(linklist)
if diameter % 3 == 1:
print('Second')
else:
print('First')
if __name__ == '__main__':
main()
| ###############################################################################
from bisect import bisect_left as binl
def intin():
input_tuple = input().split()
if len(input_tuple) <= 1:
return int(input_tuple[0])
return tuple(map(int, input_tuple))
def intina():
return [int(i) for i in input().split()]
def intinl(count):
return [intin() for _ in range(count)]
def modadd(x, y):
global mod
return (x + y) % mod
def modmlt(x, y):
global mod
return (x * sy) % mod
def lcm(x, y):
while y != 0:
z = x % y
x = y
y = z
return x
def make_linklist(xylist):
linklist = {}
for a, b in xylist:
linklist.setdefault(a, [])
linklist.setdefault(b, [])
linklist[a].append(b)
linklist[b].append(a)
return linklist
def calc_longest_distance(linklist, v=1):
distance_list = {}
distance_count = 0
distance = 0
vlist_previous = []
vlist = [v]
nodecount = len(linklist)
while distance_count < nodecount:
vlist_next = []
for v in vlist:
distance_list[v] = distance
distance_count += 1
vlist_next.extend(linklist[v])
distance += 1
vlist_to_del = vlist_previous
vlist_previous = vlist
vlist = list(set(vlist_next) - set(vlist_to_del))
max_distance = -1
max_v = None
for v, distance in list(distance_list.items()):
if distance > max_distance:
max_distance = distance
max_v = v
return (max_distance, max_v)
def calc_tree_diameter(linklist, v=1):
_, u = calc_longest_distance(linklist, v)
distance, _ = calc_longest_distance(linklist, u)
return distance
###############################################################################
def main():
n = intin()
ablist = intinl(n-1)
linklist = make_linklist(ablist)
diameter = calc_tree_diameter(linklist)
if diameter % 3 == 1:
print('Second')
else:
print('First')
if __name__ == '__main__':
main()
| p03055 |
from collections import deque
def diameter(N, E):#diamete of a tree
V = [-1]*N
V[0] = 0
q = deque([0])
s = 0
while q:
v = q.popleft()
for w in E[v]:
if V[w] == -1:
s = w
V[w] = V[v] + 1
q.append(w)
# s = V.index( max(V))
p = deque([s])
W = [-1]*N
W[s] = 0
while p:
v = p.popleft()
for w in E[v]:
if W[w] == -1:
W[w] = W[v] + 1
p.append(w)
return max(W)
N = int( eval(input()))
E = [ [] for _ in range(N)]
for _ in range(N-1):
a, b = list(map( int, input().split()))
a, b = a-1, b-1
E[a].append(b)
E[b].append(a)
ans = "First"
if diameter(N, E)%3 == 1:
ans = "Second"
print( ans)
| from collections import deque
def diameter(N, E):#diamete of a tree
V = [-1]*N
V[0] = 0
q = deque([0])
# s = 0
while q:
v = q.popleft()
for w in E[v]:
if V[w] == -1:
# s = w
V[w] = V[v] + 1
q.append(w)
s = V.index( max(V))
p = deque([s])
W = [-1]*N
W[s] = 0
while p:
v = p.popleft()
for w in E[v]:
if W[w] == -1:
W[w] = W[v] + 1
p.append(w)
return max(W)
N = int( eval(input()))
E = [ [] for _ in range(N)]
for _ in range(N-1):
a, b = list(map( int, input().split()))
a, b = a-1, b-1
E[a].append(b)
E[b].append(a)
ans = "First"
if diameter(N, E)%3 == 1:
ans = "Second"
print( ans) | p03055 |
import sys
input = sys.stdin.readline
from collections import deque
import marshal
class Graph:
def __init__(self, n, directed=False, decrement=True, destroy=False, edges=[]):
self.n = n
self.directed = directed
self.decrement = decrement
self.destroy = destroy
self.edges = [set() for _ in range(self.n)]
self.parent = [-1]*self.n
self.info = [-1]*self.n
for x, y in edges:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edges[x].add(y)
if self.directed == False:
self.edges[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edges[i] = set([x - 1 for x in adjacent_list])
else:
self.edges[i] = set(adjacent_list)
def bfs(self, start=1, goal=-1, time=0, save=False):
"""
:param start: スタート地点
:param goal: ゴール地点
:param save: True = 前回の探索結果を保持する
:return: （ループがあっても）最短距離。存在しなければ -1
"""
if self.decrement:
start -= 1
goal -= 1
if not save:
self.parent = [-1] * self.n
p, t = start, time
self.parent[p] = -2
next_set = deque([(p, t)])
while next_set:
p, t = next_set.popleft()
for q in self.edges[p]:
if self.parent[q] != -1:
continue
if q == goal:
return t + 1
self.parent[q] = p
next_set.append((q, t + 1))
return -1
def connection_counter(self):
"""
:return: 連結成分の個数。有効グラフではあまり意味がない。
"""
cnt = 0
self.parent = [-1] * self.n
for start in range(self.n):
if self.parent[start] == -1:
cnt += 1
self.bfs(start + self.decrement, save=True)
return cnt
def distance_list(self, start=1, save=False):
"""
:param start: スタート地点
:return: スタート地点から各点への距離のリスト
"""
dist = [-1]*self.n
if self.decrement:
start -= 1
if not save:
self.parent = [-1] * self.n
p, t = start, 0
self.parent[p] = -2
dist[p] = 0
next_set = deque([(p, t)])
while next_set:
p, t = next_set.popleft()
for q in self.edges[p]:
if self.parent[q] != -1:
continue
dist[q] = t + 1
self.parent[q] = p
next_set.append((q, t + 1))
return dist
def path_list(self, start=1):
"""
:return: スタート地点から最短経路で進んだ時の、各頂点の一個前に訪問する頂点番号
訪問しない場合は -1 を返す
"""
self.distance_list(start)
if self.decrement:
start -= 1
return list(p + self.decrement for p in self.parent[1:])
def most_distant_point(self, start=1, save=False):
"""
計算量 O(N)
:return: (start から最も遠い頂点, 距離)
"""
if not save:
self.parent = [-1] * self.n
res = (start - self.decrement, 0)
temp = 0
for i, dist in enumerate(self.distance_list(start, save=save)):
if dist > temp:
temp = dist
res = (i + self.decrement, dist)
return res
def diameter(self, save=False):
"""
計算量 O(N)
:return: 木の直径（最も離れた二頂点間の距離）を返す
"""
if not save:
self.parent = [-1] * self.n
p = self.most_distant_point(save=save)
res = self.most_distant_point(start=p[0], save=save)
return res[1]
##################################################################################################
N = int(eval(input()))
M = N-1
graph = Graph(N, directed=False, decrement=True, destroy=False)
for _ in range(M):
x, y = list(map(int, input().split()))
graph.add_edge(x, y)
print(("Second" if (graph.diameter()+1)%3==2 else "First")) | class Tree():
def __init__(self, n, decrement=1):
self.n = n
self.edges = [[] for _ in range(n)]
self.root = None
self.depth = [-1]*n
self.size = [1]*n # 部分木のノードの数
self.decrement = decrement
def add_edge(self, u, v):
u, v = u-self.decrement, v-self.decrement
self.edges[u].append(v)
self.edges[v].append(u)
def add_edges(self, edges):
for u, v in edges:
u, v = u-self.decrement, v-self.decrement
self.edges[u].append(v)
self.edges[v].append(u)
def set_root(self, root):
root -= self.decrement
self.root = root
self.par = [-1]*self.n
self.depth[root] = 0
self.order = [root] # 帰りがけに使う
next_set = [root]
while next_set:
p = next_set.pop()
for q in self.edges[p]:
if self.depth[q] != -1: continue
self.par[q] = p
self.depth[q] = self.depth[p]+1
self.order.append(q)
next_set.append(q)
for p in self.order[::-1]:
for q in self.edges[p]:
if self.par[p] == q: continue
self.size[p] += self.size[q]
def diameter(self):
# assert self.root is not None
u = self.depth.index(max(self.depth))
dist = [-1]*self.n
dist[u] = 0
prev = [-1]*self.n
next_set = [u]
while next_set:
p = next_set.pop()
for q in self.edges[p]:
if dist[q] != -1: continue
dist[q] = dist[p]+1
prev[q] = p
next_set.append(q)
d = max(dist)
v = w = dist.index(d)
path = [v+1]
while w != u:
w = prev[w]
path.append(w+self.decrement)
return d, v+self.decrement, u+self.decrement, path
def heavy_light_decomposition(self):
"""
heavy edge を並べてリストにした物を返す (1-indexed if decrement=True)
"""
# assert self.root is not None
self.vid = [-1]*self.n
self.hld = [-1]*self.n
self.head = [-1]*self.n
self.head[self.root] = self.root
self.heavy_node = [-1]*self.n
next_set = [self.root]
for i in range(self.n):
""" for tree graph, dfs ends in N times """
p = next_set.pop()
self.vid[p] = i
self.hld[i] = p+self.decrement
maxs = 0
for q in self.edges[p]:
""" encode direction of Heavy edge into heavy_node """
if self.par[p] == q: continue
if maxs < self.size[q]:
maxs = self.size[q]
self.heavy_node[p] = q
for q in self.edges[p]:
""" determine "head" of heavy edge """
if self.par[p] == q or self.heavy_node[p] == q: continue
self.head[q] = q
next_set.append(q)
if self.heavy_node[p] != -1:
self.head[self.heavy_node[p]] = self.head[p]
next_set.append(self.heavy_node[p])
return self.hld
def lca(self, u, v):
# assert self.head is not None
u, v = u-self.decrement, v-self.decrement
while True:
if self.vid[u] > self.vid[v]: u, v = v, u
if self.head[u] != self.head[v]:
v = self.par[self.head[v]]
else:
return u + self.decrement
def path(self, u, v):
""" u-v 間の最短経路をリストで返す """
p = self.lca(u, v)
u, v, p = u-self.decrement, v-self.decrement, p-self.decrement
R = []
while u != p:
yield u+self.decrement
u = self.par[u]
yield p+self.decrement
while v != p:
R.append(v)
v = self.par[v]
for v in reversed(R):
yield v+self.decrement
def distance(self, u, v):
# assert self.head is not None
p = self.lca(u, v)
u, v, p = u-self.decrement, v-self.decrement, p-self.decrement
return self.depth[u] + self.depth[v] - 2*self.depth[p]
def find(self, u, v, x):
return self.distance(u,x)+self.distance(x,v)==self.distance(u,v)
def path_to_list(self, u, v, edge_query=False):
"""
パス上の頂点の集合を self.hld 上の開区間の集合として表す
ここで、self.hld は heavy edge を並べて数列にしたものである
"""
# assert self.head is not None
u, v = u-self.decrement, v-self.decrement
while True:
if self.vid[u] > self.vid[v]: u, v = v, u
if self.head[u] != self.head[v]:
yield self.vid[self.head[v]], self.vid[v] + 1
v = self.par[self.head[v]]
else:
yield self.vid[u] + edge_query, self.vid[v] + 1
return
def point(self, u):
return self.vid[u-self.decrement]
def subtree_query(self, u):
u -= self.decrement
return self.vid[u], self.vid[u] + self.size[u]
##################################################################################################
import sys
input = sys.stdin.readline
N = int(eval(input()))
T = Tree(N)
for _ in range(N-1):
x, y = list(map(int, input().split()))
T.add_edge(x, y)
T.set_root(1)
print(("Second" if (T.diameter()[0]+1)%3==2 else "First")) | p03055 |
n = int(eval(input()))
tree = {i: [] for i in range(n)}
for _ in range(n-1):
t = input().split()
u, v = int(t[0]), int(t[1])
tree[u-1].append(v-1)
tree[v-1].append(u-1)
a = 0
idx = 0
q = []
q.append(a)
v = [0 for _ in range(n)]
v[a] = 1
while (idx != len(q)):
a = q[idx]
idx += 1
for b in tree[a]:
if (v[b] == 0):
q.append(b)
v[b] = 1
s = a
idx = 0
q = []
q.append([a, 1])
v = [0 for _ in range(n)]
v[a] = 1
while (idx != len(q)):
a = q[idx]
idx += 1
for b in tree[a[0]]:
if (v[b] == 0):
q.append([b, a[1] + 1])
v[b] = 1
l = a[1]
if l%3 == 2:
print("Second")
else:
print("First") | n = int(eval(input()))
tree = [[] for i in range(n)]
for _ in range(n-1):
t = input().split()
u, v = int(t[0]), int(t[1])
tree[u-1].append(v-1)
tree[v-1].append(u-1)
a = 0
idx = 0
q = []
q.append(a)
v = [0 for _ in range(n)]
v[a] = 1
while (idx != len(q)):
a = q[idx]
idx += 1
for b in tree[a]:
if (v[b] == 0):
q.append(b)
v[b] = 1
s = a
idx = 0
q = []
q.append([a, 1])
v = [0 for _ in range(n)]
v[a] = 1
while (idx != len(q)):
a = q[idx]
idx += 1
for b in tree[a[0]]:
if (v[b] == 0):
q.append([b, a[1] + 1])
v[b] = 1
l = a[1]
if l%3 == 2:
print("Second")
else:
print("First") | p03055 |
import queue
n = int(eval(input()))
tree = {i: [] for i in range(n)}
for _ in range(n-1):
t = input().split()
u, v = int(t[0]), int(t[1])
tree[u-1].append(v-1)
tree[v-1].append(u-1)
a = 0
q = queue.Queue()
q.put(a)
v = [0 for _ in range(n)]
v[a] = 1
while (not q.empty()):
a = q.get()
for b in tree[a]:
if (v[b] == 0):
q.put(b)
v[b] = 1
s = a
q = queue.Queue()
q.put([a, 1])
v = [0 for _ in range(n)]
v[a] = 1
while (not q.empty()):
a = q.get()
for b in tree[a[0]]:
if (v[b] == 0):
q.put([b, a[1] + 1])
v[b] = 1
l = a[1]
if l%3 == 2:
print("Second")
else:
print("First")
| import queue
n = int(eval(input()))
tree = {i: [] for i in range(n)}
for _ in range(n-1):
t = input().split()
u, v = int(t[0]), int(t[1])
tree[u-1].append(v-1)
tree[v-1].append(u-1)
a = 0
q = queue.Queue()
q.put(a)
v = [0 for _ in range(n)]
v[a] = 1
while (not q.empty()):
a = q.get()
for b in tree[a]:
if (v[b] == 0 and len(tree[b]) > 1):
q.put(b)
v[b] = 1
s = a
q = queue.Queue()
q.put([a, 1])
v = [0 for _ in range(n)]
v[a] = 1
while (not q.empty()):
a = q.get()
for b in tree[a[0]]:
if (v[b] == 0 and len(tree[b]) > 1):
q.put([b, a[1] + 1])
v[b] = 1
if n <= 3:
l = n
else:
l = a[1] + 2
if l%3 == 2:
print("Second")
else:
print("First") | p03055 |
from collections import deque
N,*L = list(map(int, open(0).read().split()))
dic = [[] for i in range(N+1)]
for i in range(N-1):
a,b = L[2*i],L[2*i+1]
dic[a].append(b)
dic[b].append(a)
q = deque([1])
dist = [-1]*(N+1)
dist[1] = 0
while q:
p = q.popleft()
for v in dic[p]:
if dist[v]==-1:
q.append(v)
dist[v] = dist[p]+1
u = max(list(range(1,N+1)),key=lambda x:dist[x])
q = deque([u])
dist = [-1]*(N+1)
dist[u] = 0
while q:
p = q.popleft()
for v in dic[p]:
if dist[v]==-1:
q.append(v)
dist[v] = dist[p]+1
M = max(dist)
if M%3==1:
print('Second')
else:
print('First') | from collections import deque
N,*L = list(map(int, open(0).read().split()))
dic = [[] for i in range(N+1)]
for a,b in zip(*[iter(L)]*2):
dic[a].append(b)
dic[b].append(a)
q = deque([1])
dist = [-1]*(N+1)
dist[1] = 0
while q:
p = q.popleft()
for v in dic[p]:
if dist[v]==-1:
q.append(v)
dist[v] = dist[p]+1
u = max(list(range(1,N+1)),key=lambda x:dist[x])
q = deque([u])
dist = [-1]*(N+1)
dist[u] = 0
while q:
p = q.popleft()
for v in dic[p]:
if dist[v]==-1:
q.append(v)
dist[v] = dist[p]+1
M = max(dist)
if M%3==1:
print('Second')
else:
print('First') | p03055 |
from collections import deque
N = int(eval(input()))
e = [[] for _ in range(N)]
# 隣接リスト
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
e[a].append(b)
e[b].append(a)
# BFS*2で直径を求める
dist = [-1 for _ in range(N)]
dist[0] = 0
q = deque()
q.append(0)
while q:
v = q.popleft()
d = dist[v]
for nv in [x for x in e[v] if dist[x] == -1]:
dist[nv] = d + 1
q.append(nv)
# 探索終了後
# (v,d)=頂点0から最遠点の頂点番号v,頂点0からの距離d
dist = [-1 for _ in range(N)]
dist[v] = 0
q = deque()
q.append(v)
while q:
w = q.popleft()
d = dist[w]
for nw in [x for x in e[w] if dist[x] == -1]:
dist[nw] = d + 1
q.append(nw)
# 探索終了後
# (w,d)=頂点vから最遠点の頂点番号w,頂点vからの距離d
print(('Second' if d % 3 == 1 else 'First')) | from collections import deque
import sys
input = sys.stdin.readline
N = int(eval(input()))
e = [[] for _ in range(N)]
# 隣接リスト
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
e[a].append(b)
e[b].append(a)
# BFS*2で直径を求める
def bfs(i):
"""
:param i: bfsの始点, 0-indexed
:return: (v,d), iの最遠点vまでの距離d
"""
dist = [-1 for _ in range(N)]
dist[i] = 0
q = deque((i,))
while q:
v = q.popleft()
d = dist[v]
for nv in [x for x in e[v] if dist[x] == -1]:
dist[nv] = d + 1
q.append(nv)
return v, d
x, _ = bfs(0)
_, d = bfs(x)
print(('Second' if d % 3 == 1 else 'First'))
| p03055 |
# coding: utf-8
import sys
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def dijkstra(start):
INF = 10 ** 15
dist = [INF] * (N+1)
dist[start] = 0
que = [(0, start)]
while que:
d, prev = heappop(que)
if dist[prev] < d:
continue
for next in graph[prev]:
d1 = d + 1
if dist[next] > d1:
dist[next] = d1
heappush(que, (d1, next))
return dist
N = ir()
graph = [[] for _ in range(N+1)] # 1-indexed
for _ in range(N-1):
a, b = lr()
graph[a].append(b)
graph[b].append(a)
# １を根とする
dist = dijkstra(1)
dist = sorted([(x, i) for i, x in enumerate(dist)], reverse=True)
new_root = dist[1][1]
dist = dijkstra(new_root)
diameter = max(dist[1:]) + 1
bl = diameter % 3 != 2
print(('First' if bl else 'Second'))
# 22 | # coding: utf-8
import sys
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def tree_diameter(graph): # 木の直径
def dijkstra(start):
INF = 10 ** 15
dist = [INF] * (N+1)
dist[start] = 0
que = [(0, start)]
length = 0; far = 0
while que:
d, prev = heappop(que)
if dist[prev] < d:
continue
for next in graph[prev]:
d1 = d + 1
if dist[next] > d1:
dist[next] = d1
if d1 > length:
length = d1; far = next
heappush(que, (d1, next))
return length, far
_, f = dijkstra(1)
l, f = dijkstra(f)
return l
N = ir()
graph = [[] for _ in range(N+1)] # 1-indexed
for _ in range(N-1):
a, b = lr()
graph[a].append(b)
graph[b].append(a)
daiameter = tree_diameter(graph)
bl = daiameter % 3 != 1
print(('First' if bl else 'Second'))
| p03055 |
from collections import defaultdict
import queue
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
class breadth(object):
def __init__(self, graph, s):
self.g = graph.graph
self.dist = defaultdict(lambda: float('inf'))
self.dist[s] = 0
self.visit = ["no" for i in range(len(graph) + 1)]
self.visit[s] = "yes"
self.Q = queue.Queue()
self.Q.put([self.dist[s], s])
while not self.Q.empty():
dist_u, u = self.Q.get()
for v in self.g[u]:
if self.visit[v] == "yes":
continue
else:
self.dist[v] = dist_u + 1
self.visit[v] = "yes"
self.Q.put([self.dist[v], v])
N = int(eval(input()))
if N == 1:
print("First")
else:
g_a = Graph()
for i in range(N - 1):
a, b = getlist()
g_a.add_edge(a, b)
g_a.add_edge(b, a)
s = 1
E = breadth(g_a, s)
x = 0
for i in E.dist:
if E.dist[i] > x:
x = E.dist[i]
y = i
F = breadth(g_a, y)
x = 0
for i in F.dist:
if F.dist[i] > x:
x = F.dist[i]
y = i
if x % 3 == 0 or x % 3 == 2:
print("First")
else:
print("Second")
| from collections import defaultdict
from collections import deque
def getlist():
return list(map(int, input().split()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, a, b):
self.graph[a].append(b)
class breadth(object):
def __init__(self, graph, s):
self.g = graph.graph
self.dist = defaultdict(lambda: float('inf'))
self.dist[s] = 0
self.visit = ["no" for i in range(len(graph) + 1)]
self.visit[s] = "yes"
self.Q = deque()
self.Q.append([self.dist[s], s])
while self.Q:
dist_u, u = self.Q.popleft()
for v in self.g[u]:
if self.visit[v] == "yes":
continue
else:
self.dist[v] = dist_u + 1
self.visit[v] = "yes"
self.Q.append([self.dist[v], v])
N = int(eval(input()))
if N == 1:
print("First")
else:
g_a = Graph()
for i in range(N - 1):
a, b = getlist()
g_a.add_edge(a, b)
g_a.add_edge(b, a)
s = 1
E = breadth(g_a, s)
x = 0
for i in E.dist:
if E.dist[i] > x:
x = E.dist[i]
y = i
F = breadth(g_a, y)
x = 0
for i in F.dist:
if F.dist[i] > x:
x = F.dist[i]
y = i
if x % 3 == 0 or x % 3 == 2:
print("First")
else:
print("Second")
| p03055 |
import sys
input = sys.stdin.buffer.readline
from collections import deque
def main():
N = int(eval(input()))
if N == 1:
print("First")
exit()
edge = [[] for _ in range(N)]
for _ in range(N-1):
a,b = list(map(int,input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
d = 0
for st in range(N):
dep = [-1 for _ in range(N)]
dep[st] = 0
q = deque([st])
while q:
now = q.popleft()
for fol in edge[now]:
if dep[fol] == -1:
dep[fol] = dep[now]+1
q.append(fol)
d = max(d,max(dep))
if d%3 == 1:
print("Second")
else:
print("First")
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
from collections import deque
def main():
N = int(eval(input()))
if N == 1:
print("First")
exit()
edge = [[] for _ in range(N)]
for _ in range(N-1):
a,b = list(map(int,input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
dep = [-1 for _ in range(N)]
dep[0] = 0
q = deque([0])
while q:
now = q.popleft()
for fol in edge[now]:
if dep[fol] == -1:
dep[fol] = dep[now]+1
q.append(fol)
st = dep.index(max(dep))
dep = [-1 for _ in range(N)]
dep[st] = 0
q = deque([st])
while q:
now = q.popleft()
for fol in edge[now]:
if dep[fol] == -1:
dep[fol] = dep[now]+1
q.append(fol)
if max(dep)%3 == 1:
print("Second")
else:
print("First")
if __name__ == "__main__":
main()
| p03055 |
import sys
sys.setrecursionlimit(210000)
def s(x,v,d):
r=[d,v]
for u in g[v]:
if u!=x:
t=s(v,u,d+1)
if r[0]<t[0]:r=t
return r
n,*t=list(map(int,open(0).read().split()))
g=[set()for _ in range(n+1)]
for a,b in zip(t[::2],t[1::2]):
g[a].add(b)
g[b].add(a)
print(('SFeicrosntd'[s(0,s(0,1,0)[1],0)[0]%3!=1::2])) | import sys
sys.setrecursionlimit(250000)
def s(x,v,d):
r=[d,v]
for u in g[v]:
if u!=x:
t=s(v,u,d+1)
if r[0]<t[0]:r=t
return r
n,*t=list(map(int,open(0).read().split()))
g=[[]for _ in range(n+1)]
for a,b in zip(t[::2],t[1::2]):
g[a].append(b)
g[b].append(a)
print(('SFeicrosntd'[s(0,s(0,1,0)[1],0)[0]%3!=1::2])) | p03055 |
# encoding: utf-8
import sys
# input = sys.stdin.readline
inf = 10 ** 18
N = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(N - 1)]
cnct = [[] for _ in range(N)]
for ai, bi in ab:
cnct[ai - 1].append(bi - 1)
cnct[bi - 1].append(ai - 1)
# print("#", cnct)
# start from a leaf
for src in range(N):
if len(cnct[src]) > 1: break
# print("#", src)
import heapq
len_max = 0
while True:
q = []
d = [inf] * N
prev = [None] * N
#
heapq.heappush(q, (0, src))
d[src] = 0
while len(q) > 0:
du, u = heapq.heappop(q)
# print("#", du, u)
for dst in cnct[u]:
# print("##", dst)
if d[dst] > du + 1:
d[dst] = du + 1
prev[dst] = u
heapq.heappush(q, (du + 1, dst))
#
if len_max == max(d):
break
elif len_max < max(d):
len_max = max(d)
src = d.index(len_max)
else:
continue
# print("#", len_max)
if len_max % 3 == 1:
print('Second')
else:
print('First') | # encoding: utf-8
import sys
# input = sys.stdin.readline
inf = 10 ** 18
N = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(N - 1)]
cnct = [[] for _ in range(N)]
for ai, bi in ab:
cnct[ai - 1].append(bi - 1)
cnct[bi - 1].append(ai - 1)
# print("#", cnct)
# start from a leaf
for src in range(N):
if len(cnct[src]) > 1: break
# print("#", src)
import heapq
len_max = 0
for i in range(10):
q = []
d = [inf] * N
prev = [None] * N
#
heapq.heappush(q, (0, src))
d[src] = 0
while len(q) > 0:
du, u = heapq.heappop(q)
# print("#", du, u)
for dst in cnct[u]:
# print("##", dst)
if d[dst] > du + 1:
d[dst] = du + 1
prev[dst] = u
heapq.heappush(q, (du + 1, dst))
#
if len_max == max(d):
break
elif len_max < max(d):
len_max = max(d)
src = d.index(len_max)
else:
continue
# print("#", len_max)
if len_max % 3 == 1:
print('Second')
else:
print('First') | p03055 |
# C問題 20分で最長の長さの道の含むノードの数Nに対して
# N%3 == 2ならS, それ以外でFであることまでわかった。
# !!直径rでいうとr%3 ==1 ならS
# しかし、longest path problemはNP hardとか言われた...
# けど、treeであることを考慮に入れて再検索すると行けた。
# ググり力 = 関連ワードを色々入れて試す力 & 関係なさそうなテーマから早く撤退する
# 木の直径というらしい
# 木DP or 適当に初期点W → Wからの最遠点U → Uからの最遠点V でUとVの距離でわかるらしい。
N = int(eval(input()))
#各頂点が繋がってる辺リスト
E = [ [] for _ in range(N)]
for i in range(N-1):
a,b = list(map(int, input().split()))
E[a-1].append(b-1)
E[b-1].append(a-1)
# #入力1
# N= 3
# E= [[1], [0, 2], [1]]
# # 入力2
# N= 6
# E= [[1], [0, 2, 3], [1], [1, 5], [5], [3, 4]]
# # 入力3
# N= 7
# E= [[6, 1], [0], [3, 5], [6, 2], [6], [2], [0, 3, 4]]
def farthest(s):
visited = []
stack = [[s,0]]
best = [s,0]
while len(stack)>0:
# print("visited:",visited)
# print("stack:",stack)
current = stack.pop()#pop(-1)と同じ
currentPosition = current[0]
currentLength = current[1]
# bestの更新
if currentLength > best[1]:
best = [currentPosition, currentLength]
visited.append(currentPosition)
# 繋がっているノードのうち未探索の場所を追加
for position in E[currentPosition]:
if position not in visited:
stack.append([position, currentLength+1])
return best
# print("u,length:",farthest(0))
u = farthest(0)[0]
best = farthest(u)
# print(best)
# v = best[0]
diameter = best[1]
# print(diameter)
ans = "First"
if diameter % 3 == 1:
ans = "Second"
print(ans) | # カンニングして修正
N = int(eval(input()))
#各頂点が繋がってる辺リスト
E = [ [] for _ in range(N)]
for i in range(N-1):
a,b = list(map(int, input().split()))
E[a-1].append(b-1)
E[b-1].append(a-1)
# #入力1
# N= 3
# E= [[1], [0, 2], [1]]
# # 入力2
# N= 6
# E= [[1], [0, 2, 3], [1], [1, 5], [5], [3, 4]]
# # 入力3
# N= 7
# E= [[6, 1], [0], [3, 5], [6, 2], [6], [2], [0, 3, 4]]
def farthest(s):
visited = [False]*N
stack = [[s,0]]
best = [s,0]
while len(stack)>0:
# print("visited:",visited)
# print("stack:",stack)
current = stack.pop()#pop(-1)と同じ
currentPosition = current[0]
currentLength = current[1]
visited[currentPosition] = True
# bestの更新
if currentLength > best[1]:
best = [currentPosition, currentLength]
visited.append(currentPosition)
# 繋がっているノードのうち未探索の場所を追加
for position in E[currentPosition]:
if not visited[position]:
stack.append([position, currentLength+1])
return best
# print("u,length:",farthest(0))
u = farthest(0)[0]
best = farthest(u)
# print(best)
# v = best[0]
diameter = best[1]
# print(diameter)
ans = "First"
if diameter % 3 == 1:
ans = "Second"
print(ans) | p03055 |
N = int(eval(input()))
H = list(map(int, input().split()))
judge = False
for i in range(1, len(H)):
if H[i] - H[i-1] >= 1:
H[i] -= 1
elif H[i] - H[i-1] < 0:
judge = True
break
print(('No' if judge else 'Yes')) | eval(input());a=list(map(int,input().split()));b=sorted(a)
for i,j in zip(a,b):
if abs(i-j)>1: print('No');break
else:
print('Yes') | p02953 |
n = int(eval(input()))
h = list(map(int, input().split()))
flag = 0
for i in range(n-1):
for j in range(i+1, n):
if h[i] > h[j] + 1:
flag = 1
break
if flag == 1:
print("No")
break
if flag == 0:
print("Yes") | n = int(eval(input()))
h = list(map(int, input().split()))
current_max = 0
for i in range(n):
if current_max > h[i] + 1:
print("No")
break
else:
current_max = max(current_max, h[i])
if i == n-1:
print("Yes")
| p02953 |
n = int(eval(input()))
h = list(map(int, input().split()))
answer = 'Yes'
for i in range(n):
if i == (n - 1):
break
index = n - (i + 1)
for j in range(index):
if (h[j] - h[index]) >= 2:
answer = 'No'
break
print(answer)
| n = int(eval(input()))
h = list(map(int, input().split()))
answer = 'Yes'
pre = 0
for i in range(n):
if pre <= h[i]-1:
pre = h[i]-1
elif pre <= h[i]:
pre = h[i]
else:
answer = 'No'
break
print(answer)
| p02953 |
N = int(eval(input()))
H = list(map(int, input().split()))
ans = "Yes"
for i in range(N - 1):
if H[i] > H[i + 1]:
if H[i] - 1 > H[i + 1]:
ans = "No"
else:
H[i] = H[i] - 1
if sorted(H[:i + 1]) != H[:i + 1]:
ans = "No"
print(ans) | N = int(eval(input()))
H = list(map(int, input().split()))
ans = "Yes"
for i in range(0, N - 1):
diff = H[i + 1] - H[i]
if diff >= 1:
H[i + 1] -= 1
elif diff < 0:
ans = "No"
print(ans) | p02953 |
N = int(eval(input()))
H = list(map(int, input().split()))
ans = 0
for i in range(N-1) :
for k in range(i+1, N):
if H[i] - H[k] > 1 :
print('No')
ans = 1
exit()
if ans == 0:
print('Yes')
| N = int(eval(input()))
H = list(map(int, input().split()))
H[0] -= 1
for i in range(N - 1):
if H[i] < H[i+1] :
H[i+1] -= 1
elif H[i] > H[i+1]:
print('No')
exit()
print('Yes')
| p02953 |
def main():
N = int(eval(input()))
A = [int(i) for i in input().split()]
c = 0
if A == sorted(A):
print("Yes")
c += 1
else:
for i, a in enumerate(A):
A[i] = a-1
if A == sorted(A):
print("Yes")
c += 1
break
if c == 0:
print("No")
if __name__ == "__main__":
main()
| def main():
n = int(eval(input()))
h = list(map(int, input().split()))
for i in range(n-1):
if h[i] < h[i+1]:
h[i+1] -= 1
elif h[i] > h[i+1]:
print('No')
exit()
print('Yes')
if __name__ == "__main__":
main()
| p02953 |
n = int(eval(input()))
h = [int(i) for i in input().split()]
flag = 1
for i in range(len(h)-1):
for j in range(i+1,len(h)):
if(h[i]-h[j]>=2):
print("No")
flag=0
break
if(flag==0):
break
if(flag==1):
print("Yes") | n = int(eval(input()))
h = [int(i) for i in input().split()]
flag = 1
temp = h[0]
for i in range(len(h)-1):
if(temp<h[i]):
temp = h[i]
if(temp-h[i+1]>=2):
print("No")
flag=0
break
if(flag==1):
print("Yes") | p02953 |
n = int(eval(input()))
h = list(map(int,input().split()))
a = "Yes"
m = 0
for i in range(n):
if m - h[i] > 1:
a ="No"
break
else:
m = max(m,h[i])
print(a) | n = int(eval(input()))
lis = list(map(int,input().split()))
ans = "Yes"
m = 0
for i in range(n):
if m - lis[i] > 1:
ans = "No"
break
else:
m = max(m,lis[i])
print(ans) | p02953 |
N, *H = list(map(int, open(0).read().split()))
cnt = 0
for i in range(N - 1):
if H[i + 1] - H[i] < -1:
print('No')
break
elif H[i + 1] - H[i] == -1:
cnt += 1
elif H[i + 1] - H[i] == 0:
pass
else:
cnt = 0
if cnt > 1:
print('No')
break
else:
print('Yes')
|
N = int(eval(input()))
X = list(map(int, input().split()))
cur = 0
flag = True
for i in range(N):
cur = max(cur, X[i])
if cur - X[i] > 1:
flag = False
if flag:
print("Yes")
else:
print("No")
| p02953 |
import sys
n = int(eval(input()))
h = [int(i) for i in input().split()]
for k in range(n):
if k == n-1:
break
if h[k+1] > h[k]:
h[k+1] -= 1
elif h[k+1] < h[k]:
print('No')
sys.exit()
if k+1 == n-1:
break
print('Yes') | n = int(eval(input()))
h = list(map(int, input().split()))
ans ='Yes'
mah = 0
for i in h:
mah = max(i, mah)
if i < mah - 1:
ans = 'No'
break
print(ans) | p02953 |
n = int(eval(input()))
H = list(map(int, input().split()))
for i in range(n - 1):
if max(H[:i+1]) <= H[i+1] + 1:
continue
else:
print('No')
exit()
print('Yes') | n = int(eval(input()))
H = list(map(int, input().split()))
m = H[0]
for i in range(n - 1):
if max(m, H[i]) <= H[i+1] + 1:
m = max(m, H[i])
else:
print('No')
exit()
print('Yes') | p02953 |
n = int(eval(input()))
hs = input().split()
h = []
for s in hs:
h.append(int(s))
for i in range(0,n):
hi = h[i]
for j in range(i,n):
if hi - h[j] > 1:
print("No")
exit()
print("Yes")
| n = int(eval(input()))
hs = input().split()
h = []
for s in hs:
h.append(int(s))
max = 0
for i in range(0,n):
if max < h[i]:
max = h[i]
if max - h[i] > 1:
print("No")
exit()
print("Yes")
| p02953 |
# ABC136C - Build Stairs
def main():
n = int(eval(input()))
A = tuple(map(int, input().rstrip().split()))
cur = A[0]
for i in A[1:]:
if i == cur or i - 1 == cur:
continue
elif i > cur:
cur = i - 1
else:
print("No")
break
else:
print("Yes")
if __name__ == "__main__":
main() | # ABC136C - Build Stairs
def main():
n = int(eval(input()))
A = tuple(map(int, input().rstrip().split()))
cur = A[0]
for i in A[1:]:
if i > cur + 1:
cur = i - 1
if i < cur:
print("No")
break
else:
print("Yes")
if __name__ == "__main__":
main() | p02953 |
N=int(eval(input()))
h_list=[int(x) for x in input().split()]
flag=True
for j in range(1,len(h_list)):
for i in range(len(h_list)-j):
if h_list[i]-h_list[i+j]>=2:
flag=False
break
if flag:
print("Yes")
else:
print("No") | N=int(eval(input()))
h_list=[int(x) for x in input().split()]
flag=True
m=h_list[0]
for j in range(len(h_list)-1):
if m<h_list[j]:
m=h_list[j]
if m-h_list[j+1]>=2:
flag=False
break
if flag:
print("Yes")
else:
print("No") | p02953 |
def main():
n = int(eval(input()))
h = list(map(int,input().split()))
h = list(reversed(h))
flag = True
for i in range(1,len(h)):
if h[i] - h[i-1] > 1:
flag = False
elif h[i] - h[i-1] == 1:
h[i] -= 1
if flag:
print('Yes')
else:
print('No')
main() |
from sys import exit
ii = lambda : int(eval(input()))
mi = lambda : list(map(int,input().split()))
li = lambda : list(map(int,input().split()))
def main():
n = ii()
a = li()
a = reversed(a)
m = 100000000000
for i in a:
m = min(m,i)
if i > m+1:
print("No")
exit()
print("Yes")
main()
| p02953 |
N=int(eval(input()))
h=list(map(int, input().split()))
output='Yes'
for i in range(N-1):
if h[i]-h[i+1]>0:
if h[i]-min(h[i+1:])>1:
output='No'
print(output) | N=int(eval(input()))
h=list(map(int, input().split()))
index=N-1
output='Yes'
while index>0:
if h[index-1]-h[index]>1:
output='No'
break
elif h[index-1]-h[index]==1:
h[index-1]-=1
else:
pass
index-=1
print(output) | p02953 |
def resolve():
n = int(eval(input()))
h = list(map(int, input().split()))
for i in range(2 ** n):
new_h = []
for j in range(n):
if i >> j & 1:
new_h.append(h[j] - 1)
else:
new_h.append(h[j])
flg = 0
for k in range(n-1):
if new_h[k] > new_h[k+1]:
flg = 1
if flg == 0:
print('Yes')
return
print('No')
resolve() | def resolve():
n = int(eval(input()))
h = list(map(int, input().split()))
for i in range(n):
if i == 0:
h[i] -= 1
continue
if h[i-1] < h[i]:
h[i] -= 1
if h[i-1] > h[i]:
print('No')
return
print('Yes')
resolve() | p02953 |
n = int(eval(input()))
h = [int(i) for i in input().split(' ')]
for i, e in enumerate(h[-2::-1]):
if h[len(h) - i - 1] - e == -1:
h[len(h) - i - 2] -= 1
elif h[len(h) - i - 1] - e < -1:
print('No')
exit(0)
print('Yes')
| n = int(eval(input()))
h = [int(i) for i in input().split(' ')]
for i, e in enumerate(h[-2::-1]):
if h[len(h) - i - 1] - e == -1:
h[len(h) - i - 2] -= 1
elif h[len(h) - i - 1] - e >= 0:
continue
else:
print('No')
exit(0)
print('Yes')
| p02953 |
# 初期入力
from collections import deque
import sys
input = sys.stdin.readline
N = int(eval(input()))
H = list(map(int, input().split()))
#
differ =0
ans="Yes"
max_h =max(H)
max_index =H.index(max_h)
#最大値-1 と最大値の右側の最小値を比較,この時はfor不要
if max_index +1 <= N-1:
if H[max_index]-1 > min(H[max_index+1:]):
ans ="No"
print(ans)
sys.exit()
dq =deque(H)
before =dq.popleft()
for i in range(N-1):
after =dq.popleft()
differ =after - before
#differ = H[i+1] -H[i]
if differ <-1: #右側が小さのは１までOK
ans ="No"
break
elif differ ==-1:
if before -1 > min(dq) :
ans ="No"
break
else:
before = after
else:
before = after
print(ans) |
# 初期入力
from collections import deque
import sys
#input = sys.stdin.readline
N = int(eval(input()))
H = list(map(int, input().split()))
#
differ =0
ans="Yes"
max_h =max(H)
max_index =H.index(max_h)
#最大値-1 と最大値の右側の最小値を比較,この時はfor不要
if max_index +1 <= N-1:
if H[max_index]-1 > min(H[max_index+1:]):
ans ="No"
print(ans)
sys.exit()
dq =deque(H)
before =dq.popleft()
for i in range(N-1):
after =dq.popleft()
differ =after - before
#differ = H[i+1] -H[i]
if differ <-1: #右側が小さのは１までOK
ans ="No"
break
else:
before = after
print(ans)
| p02953 |
import sys
from collections import deque
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
def main():
n = int(eval(input()))
nums = list(map(int, input().split()))
ans = 'Yes'
for x in reversed(list(range(1, len(nums)))):
if nums[x-1] - nums[x] >= 2:
ans = 'No'
elif nums[x-1] - nums[x] == 1:
nums[x-1] -= 1
else:
continue
print(ans)
if __name__ == '__main__':
main()
| import sys
from collections import deque
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
# def main():
# n = int(input())
#
# nums = list(map(int, input().split()))
#
# ans = 'Yes'
#
# for x in reversed(range(1, len(nums))):
# if nums[x-1] - nums[x] >= 2:
# ans = 'No'
#
# elif nums[x-1] - nums[x] == 1:
# nums[x-1] -= 1
#
# else:
# continue
#
# print(ans)
#
#
# if __name__ == '__main__':
# main()
def main():
n = int(eval(input()))
nums = list(map(int, input().split()))
for x in reversed(list(range(1, len(nums)))):
if nums[x-1] > nums[x]:
nums[x-1] -= 1
if nums[x-1] > nums[x]:
print('No')
sys.exit()
print('Yes')
if __name__ == '__main__':
main() | p02953 |
n=int(eval(input()))
h=[int(i) for i in input().split()]
f=1
h[0]-=1
for i in range(1,n):
if h[i]-h[i-1]>=1:h[i]+=-1
elif h[i]-h[i-1]==0:h[i]+=0
else:
f=0
print("No")
break
if f==1:print("Yes")
| # 実行時間超過
N=int(eval(input()))
n = list(map(int, input().split()))
for i in range(N-1):
if n[i+1]-n[i]>=1:
n[i+1]-=1
elif n[i+1]-n[i]<=-1:
print("No")
exit()
print("Yes") | p02953 |
n=int(eval(input()))
l=list(map(int,input().split()))
t=l.pop(0)-1
for i in l:
if i<t: print('No'); exit()
if i>t: t=i-1
print('Yes') | n=int(eval(input()))
l=list(map(int,input().split()))
t=0
for i in l:
if i<t: print('No'); exit()
if i>t: t=i-1
print('Yes') | p02953 |
n,*l=list(map(int,open(0).read().split()))
t=0
for i in l:
if i<t: print('No'); break
if i>t: i-=1
t=i
else: print('Yes') | n,*l=list(map(int,open(0).read().split()))
t=0
for i in l:
if i<t: print('No'); exit()
if i>t: t=i-1
print('Yes') | p02953 |
N = int(eval(input()))
H = list(map(int,input().split()))
for i in range(N-1):
for j in range(i+1,N):
if H[j] - (H[i]-1) < 0:
print('No')
exit()
print('Yes') | N = int(eval(input()))
H = list(map(int,input().split()))
for i in range(N-1,0,-1):
if 2 <= H[i-1] - H[i]:
print('No')
exit()
else:
if (H[i-1] - 1) == H[i]:
H[i-1] -= 1
print('Yes') | p02953 |
#a,b=map(int,input().split())
#p_3,p_4=map(int,input().split())
n=int(eval(input()))
#g=input()
#recipe=[list(input().split())for _ in range(n)]
#m=int(input())
#have=[list(input().split())for _ in range(m)]
#a=[int(input()) for _ in range(k)]
h=list(map(int,input().split()))
#b=list(map(int,input().split()))
#c=list(map(float,input().split()))
#n=int(input())
#m=[list(map(int,input().split()))for _ in range(n)]
#p=[list(input().split())for _ in range(h)]
#a=[input()for _ in range(n)]
for i in range(1,n):
left=max(h[:i])-1
if h[i]<left:
print("No")
exit()
print("Yes")
| #a,b=map(int,input().split())
#p_3,p_4=map(int,input().split())
n=int(eval(input()))
#g=input()
#recipe=[list(input().split())for _ in range(n)]
#m=int(input())
#have=[list(input().split())for _ in range(m)]
#a=[int(input()) for _ in range(k)]
h=list(map(int,input().split()))
#b=list(map(int,input().split()))
#c=list(map(float,input().split()))
#n=int(input())
#m=[list(map(int,input().split()))for _ in range(n)]
#p=[list(input().split())for _ in range(h)]
#a=[input()for _ in range(n)]
tmp=h[0]
for i in range(1,n):
if tmp<h[i]:
tmp=h[i]
tmp-=1
if h[i]<tmp:
print("No")
exit()
print("Yes")
| p02953 |
n = int(eval(input()))
h = list(map(int, input().split()))
h[0] -= 1
for i in range(1, n-1):
if h[i] <= h[i+1] + 1:
if h[i-1] != h[i]:
h[i] -= 1
else:
print('No')
exit()
for i in range(n-1):
if h[i] > h[i+1]:
print('No')
exit()
print('Yes') | n = int(eval(input()))
h = list(map(int, input().split()))
h[0] -= 1
for i in range(1, n-1):
if h[i] == h[i+1] + 1:
if h[i-1] != h[i]:
h[i] -= 1
else:
print('No')
exit()
elif h[i] < h[i+1] + 1:
if h[i-1] != h[i]:
h[i] -= 1
else:
print('No')
exit()
print('Yes') | p02953 |
import sys
N = int(eval(input()))
H = list(map(int, input().split()))
ans = ("Yes")
for i in range(N-1):
for j in range(N-i-1):
if H[i]-H[i+j+1] >= 2:
ans = ("No")
print(ans)
sys.exit()
print(ans) | N = int(eval(input()))
H = list(map(int, input().split()))
ans = ("Yes")
for i in range(N-1):
if H[N-1-i] - H[N-2-i] == -1:
H[N-2-i] -= 1
elif H[N-1-i] - H[N-2-i] <= -2:
ans = ("No")
print(ans) | p02953 |
n = int(eval(input()))
h = list(map(int,input().split()))
for i in range(len(h)-1):
if h[i] > h[i+1]:
h[i] = h[i] - 1
elif h[i] == h[i+1]:
if h[i] == min(h[i:])+1:
h[i] = h[i] - 1
if h == sorted(h):
print('Yes')
else:
print('No') | n = int(eval(input()))
h = list(map(int, input().split()))
for i in reversed(list(range(1,n))):
if h[i-1] - h[i] == 1:
h[i-1] -= 1
elif h[i-1] - h[i] > 1:
print('No')
exit()
print('Yes') | p02953 |
N = int(eval(input()))
b_list = list(map(int,input().split()))
d_list = [True for i in range(N)]
s = True
b_list.append(1000000000)
for _ in range(N):
for i in range(len(b_list)-1):
if (b_list[i] > b_list[i+1]):
if (d_list[i]):
b_list[i] -= 1
d_list[i] = False
else:
s = False
break
if (s):
print('Yes')
else:
print('No') | N = int(eval(input()))
b_list = list(map(int,input().split()))
s = True
if (b_list[0] > 1):
b_list[0] -= 1
for i in range(1,len(b_list)):
if (b_list[i-1] < b_list[i]):
b_list[i] -= 1
for i in range(len(b_list)-1):
if (b_list[i] > b_list[i+1]):
s = False
if (s):
print('Yes')
else:
print('No') | p02953 |
n = int(eval(input()))
h = list(map(int, input().split()))
for i in range(1,n):
if h[i] < h[i-1]:
h[i] += 1
for i in range(1,n):
if h[i] < h[i-1]:
print("No")
exit()
print("Yes") | n = int(eval(input()))
h = list(map(int, input().split()))[::-1]
for i in range(1,n):
if h[i] - h[i-1] > 1:
print("No")
exit()
elif h[i] - h[i-1] == 1:
h[i] -= 1
print("Yes") | p02953 |
n = int(eval(input()))
H_l = list(map(int, input().split()))
flg_nd = True
for i in range(n-1):
if H_l[i] >=3:
H_min = min(H_l[i+1:])
if H_l[i] - H_min >=2:
flg_nd = False
break;
if flg_nd:
print('Yes')
else:
print('No') | n = int(eval(input()))
H_l = list(map(int, input().split()))
tmp_max = 0
flg_nd = True
for i in range(n):
if tmp_max - H_l[i] >=2:
flg_nd = False
break;
if H_l[i] > tmp_max:
tmp_max = H_l[i]
if flg_nd:
print('Yes')
else:
print('No') | p02953 |
N = int(eval(input()))
Hs = [int(x) for x in input().split()]
# 右端から見て, 単調減少/同じにできればいい.
# 右端から見て, 右側より大きければ1つ減らす.
# その上で比較していく. もし単調減少/同じにできなければ'No'を返す.
prev = 'init'
is_yes = True
for i in range(N):
current = Hs[N-1-i]
if prev == 'init':
prev = current
continue
elif prev >= current:
prev = current
elif prev == current - 1:
prev = current - 1
else:
is_yes = False
if is_yes:
print('Yes')
else:
print('No')
| N = int(eval(input()))
Hs = [int(x) for x in input().split()]
# 右端から見て, 単調減少/同じにできればいい.
# 右端から見て, 右側より大きければ1つ減らす.
# その上で比較していく. もし単調減少/同じにできなければ'No'を返す.
def is_yes(Hs):
max = 0
for H in Hs:
# print("H: " + H)
if H > max:
max = H
# print("max: " + max)
if max - H >= 2:
return False
return True
if is_yes(Hs):
print('Yes')
else:
print('No')
| p02953 |
import sys
N=int(eval(input()))
H=[int(x) for x in input().rstrip().split()]
flag=0
mi=-1
for i in range(N-1):
if H[i]<=H[i+1] and mi<=H[i]:
mi=max(mi,H[i]-1)
continue
elif H[i+1]<H[i]:
H[i]=H[i]-1
mi=max(mi,H[i])
if H[i+1]<H[i] or H[i]<mi:
flag=1
print("No")
sys.exit()
if flag==0:
print("Yes")
| import sys
N=int(eval(input()))
H=[int(x) for x in input().rstrip().split()]
flag=0
mi=-1
for i in range(N-1):
if H[i]<=H[i+1] and mi<=H[i]:
mi=max(mi,H[i]-1)
continue
elif H[i+1]<H[i]:
H[i]=H[i]-1
mi=max(mi,H[i])
if H[i+1]<H[i] or H[i]<mi:
flag=1
print("No")
sys.exit()
if flag==0:
print("Yes")
| p02953 |
N = int(eval(input()))
H = [int(x) for x in input().split()]
ans = "Yes"
for i in range(1, N):
if H[-(i + 1)] <= H[-i]:
continue
elif H[-(i + 1)] - 1 <= H[-i]:
H[-(i + 1)] -= 1
else:
ans = "No"
break
print(ans) | n = int(eval(input()))
h = list(map(int, input().split()))[::-1]
for i in range(1, n):
if h[i-1] >= h[i]: continue
if h[i-1] == h[i]-1:h[i] -= 1
else:
print("No")
exit()
print("Yes") | p02953 |
n = int(eval(input()))
h = list(map(int, input().split()))[::-1]
for i in range(1, n):
if h[i-1] >= h[i]: continue
if h[i-1] == h[i]-1:h[i] -= 1
else:
print("No")
exit()
print("Yes") | n = int(eval(input()))
h = list(map(int, input().split()))[::-1]
ans = "Yes"
for i in range(n-1):
if h[i] >= h[i+1]: continue
if h[i] >= h[i+1]-1:
h[i+1] -= 1
else:
ans = "No"
break
print(ans) | p02953 |
n, *a = list(map(int, open(0).read().split()))
for i in range(n): a[i] -= a[0]
mx = cant = 0
for i in range(n):
mx = max(mx, a[i])
if a[i]<mx-1: cant = True
print(("YNeos"[cant::2])) | n, *k = list(map(int, open(0).read().split()))
mx = cant = 0
for i in k:
mx = max(mx, i)
if mx-i>1: cant = True
print(("YNeos"[cant::2])) | p02953 |
# 2019-11-16 10:55:08(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
def main():
n, *h = [int(x) for x in sys.stdin.read().split()]
ans = 'Yes'
maximum = h[0]
for i in range(1, n):
if maximum - h[i] >= 2:
ans = 'No'
break
maximum = max(maximum, h[i])
print(ans)
if __name__ == "__main__":
main()
| import sys
n, *H = list(map(int, sys.stdin.read().split()))
def main():
cur = 0
for h in H:
if h > cur:
cur = h - 1
elif h < cur:
return 'No'
return 'Yes'
if __name__ == '__main__':
ans = main()
print(ans) | p02953 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
H = [int(item) for item in input().split()]
cand = []
cand += [H[0], H[0] - 1]
for i in range(1, N):
new_cand = []
for c in cand:
if c <= H[i] - 1:
new_cand += [H[i], H[i] - 1]
elif c == H[i]:
new_cand += [H[i]]
cand = new_cand
if len(cand) == 0:
print("No")
break
else:
print("Yes")
| import sys
input = sys.stdin.readline
N = int(eval(input()))
H = [int(item) for item in input().split()]
cand = []
cand += [H[0], H[0] - 1]
for i in range(1, N):
new_cand = []
for c in cand:
if c <= H[i] - 1:
new_cand += [H[i], H[i] - 1]
elif c == H[i]:
new_cand += [H[i]]
cand = list(set(new_cand))
if len(cand) == 0:
print("No")
break
else:
print("Yes")
| p02953 |
N=int(eval(input()))
H=list(map(int,input().split()))
H.append(0)
h1=0
h2=0
a=0
for i in range(N-1):
h1=H[i+1]-H[i]
if h1<-1:
a=1
break
elif h1==-1:
for j in range(1,N-i):
h2=H[i]-H[i+j]
if h2>=2:
a=1
break
if a==1:
break
if a==0:
print('Yes')
else:
print('No') | N=int(eval(input()))
H=list(map(int,input().split()))
a=0
for i in range(N-1)[::-1]:
if H[i]>H[i+1]:
H[i]-=1
for i in range(N-1):
if H[i]>H[i+1]:
a=1
break
if a==0:
print("Yes")
else:
print("No") | p02953 |
N =int(eval(input()))
H = [int(x) for x in input().split()]
memo = 0
for i in range(N):
if i==N-1:
break
elif H[i]-min(H[i+1:])>=2:
memo+=1
if memo>=1:
print('No')
else:
print('Yes') | N =int(eval(input()))
H = [int(x) for x in input().split()]
h=0
l=0
memo = 0
for i in range(N):
if H[i]>=h:
h=H[i]
elif H[i]<h and H[i]>=l:
l=H[i]
else:
memo+=1
for i in range(N):
if i==N-1:
break
elif H[i]-H[i+1]>=2:
memo+=1
if memo>=1:
print('No')
else:
print('Yes') | p02953 |
import sys
n = int(eval(input()))
h = list(map(int, input().split()))
if n == 1:
print('Yes')
sys.exit()
cnt = 0
for i in range(n-1):
if h[i] - h[i+1] == 1:
cnt += 1
if cnt == 2:
print('No')
sys.exit()
elif h[i] - h[i+1] > 1:
print('No')
sys.exit()
elif h[i] - h[i+1] < 0:
cnt = 0
print('Yes') | n = int(eval(input()))
h = list(map(int, input().split()))
h[0] -= 1
for i in range(1, n):
if h[i] > h[i-1]:
h[i] -= 1
elif h[i] < h[i-1]:
print('No')
exit()
print('Yes') | p02953 |
n = int(eval(input()))
h_list = list(map(int, input().split()))
for i in range(n - 1, 0, -1):
if max(h_list[:i]) - h_list[i] >= 2:
print('No')
break
else:
print('Yes') | n = int(eval(input()))
h_list = list(map(int, input().split()))
min_v = h_list[-1]
for i in range(n - 1, 0, -1):
if h_list[i] < min_v:
min_v = h_list[i]
if h_list[i - 1] - min_v >= 2:
print('No')
break
else:
print('Yes') | p02953 |
n = int(eval(input()))
h = list(map(int,input().split()))
submax = 0
for i in range(n-1):
for j in range(i+1,n):
if h[i] - h[j] >= 2:
submax = 1
break
if submax == 1:
break
if submax == 1:
print("No")
else:
print("Yes") | n = int(eval(input()))
h = list(map(int,input().split()))
d = [1]+[0]*(n-1)
for i in range(n-1):
if h[i] >= 2+ h[i+1]:
print('No')
exit()
if d[i] == 1 and h[i] <= h[i+1]:
d[i+1] = 1
elif d[i] == 0:
if h[i] +1 <=h[i+1]:
d[i+1] = 1
elif h[i] -1 == h[i+1]:
print('No')
exit()
print('Yes') | p02953 |
N = int(eval(input()))
l = list(map(int, input().split()))
d = 0
for i in range(N-1):
if l[i] - l[i+1] >= 2:
d = 1
for i in range(N-1):
if l[i] - l[i+1] == 1:
for j in range(i+1, N-1):
if l[j] - l[j+1] == 1:
d = 1
if d == 0:
print("Yes")
else:
print("No") | N = int(eval(input()))
l = list(map(int, input().split()))
d = 0
for i in range(N-1):
if l[i] - l[i+1] >= 2:
d = 1
for i in range(N-2):
if l[i] - l[i+1] == 1:
for j in range(i+1, N-1):
if l[j] - l[j+1] <= -1:
break
if l[j] - l[j+1] == 0:
continue
if l[j] - l[j+1] == 1:
d = 1
break
if d == 0:
print("Yes")
else:
print("No") | p02953 |
def solve():
ans = "Yes"
for i in range(1,N):
tmp = min(H[i:])
if H[i-1] - tmp > 1:
ans = "No"
break
print(ans)
if __name__ == "__main__":
N = int(eval(input()))
H = list(map(int, input().split()))
solve()
|
def solve():
ans = "Yes"
for i in range(1,N-1):
if H[i] > H[i+1]:
H[i] -= 1
if H[i] > H[i+1]:
ans = "No"
break
if H[i-1] > H[i]:
ans = "No"
break
elif H[i-1] <= H[i]-1:
H[i] -= 1
print(ans)
if __name__ == "__main__":
N = int(eval(input()))
H = list(map(int, input().split()))
solve()
| p02953 |
N = int(eval(input()))
H = list(map(int, input().split()))
flag = True
for i in range(N-1, 0, -1):
if H[i-1] - H[i] == 1:
H[i-1] -= 1
elif H[i-1] - H[i] > 1:
flag = False
print('No')
break
if flag:
print('Yes')
| N = int(eval(input()))
H = list(map(int, input().split()))
for i in range(N-1, 0, -1):
if H[i-1] - H[i] == 1:
H[i-1] -= 1
elif H[i-1] - H[i] > 1:
flag = False
print('No')
break
else:
print('Yes')
| p02953 |
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(eval(input()))
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())
N = inp()
HH = inpl()
HH[0] -= 1
for i in range(N-1):
#print(HH)
if HH[i+1]-HH[i] > 0:
HH[i+1] -= 1
elif HH[i+1]-HH[i] == 0:
continue
else:
print('No')
exit()
print('Yes')
| N = int(eval(input()))
hh = list(map(int, input().split()))
for i in range(1, N):
if hh[i - 1] == hh[i]:
continue
else:
hh[i] -= 1
if hh[i - 1] > hh[i]:
print("No")
exit()
print("Yes")
| p02953 |
N,*H=list(map(int,open(0).read().split()))
H[0]-=1
def main():
ihmax=0
hmax=H[0]
for i in range(1,N):
if H[i-1]<H[i]:
ihmax=i-1
H[i]-=1
hmax=max(H[i],hmax)
elif H[i-1]==H[i]:
continue
else:
return 'No'
return 'Yes'
print((main())) | N,*H=list(map(int,open(0).read().split()))
H[0]-=1
def main():
for i in range(1,N):
if H[i-1]<H[i]:
H[i]-=1
elif H[i-1]==H[i]:
continue
else:
return 'No'
return 'Yes'
print((main())) | p02953 |
n=int(eval(input()))
l=list(map(int,input().split()))
x=0
flg=0
while(x<n):
j=x+1
while(j<n):
if(l[j]<l[x]-1):
flg=1
break
j+=1
x+=1
if(flg==0):
print("Yes")
else:
print("No") | n=int(eval(input()))
l=list(map(int,input().split()))
x=[]
i=0
flag=0
for i in range(n-1,0,-1):
if(l[i]<l[i-1]):
if(l[i-1]-1<=l[i]):
l[i-1]-=1
else:
flag=1
if(flag==0):
print("Yes")
else:
print("No")
| p02953 |
import sys
n = int(eval(input()))
h = list(map(int, input().split()))
def main():
for i in reversed(list(range(n-1))):
if h[i] - h[i+1] > 1:
return False
exit()
elif h[i] - h[i+1] == 1:
h[i] -= 1
else:
continue
return True
if main() == True:
print('Yes')
sys.exit()
h[n-1] -= 1
if main() == True:
print('Yes')
else:
print('No') |
n = int(eval(input()))
h = list(map(int, input().split()))
def main():
for i in reversed(list(range(n-1))):
if h[i] - h[i+1] > 1:
return False
exit()
elif h[i] - h[i+1] == 1:
h[i] -= 1
else:
continue
return True
if main() == True:
print('Yes')
else:
print('No') | p02953 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.