input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from collections import Counter
n = int(eval(input()))
v = list(map(str, input().split()))
f = Counter(v[::2])
s = Counter(v[1::2])
ans = []
for i in list(f.keys()):
for j in list(s.keys()):
if i == j:
continue
else:
ans.append(f[i] + s[j])
if ans:
print((n - max(ans)))
else:
print((n // 2)) | from collections import Counter
n = int(eval(input()))
v = list(map(str, input().split()))
f = Counter(v[::2]).most_common(2)
s = Counter(v[1::2]).most_common(2)
if f[0][0] != s[0][0]:
print((n - f[0][1] - s[0][1]))
else:
if len(f) == 1 or len(s) == 1:
print((n // 2))
else:
print((n - max(f[0][1] + s[1][1], f[1][1] + s[0][1]))) | p03244 |
mod = 10 ** 9 + 7
mod2 = 2**61+1
from collections import deque
import heapq
from bisect import bisect_left, insort_left, bisect_right
_NUMINT_ALL = list(range(10))
def main():
ans = solve()
if ans is not None:
print(ans)
def solve():
N = iip(False)
V = iip()
v1 = V[1::2]
v2 = V[::2]
d1 = {}
for i in v1:
if i in d1:
d1[i] += 1
else:
d1[i] = 1
d2 = {}
for i in v2:
if i in d2:
d2[i] += 1
else:
d2[i] = 1
d1 = list(d1.items())
d1.sort(key=lambda x:x[1])
d2 = list(d2.items())
d2.sort(key=lambda x:x[1])
m11 = d1[-1][1]
if len(d1) >= 2:
m12 = d1[-2][1]
else:
m12 = 0
m21 = d2[-1][1]
if len(d2) >= 2:
m22 = d2[-2][1]
else:
m22 = 0
if d1[-1][0] != d2[-1][0]:
return N - (d1[-1][1]+d2[-1][1])
else:
return min(N - (m11+m22), N - (m12+m21))
#print(d1)
#print(d2)
#####################################################ライブラリ集ここから
def iip(listed=True, num_only = True):
if num_only:
ret = [int(i) for i in input().split()]
else:
ret = [int(i) if i in _NUMINT_ALL else i for i in input().split()]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def iipt(l, listed=False, num_only = True):
ret = []
for i in range(l):
ret.append(iip_ord(listed=listed, num_only=num_only))
return ret
def sortstr(s):
return "".join(sorted(s))
def iip_ord():
return [ord(i) - ord("a") for i in eval(input())]
def YesNo(s):
if s:
print("Yes")
else:
print("No")
def fprint(s):
for i in s:
print(i)
def bitall(N):
ret = []
for i in range(2**N):
a = []
for j in range(N):
a.append(i%2)
i //= 2
ret.append(a)
return ret
def split_print_space(s):
print((" ".join([str(i) for i in s])))
def split_print_enter(s):
print(("\n".join([str(i) for i in s])))
def koenai_saidai_x_index(sorted_list, n):
l = 0
r = len(sorted_list)
if len(sorted_list) == 0:
return False
if sorted_list[0] > n:
return False
while r - l > 1:
x = (l + r) // 2
if sorted_list[x] == n:
return x
elif sorted_list[x] > n:
r = x
else:
l = x
return l
def searchsorted(sorted_list, n, side="left"):
if side not in ["right", "left"]:
raise Exception("sideはrightかleftで指定してください")
l = 0
r = len(sorted_list)
if n > sorted_list[-1]:
# print(sorted_list)
return len(sorted_list)
if n < sorted_list[0]:
return 0
while r - l > 1:
x = (l + r) // 2
if sorted_list[x] > n:
r = x
elif sorted_list[x] < n:
l = x
else:
if side == "left":
r = x
elif side == "right":
l = x
if side == "left":
if sorted_list[l] == n:
return r - 1
else:
return r
if side == "right":
if sorted_list[l] == n:
return l + 1
else:
return l
def soinsuu_bunkai(n):
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False):
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod):
return power(n, mod - 2)
def power(n, p, mod_= mod):
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
if __name__ == "__main__":
main() | mod = 10 ** 9 + 7
mod2 = 2**61+1
from collections import deque
import heapq
from bisect import bisect_left, insort_left, bisect_right
_NUMINT_ALL = list(range(10))
def main():
ans = solve()
if ans is not None:
print(ans)
def solve():
N = iip(False)
V = iip()
v1 = V[1::2]
v2 = V[::2]
d1 = count_elements(v1)
d2 = count_elements(v2)
d1 = list(d1.items())
d2 = list(d2.items())
d1 = sort_tuples(d1, 1)
d2 = sort_tuples(d2, 1)
m11 = d1[-1][1]
if len(d1) >= 2:
m12 = d1[-2][1]
else:
m12 = 0
m21 = d2[-1][1]
if len(d2) >= 2:
m22 = d2[-2][1]
else:
m22 = 0
if d1[-1][0] != d2[-1][0]:
return N - (d1[-1][1]+d2[-1][1])
else:
return min(N - (m11+m22), N - (m12+m21))
#print(d1)
#print(d2)
#####################################################ライブラリ集ここから
def iip(listed=True, num_only = True):
if num_only:
ret = [int(i) for i in input().split()]
else:
ret = [int(i) if i in _NUMINT_ALL else i for i in input().split()]
if len(ret) == 1 and not listed:
return ret[0]
return ret
def sort_tuples(l, index):
if isinstance(l, list):
l.sort(key=lambda x:x[index])
return l
else:
l = list(l)
return sorted(l, key=lambda x:x[index])
def count_elements(l):
d = {}
for i in l:
if i in d:
d[i] += 1
else:
d[i] = 1
return d
def iipt(l, listed=False, num_only = True):
ret = []
for i in range(l):
ret.append(iip_ord(listed=listed, num_only=num_only))
return ret
def sortstr(s):
return "".join(sorted(s))
def iip_ord():
return [ord(i) - ord("a") for i in eval(input())]
def YesNo(s):
if s:
print("Yes")
else:
print("No")
def fprint(s):
for i in s:
print(i)
def bitall(N):
ret = []
for i in range(2**N):
a = []
for j in range(N):
a.append(i%2)
i //= 2
ret.append(a)
return ret
def split_print_space(s):
print((" ".join([str(i) for i in s])))
def split_print_enter(s):
print(("\n".join([str(i) for i in s])))
def koenai_saidai_x_index(sorted_list, n):
l = 0
r = len(sorted_list)
if len(sorted_list) == 0:
return False
if sorted_list[0] > n:
return False
while r - l > 1:
x = (l + r) // 2
if sorted_list[x] == n:
return x
elif sorted_list[x] > n:
r = x
else:
l = x
return l
def searchsorted(sorted_list, n, side="left"):
if side not in ["right", "left"]:
raise Exception("sideはrightかleftで指定してください")
l = 0
r = len(sorted_list)
if n > sorted_list[-1]:
# print(sorted_list)
return len(sorted_list)
if n < sorted_list[0]:
return 0
while r - l > 1:
x = (l + r) // 2
if sorted_list[x] > n:
r = x
elif sorted_list[x] < n:
l = x
else:
if side == "left":
r = x
elif side == "right":
l = x
if side == "left":
if sorted_list[l] == n:
return r - 1
else:
return r
if side == "right":
if sorted_list[l] == n:
return l + 1
else:
return l
def soinsuu_bunkai(n):
ret = []
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
n //= i
ret.append(i)
if i > n:
break
if n != 1:
ret.append(n)
return ret
def conbination(n, r, mod, test=False):
if n <= 0:
return 0
if r == 0:
return 1
if r < 0:
return 0
if r == 1:
return n
ret = 1
for i in range(n - r + 1, n + 1):
ret *= i
ret = ret % mod
bunbo = 1
for i in range(1, r + 1):
bunbo *= i
bunbo = bunbo % mod
ret = (ret * inv(bunbo, mod)) % mod
if test:
# print(f"{n}C{r} = {ret}")
pass
return ret
def inv(n, mod):
return power(n, mod - 2)
def power(n, p, mod_= mod):
if p == 0:
return 1
if p % 2 == 0:
return (power(n, p // 2, mod_) ** 2) % mod_
if p % 2 == 1:
return (n * power(n, p - 1, mod_)) % mod_
if __name__ == "__main__":
main() | p03244 |
n = int(eval(input()))
a = list(map(int,input().split()))
b = a[0::2]
b1 = sorted(b, key=lambda x: b.count(x))
c = a[1::2]
c1 = sorted(c, key=lambda x: c.count(x))
if b == c:
print((n//2))
else:
print((n - b1.count(b1[-1]) - c1.count(c1[-1]))) | n = int(eval(input()))
v = list(map(int,input().split()))
v1 = sorted(v[0::2])
v2 = sorted(v[1::2])
s1 = set(v1)
s2 = set(v2)
## 偶数項・奇数項ごとに最大数および次点の値を保持
eve = [[0,0]]
odd = [[0,0]]
cnt_eve = 1
cnt_odd = 1
for i in range(1,n//2):
## 偶数
if v1[i] == v1[i-1]:
cnt_eve += 1
else:
eve.append([cnt_eve, v1[i-1]])
cnt_eve = 1
if v2[i] == v2[i-1]:
cnt_odd += 1
else:
odd.append([cnt_odd, v2[i-1]])
cnt_odd = 1
if i == n//2 - 1:
eve.append([cnt_eve, v1[i]])
odd.append([cnt_odd, v2[i]])
eve.sort(key=lambda x: x[0], reverse=True)
odd.sort(key=lambda x: x[0], reverse=True)
if eve[0][1] != odd[0][1]:
ans = n - eve[0][0] - odd[0][0]
print(ans)
else:
ans = n - max(eve[0][0] + odd[1][0], eve[1][0] + odd[0][0])
print(ans)
| p03244 |
from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
odds = []
evens = []
for i in range(n):
if i % 2 == 0:
evens.append(v[i])
else:
odds.append(v[i])
evens_c = Counter(evens).most_common()
odds_c = Counter(odds).most_common()
ans = n
fl = 0
for i in range(len(evens_c)):
for j in range(len(odds_c)):
try:
if evens_c[i][0] != odds_c[j][0]:
ans = min(ans, n - evens_c[i][1] - odds_c[j][1])
fl = 1
except:
continue
if fl == 1:
print(ans)
exit()
print((n // 2))
| from collections import Counter
n = int(eval(input()))
v = list(map(int, input().split()))
odds = []
evens = []
for i in range(n):
if i % 2 == 0:
evens.append(v[i])
else:
odds.append(v[i])
evens_c = Counter(evens).most_common(2)
odds_c = Counter(odds).most_common(2)
if evens_c[0][0] != odds_c[0][0]:
print((n - evens_c[0][1] - odds_c[0][1]))
exit()
if len(evens_c) == 1 or len(odds_c) == 1:
print((n // 2))
exit()
print((n - max(evens_c[0][1] + odds_c[1][1], evens_c[1][1] + odds_c[0][1])))
| p03244 |
n = int(eval(input()))
lst = list(map(int, input().split()))
ma = {}
mb = {}
for i in range(0, n, 2):
lst[i] in ma
if lst[i] in ma:
ma[lst[i]] += 1
else:
ma[lst[i]] = 1
lst[i+1] in mb
if lst[i+1] in mb:
mb[lst[i+1]] += 1
else:
mb[lst[i+1]] = 1
if max(ma, key=ma.get) != max(mb, key=mb.get):
d = n - max(ma.values()) - max(mb.values())
else:
ma2 = max(ma.values())
mb2 = max(mb.values())
ma[max(ma, key=ma.get)] = 0
mb[max(mb, key=mb.get)] = 0
d1 = n - ma2 - max(mb.values())
d2 = n - max(ma.values()) - mb2
d = min(d1, d2)
print(d) | n = int(eval(input()))
lst = list(map(int, input().split()))
m1 = {}
m2 = {}
for i in range(0, n, 2):
if lst[i] in m1:
m1[lst[i]] += 1
else:
m1[lst[i]] = 1
if lst[i+1] in m2:
m2[lst[i+1]] += 1
else:
m2[lst[i+1]] = 1
if max(m1, key=m1.get) != max(m2, key=m2.get):
mm = n - max(m1.values()) - max(m2.values())
else:
mm1 = max(m1.values())
mm2 = max(m2.values())
m1[max(m1, key=m1.get)] = 0
m2[max(m2, key=m2.get)] = 0
mm = min(n - max(m1.values()) - mm2, n - max(m2.values()) - mm1)
print(mm) | p03244 |
from itertools import permutations
import collections
N = int(eval(input()))
nums = list(map(int, input().split()))
odd_nums = []
even_nums = []
for i, num in enumerate(nums):
if i % 2 == 1:
even_nums.append(num)
else:
odd_nums.append(num)
useable_nums = set(nums)
even_length = len(even_nums)
odd_length = len(odd_nums)
even_counter = collections.Counter(even_nums)
odd_counter = collections.Counter(odd_nums)
# print(even_counter) # 偶数
# print(odd_counter) # 奇数
inf = float('inf')
min_ans = inf
if len(useable_nums) == 1:
useable_nums.add(0)
useable_permutaions = list(permutations(useable_nums, 2))
# print(useable_permutaions)
for permutation in useable_permutaions:
ans = 0
if permutation[0] in odd_counter:
ans += odd_length - odd_counter[permutation[0]]
else:
ans += odd_length
if permutation[1] in even_counter:
ans += even_length - even_counter[permutation[1]]
else:
ans += even_length
min_ans = min(min_ans, ans)
print(min_ans)
| from itertools import permutations
import collections
N = int(eval(input()))
nums = list(map(int, input().split()))
odd_nums = []
even_nums = []
for i, num in enumerate(nums):
if i % 2 == 1:
even_nums.append(num)
else:
odd_nums.append(num)
useable_nums = set(nums)
even_length = len(even_nums)
odd_length = len(odd_nums)
even_counter = collections.Counter(even_nums).most_common()
odd_counter = collections.Counter(odd_nums).most_common()
even_counter.append((0, 0))
odd_counter.append((0, 0))
even_counter.sort(key=lambda x: x[1], reverse=True)
odd_counter.sort(key=lambda x: x[1], reverse=True)
# print(even_counter)
# print(odd_counter)
min_ans = None
if even_counter[0][0] == odd_counter[0][0]:
min_ans = min((odd_length - odd_counter[0][1]) + (even_length - even_counter[1][1]),
(odd_length - odd_counter[1][1]) + (even_length - even_counter[0][1]))
else:
min_ans = odd_length - odd_counter[0][1] + even_length - even_counter[0][1]
print(min_ans)
| p03244 |
from collections import defaultdict
N = int(eval(input()))
L = list(map(int, input().split()))
if len(set(L)) == 1:
print((N//2))
exit()
if N == 2:
print((0))
exit()
d_even = defaultdict(int)
d_odd = defaultdict(int)
for i in range(N):
v = L[i]
if i % 2 == 0:
d_even[v] += 1
else:
d_odd[v] += 1
l_even = sorted(list(d_even.items()), key=lambda x: -x[1])
l_odd = sorted(list(d_odd.items()), key=lambda x: -x[1])
if l_even[0][0] != l_odd[0][0]:
print((N - l_even[0][1] - l_odd[0][1]))
else:
# どちらも試してコストの小さい方を採用する
ans1 = N - l_even[0][1] - l_odd[1][1]
ans2 = N - l_even[1][1] - l_odd[0][1]
print((min(ans1, ans2)))
| from collections import defaultdict
N = int(eval(input()))
L = list(map(int, input().split()))
if len(set(L)) == 1:
print((N//2))
exit()
if N == 2:
print((0))
exit()
d_even = defaultdict(int)
d_odd = defaultdict(int)
for i in range(N):
v = L[i]
if i % 2 == 0:
d_even[v] += 1
else:
d_odd[v] += 1
l_even = sorted(list(d_even.items()), key=lambda x: -x[1])
l_odd = sorted(list(d_odd.items()), key=lambda x: -x[1])
if l_even[0][0] != l_odd[0][0]:
print((N - l_odd[0][1] - l_even[0][1]))
exit()
ans = N
ans = min(ans, N - l_odd[0][1] - l_even[1][1])
ans = min(ans, N - l_odd[1][1] - l_even[0][1])
print(ans)
| p03244 |
from collections import defaultdict
N = int(eval(input()))
L = list(map(int, input().split()))
if len(set(L)) == 1:
print((N//2))
exit()
if N == 2:
print((0))
exit()
d_even = defaultdict(int)
d_odd = defaultdict(int)
for i in range(N):
v = L[i]
if i % 2 == 0:
d_even[v] += 1
else:
d_odd[v] += 1
l_even = sorted(list(d_even.items()), key=lambda x: -x[1])
l_odd = sorted(list(d_odd.items()), key=lambda x: -x[1])
if l_even[0][0] != l_odd[0][0]:
print((N - l_odd[0][1] - l_even[0][1]))
exit()
ans = N
ans = min(ans, N - l_odd[0][1] - l_even[1][1])
ans = min(ans, N - l_odd[1][1] - l_even[0][1])
print(ans)
| from collections import Counter
N = int(eval(input()))
L = list(map(int, input().split()))
odd = [v for i, v in enumerate(L) if i % 2 == 0]
even = [v for i, v in enumerate(L) if i % 2 == 1]
if len(set(L)) == 1:
print((N//2))
exit()
if N == 2:
print((0))
exit()
c_odd = sorted(list(dict(Counter(odd)).items()), key=lambda x: -x[1])
c_even = sorted(list(dict(Counter(even)).items()), key=lambda x: -x[1])
odd_1 = c_odd[0]
even_1 = c_even[0]
if odd_1[0] != even_1[0]:
print((N - odd_1[1] - even_1[1]))
exit()
even_2 = c_even[1]
odd_2 = c_odd[1]
ans = N
ans = min(ans, N - odd_1[1] - even_2[1])
ans = min(ans, N - odd_2[1] - even_1[1])
print(ans)
| p03244 |
from collections import Counter
n = int(eval(input()))
num = list(map(int, input().split()))
num1 = []
num2 = []
ans = 0
for i in range(0, n, 2):
num1.append(num[i])
for i in range(1, n, 2):
num2.append(num[i])
num1 = Counter(num1).most_common()
num2 = Counter(num2).most_common()
if num1[0][0] != num2[0][0]:
ans = n - num1[0][1] - num2[0][1]
else:
if n - num1[0][1] - num2[0][1] == 0:
ans = n // 2
else:
if n // 2 - num1[0][1] == 0:
ans = n // 2 - num2[1][1]
elif n // 2 - num2[0][1] == 0:
ans = n // 2 - num1[1][1]
else:
a = n - num1[0][1] - num2[1][1]
b = n - num1[1][1] - num2[0][1]
ans = min(a, b)
print(ans) | from collections import Counter
n = int(eval(input()))
V = list(map(int, input().split()))
X = Counter([V[i] for i in range(0, n, 2)]).most_common()
Y = Counter([V[i] for i in range(1, n, 2)]).most_common()
ans = 0
if X[0][0] != Y[0][0]:
ans = n - X[0][1] - Y[0][1]
else:
if len(X) == 1 and len(Y) == 1:
ans = n // 2
elif len(X) == 1 and len(Y) != 1:
ans = n // 2 - Y[1][1]
elif len(X) != 1 and len(Y) == 1:
ans = n // 2 - X[1][1]
else:
a = n - X[0][1] - Y[1][1]
b = n - X[1][1] - Y[0][1]
ans = min(a, b)
print(ans) | p03244 |
from collections import Counter
n = int(eval(input()))
A = [int(i) for i in input().split()]
A0 = []
A1 = []
for i in range(0, n, 2):
A0.append(A[i])
A1.append(A[i + 1])
C0 = Counter(A0).most_common()
C1 = Counter(A1).most_common()
if C0[0][0] != C1[0][0]:
ans = n - C0[0][1] - C1[0][1]
else:
if len(C0) == 1 and len(C1) == 1:
ans = n // 2
elif len(C0) != 1 and len(C1) != 1:
ans = min(n - C0[0][1] - C1[1][1], n - C0[1][1] - C1[0][1])
elif len(C0) != 1 and len(C1) == 1:
ans = n // 2 - C0[0][1]
else:
ans = n // 2 - C1[0][1]
print(ans) | from collections import Counter
n = int(eval(input()))
A = [int(i) for i in input().split()]
S = Counter(A[0::2]).most_common()
T = Counter(A[1::2]).most_common()
if S[0][0] != T[0][0]:
ans = n - S[0][1] - T[0][1]
elif S[0][0] == T[0][0]:
if len(S) == 1 and len(T) > 1:
ans = n // 2 - T[0][1]
elif len(S) > 1 and len(T) == 1:
ans = n // 2 - S[0][1]
elif len(S) > 1 and len(T) > 1:
ans = min(n - S[0][1] - T[1][1], n - S[1][1] - T[0][1])
else:
ans = n // 2
print(ans) | p03244 |
from sys import stdin
from itertools import groupby
n = int(stdin.readline().rstrip())
li = list(map(int,stdin.readline().rstrip().split()))
li1 = []
li2 = []
for i in range(n):
if i % 2 == 0:
li1.append(li[i])
else:
li2.append(li[i])
li1.sort()
li2.sort()
lin = []
lin2 = []
for key, value in groupby(li1):
lin.append((key,len(list(value))))
for key, value in groupby(li2):
lin2.append((key,len(list(value))))
lin.sort(key=lambda x:(x[1]))
lin2.sort(key=lambda x:(x[1]))
point = 0
if lin[-1][0] == lin2[-1][0] and lin[-1][1] == lin2[-1][1]:
if len(lin) == 1:
print((n//2))
else:
if lin[-2][1] >= lin2[-2][1]:
print((n-lin[-2][1]-lin2[-1][1]))
else:
print((n-lin[-1][1]-lin2[-2][1]))
elif lin[-1][0] == lin2[-1][0]:
if len(lin) == 1:
print((n//2-lin2[-2][1]))
elif len(lin2) == 1:
print((n//2-lin[-2][1]))
else:
if lin[-2][1] >= lin2[-2][1]:
print((n-lin[-1][1]-lin2[-2][1]))
else:
print((n-lin[-2][1]-lin2[-1][1]))
else:
print((n-lin[-1][1]-lin2[-1][1])) | from sys import stdin
from itertools import groupby
n = int(stdin.readline().rstrip())
li = list(map(int,stdin.readline().rstrip().split()))
li1 = []
li2 = []
for i in range(n):
if i % 2 == 0:
li1.append(li[i])
else:
li2.append(li[i])
li1.sort()
li2.sort()
lin = []
lin2 = []
for key, value in groupby(li1):
lin.append((key,len(list(value))))
for key, value in groupby(li2):
lin2.append((key,len(list(value))))
lin.sort(key=lambda x:(x[1]))
lin2.sort(key=lambda x:(x[1]))
point = 0
if lin[-1][0] == lin2[-1][0] and lin[-1][1] == lin2[-1][1]:
if len(lin) == 1:
print((n//2))
else:
if lin[-2][1] >= lin2[-2][1]:
print((n-lin[-2][1]-lin2[-1][1]))
else:
print((n-lin[-1][1]-lin2[-2][1]))
elif lin[-1][0] == lin2[-1][0]:
if len(lin) == 1:
print((n//2-lin2[-2][1]))
elif len(lin2) == 1:
print((n//2-lin[-2][1]))
else:
if lin[-2][1] >= lin2[-2][1]:
print((n-lin[-2][1]-lin2[-1][1]))
else:
print((n-lin[-1][1]-lin2[-2][1]))
else:
print((n-lin[-1][1]-lin2[-1][1])) | p03244 |
#!/usr/bin/env python3
import collections
N = int(eval(input()))
V = list(map(int, input().split()))
V1 = V[::2]
V2 = V[1::2]
if len(set(V1)) == 1 and len(set(V2)) == 1 and V1[0] == V2[0]:
print((len(V1)))
exit()
C1 = collections.Counter(V1)
C2 = collections.Counter(V2)
C1_s = sorted(list(C1.items()), key=lambda x:x[1])[::-1]
C2_s = sorted(list(C2.items()), key=lambda x:x[1])[::-1]
max1 = C1_s[0][1]
index1 = C1_s[0][0]
max2 = C2_s[0][1]
index2 = C2_s[0][0]
max1_2 = 0
max2_2 = 0
if len(C1_s) > 1:
max1_2 = C1_s[1][1]
if len(C2_s) > 1:
max2_2 = C2_s[1][1]
nokori1 = len(V1) - max1
nokori2 = len(V2) - max2
nokori1_2 = len(V1) - max1_2
nokori2_2 = len(V2) - max2_2
ans = 0
if index1 == index2:
if len(set(V1)) == 1:
ans = nokori2_2
elif len(set(V2)) == 1:
ans = nokori1_2
else:
ans = min(nokori1_2 + nokori2, nokori1 + nokori2_2)
else:
ans = nokori1 + nokori2
print(ans)
| #!/usr/bin/env python3
import collections
N = int(eval(input()))
V = list(map(int, input().split()))
V1 = V[::2]
V2 = V[1::2]
C1 = collections.Counter(V1)
C2 = collections.Counter(V2)
C1_s = sorted(list(C1.items()), key=lambda x:x[1])[::-1]
C2_s = sorted(list(C2.items()), key=lambda x:x[1])[::-1]
max1 = C1_s[0][1]
index1 = C1_s[0][0]
max2 = C2_s[0][1]
index2 = C2_s[0][0]
max1_2 = 0
max2_2 = 0
if len(C1_s) > 1:
max1_2 = C1_s[1][1]
if len(C2_s) > 1:
max2_2 = C2_s[1][1]
nokori1 = len(V1) - max1
nokori2 = len(V2) - max2
nokori1_2 = len(V1) - max1_2
nokori2_2 = len(V2) - max2_2
ans = 0
if index1 == index2:
ans = min(nokori1_2 + nokori2, nokori1 + nokori2_2)
else:
ans = nokori1 + nokori2
print(ans)
| p03244 |
#!/usr/bin/env python3
import collections
N = int(eval(input()))
V = list(map(int, input().split()))
V1 = V[::2]
V2 = V[1::2]
C1 = collections.Counter(V1)
C2 = collections.Counter(V2)
C1_s = sorted(list(C1.items()), key=lambda x:x[1])[::-1]
C2_s = sorted(list(C2.items()), key=lambda x:x[1])[::-1]
max1 = C1_s[0][1]
index1 = C1_s[0][0]
max2 = C2_s[0][1]
index2 = C2_s[0][0]
max1_2 = 0
max2_2 = 0
if len(C1_s) > 1:
max1_2 = C1_s[1][1]
if len(C2_s) > 1:
max2_2 = C2_s[1][1]
nokori1 = len(V1) - max1
nokori2 = len(V2) - max2
nokori1_2 = len(V1) - max1_2
nokori2_2 = len(V2) - max2_2
ans = 0
if index1 == index2:
ans = min(nokori1_2 + nokori2, nokori1 + nokori2_2)
else:
ans = nokori1 + nokori2
print(ans)
| #!/usr/bin/env python3
import collections
N = int(eval(input()))
V = list(map(int, input().split()))
V1 = V[::2]
V2 = V[1::2]
C1 = collections.Counter(V1)
C2 = collections.Counter(V2)
C1_s = C1.most_common()
C2_s = C2.most_common()
max1 = C1_s[0][1]
index1 = C1_s[0][0]
max2 = C2_s[0][1]
index2 = C2_s[0][0]
max1_2 = 0
max2_2 = 0
if len(C1_s) > 1:
max1_2 = C1_s[1][1]
if len(C2_s) > 1:
max2_2 = C2_s[1][1]
nokori1 = len(V1) - max1
nokori2 = len(V2) - max2
nokori1_2 = len(V1) - max1_2
nokori2_2 = len(V2) - max2_2
ans = 0
if index1 == index2:
ans = min(nokori1_2 + nokori2, nokori1 + nokori2_2)
else:
ans = nokori1 + nokori2
print(ans)
| p03244 |
a, b, c = list(map(int, input().split()))
if min(a, b) < c and c < max(a, b):
print('Yes')
else:
print('No') | a, b, c = list(map(int, input().split()))
if a <= c <= b or b <= c <= a:
print('Yes')
else:
print('No')
| p03067 |
A, B, C = list(map(int,input().split()))
print(('Yes' if A<C<B or A>C>B else 'No')) | A, B, C = list(map(int, input().split()))
print(('Yes' if A-C>0 and C-B>0 or A-C<0 and C-B<0 else 'No')) | p03067 |
a, b, c = list(map(int, input().split()))
if a < c < b or b < c <a:
print("Yes")
else:
print("No") | A, B, C = list(map(int, input().split()))
if A < C < B or B < C < A:
print("Yes")
else:
print("No") | p03067 |
A, B, C = list(map(int, input().split()))
if A < C and C < B:
ans = "Yes"
elif B < C and C < A:
ans = "Yes"
else:
ans = "No"
print(ans)
| def LI():
return list(map(int, input().split()))
A, B, C = LI()
if A < C < B or B < C < A:
ans = "Yes"
else:
ans = "No"
print(ans)
| p03067 |
while True:
n = int(eval(input()))
if n == 0:
break
tlst = []
qlst = []
for _ in range(n):
m, a, b = list(map(int, input().split()))
qlst.append((m, a, b))
tlst.append(a)
tlst.append(b)
tlst.append(b - 1)
tlst = sorted(list(set(tlst)))
tlst.sort()
tdic = {}
for i, t in enumerate(tlst):
tdic[t] = i
lent = len(tlst)
mp = [0] * lent
for m, a, b in qlst:
a, b = tdic[a], tdic[b]
mp[a] += m
mp[b] -= m
acc = 0
for i in range(lent):
acc += mp[i]
if acc > 150:
print("NG")
break
else:
print("OK")
| while True:
n = int(eval(input()))
if n == 0:
break
tlst = []
qlst = []
for _ in range(n):
m, a, b = list(map(int, input().split()))
qlst.append((m, a, b))
tlst.append(a)
tlst.append(b)
tlst = sorted(list(set(tlst)))
tlst.sort()
tdic = {}
for i, t in enumerate(tlst):
tdic[t] = i
lent = len(tlst)
mp = [0] * lent
for m, a, b in qlst:
a, b = tdic[a], tdic[b]
mp[a] += m
mp[b] -= m
acc = 0
for i in range(lent):
acc += mp[i]
if acc > 150:
print("NG")
break
else:
print("OK")
| p00231 |
# from line_profiler import LineProfiler
from collections import deque
def main():
while(True):
W, H = list(map(int, input().split()))
# print(W,H)
if not W: break
tx,ty = list(map(int, input().split()))
kx,ky = list(map(int, input().split()))
ma = [[False]*(W+2) for _ in range(H+2)]
for i in range(1,H+1):
for j,a in enumerate(input().split()):
ma[i][j+1] = bool(1-int(a))
from pprint import pprint
que = deque([[tx,ty,kx,ky,0]])
# pa = [[[[False]*(W+2) for ii in range(H+2)] for jj in range(W+2)] for kk in range(H+2)]
pas = []
ans = "NA"
while(que):
# if len(que)>10:break
# pprint(que)
tx,ty,kx,ky,c = que.popleft()
# import copy
# toprint = copy.deepcopy(ma)
# toprint[ty][tx] = "tt"
# toprint[ky][kx] = "kk"
# for i in range(H+2):
# print("".join(( toprint[i][j] if toprint[i][j] in ["tt","kk"] else " ") if toprint[i][j] else "**" for j in range(W+2)))
if c > 100: break
if tx == kx and ty == ky:
ans = c
break
for dx,dy in [[-1,0],[0,-1],[1,0],[0,1]]:
tdx, tdy = [ dx, dy] if ma[ty+dy][tx+dx] else [0,0]
kdx, kdy = [-dx,-dy] if ma[ky-dy][kx-dx] else [0,0]
# if pa[tx+tdx][ty+tdy][kx+kdx][ky+kdy]: continue
if [tx+tdx,ty+tdy,kx+kdx,ky+kdy] in pas: continue
que.append([tx+tdx,ty+tdy,kx+kdx,ky+kdy,c+1])
# pa[tx+tdx][ty+tdy][kx+kdx][ky+kdy] = True
pas.append([tx+tdx,ty+tdy,kx+kdx,ky+kdy])
print(ans)
# pprint(ma)
if __name__ == "__main__":
# prf = LineProfiler()
# prf.add_function(main)
# prf.runcall(main)
# prf.print_stats()
main()
| # from line_profiler import LineProfiler
from collections import deque
def main():
while(True):
W, H = list(map(int, input().split()))
# print(W,H)
if not W: break
tx,ty = list(map(int, input().split()))
kx,ky = list(map(int, input().split()))
ma = [[False]*(W+2) for _ in range(H+2)]
for i in range(1,H+1):
for j,a in enumerate(input().split()):
ma[i][j+1] = bool(1-int(a))
from pprint import pprint
que = deque([[tx,ty,kx,ky,0]])
# pa = [[[[False]*(W+2) for ii in range(H+2)] for jj in range(W+2)] for kk in range(H+2)]
pas = set()
ans = "NA"
while(que):
# if len(que)>10:break
# pprint(que)
tx,ty,kx,ky,c = que.popleft()
# import copy
# toprint = copy.deepcopy(ma)
# toprint[ty][tx] = "tt"
# toprint[ky][kx] = "kk"
# for i in range(H+2):
# print("".join(( toprint[i][j] if toprint[i][j] in ["tt","kk"] else " ") if toprint[i][j] else "**" for j in range(W+2)))
if c > 100: break
if tx == kx and ty == ky:
ans = c
break
for dx,dy in [[-1,0],[0,-1],[1,0],[0,1]]:
tdx, tdy = [ dx, dy] if ma[ty+dy][tx+dx] else [0,0]
kdx, kdy = [-dx,-dy] if ma[ky-dy][kx-dx] else [0,0]
# if pa[tx+tdx][ty+tdy][kx+kdx][ky+kdy]: continue
if (tx+tdx,ty+tdy,kx+kdx,ky+kdy) in pas: continue
que.append([tx+tdx,ty+tdy,kx+kdx,ky+kdy,c+1])
# pa[tx+tdx][ty+tdy][kx+kdx][ky+kdy] = True
pas.add((tx+tdx,ty+tdy,kx+kdx,ky+kdy))
print(ans)
# pprint(ma)
if __name__ == "__main__":
# prf = LineProfiler()
# prf.add_function(main)
# prf.runcall(main)
# prf.print_stats()
main()
| p00223 |
from collections import deque
while(True):
W, H = list(map(int, input().split()))
if not W: break
tx,ty = list(map(int, input().split()))
kx,ky = list(map(int, input().split()))
ma = [[False]*(W+2) for _ in range(H+2)]
for i in range(1,H+1):
for j,a in enumerate(input().split()):
ma[i][j+1] = bool(1-int(a))
from pprint import pprint
que = deque([[tx,ty,kx,ky,0]])
pas = set()
ans = "NA"
while(que):
tx,ty,kx,ky,c = que.popleft()
if c > 100: break
if tx == kx and ty == ky:
ans = c
break
for dx,dy in [[-1,0],[0,-1],[1,0],[0,1]]:
tdx, tdy = [ dx, dy] if ma[ty+dy][tx+dx] else [0,0]
kdx, kdy = [-dx,-dy] if ma[ky-dy][kx-dx] else [0,0]
if (tx+tdx,ty+tdy,kx+kdx,ky+kdy) in pas: continue
que.append([tx+tdx,ty+tdy,kx+kdx,ky+kdy,c+1])
pas.add((tx+tdx,ty+tdy,kx+kdx,ky+kdy))
print(ans)
| # from line_profiler import LineProfiler
from collections import deque
def main():
while(True):
W, H = list(map(int, input().split()))
if not W: break
tx,ty = list(map(int, input().split()))
kx,ky = list(map(int, input().split()))
ma = [[False]*(W+2) for _ in range(H+2)]
for i in range(1,H+1):
for j,a in enumerate(input().split()):
ma[i][j+1] = bool(1-int(a))
from pprint import pprint
que = deque([[tx,ty,kx,ky,0]])
pas = set()
ans = "NA"
while(que):
tx,ty,kx,ky,c = que.popleft()
if c > 100: break
if tx == kx and ty == ky:
ans = c
break
for dx,dy in [[-1,0],[0,-1],[1,0],[0,1]]:
tdx, tdy = [ dx, dy] if ma[ty+dy][tx+dx] else [0,0]
kdx, kdy = [-dx,-dy] if ma[ky-dy][kx-dx] else [0,0]
if (tx+tdx,ty+tdy,kx+kdx,ky+kdy) in pas: continue
que.append([tx+tdx,ty+tdy,kx+kdx,ky+kdy,c+1])
pas.add((tx+tdx,ty+tdy,kx+kdx,ky+kdy))
print(ans)
if __name__ == "__main__":
# prf = LineProfiler()
# prf.add_function(main)
# prf.runcall(main)
# prf.print_stats()
main()
| p00223 |
# from line_profiler import LineProfiler
from collections import deque
from sys import stdin
def main():
while(True):
W, H = list(map(int, stdin.readline().split()))
if not W: break
tx,ty = list(map(int, stdin.readline().split()))
kx,ky = list(map(int, stdin.readline().split()))
ma = [[False]*(W+2) for _ in range(H+2)]
for i in range(1,H+1):
for j,a in enumerate(stdin.readline().split()):
ma[i][j+1] = bool(1-int(a))
que = deque([[tx,ty,kx,ky,0]])
pas = set()
ans = "NA"
while(que):
tx,ty,kx,ky,c = que.popleft()
if not(tx-kx or ty-ky):
ans = c
break
for dx,dy in [[-1,0],[0,-1],[1,0],[0,1]]:
tdx, tdy = [ dx, dy] if ma[ty+dy][tx+dx] else [0,0]
kdx, kdy = [-dx,-dy] if ma[ky-dy][kx-dx] else [0,0]
if (tx+tdx,ty+tdy,kx+kdx,ky+kdy) in pas: continue
if c+1 > 100: continue
que.append([tx+tdx,ty+tdy,kx+kdx,ky+kdy,c+1])
pas.add((tx+tdx,ty+tdy,kx+kdx,ky+kdy))
print(ans)
if __name__ == "__main__":
# prf = LineProfiler()
# prf.add_function(main)
# prf.runcall(main)
# prf.print_stats()
main()
| # from line_profiler import LineProfiler
from collections import deque
from sys import stdin
def main():
while(True):
W, H = list(map(int, stdin.readline().split()))
if not W: break
tx,ty = list(map(int, stdin.readline().split()))
kx,ky = list(map(int, stdin.readline().split()))
ma = [[False]*(W+2) for _ in range(H+2)]
for i in range(1,H+1):
for j,a in enumerate(stdin.readline().split()):
ma[i][j+1] = bool(1-int(a))
que = deque([[tx,ty,kx,ky,0]])
pas = set()
ans = "NA"
while(que):
tx,ty,kx,ky,c = que.popleft()
if tx == kx and ty == ky:
ans = c
break
for dx,dy in [[-1,0],[0,-1],[1,0],[0,1]]:
tdx, tdy = ( dx, dy) if ma[ty+dy][tx+dx] else (0,0)
kdx, kdy = (-dx,-dy) if ma[ky-dy][kx-dx] else (0,0)
ttx,tty,kkx,kky = tx+tdx,ty+tdy,kx+kdx,ky+kdy
if (ttx,tty,kkx,kky) in pas: continue
if c+1 > 100: continue
que.append([ttx,tty,kkx,kky,c+1])
pas.add((ttx,tty,kkx,kky))
print(ans)
if __name__ == "__main__":
# prf = LineProfiler()
# prf.add_function(main)
# prf.runcall(main)
# prf.print_stats()
main()
| p00223 |
# from line_profiler import LineProfiler
from collections import deque
from sys import stdin
def main():
while(True):
W, H = list(map(int, stdin.readline().split()))
if not W: break
tx,ty = list(map(int, stdin.readline().split()))
kx,ky = list(map(int, stdin.readline().split()))
ma = [[0]+[abs(1-int(a)) for a in stdin.readline().split()]+[0] for i in range(H)]
ma = [[0]*(W+2)] + ma + [[0]*(W+2)]
que = deque([[tx,ty,kx,ky,0]])
pas = set()
ans = "NA"
while(que):
tx,ty,kx,ky,c = que.popleft()
if tx == kx and ty == ky:
ans = c
break
if c+1 > 100: continue
for dx,dy in [[-1,0],[0,-1],[1,0],[0,1]]:
tdx, tdy = dx * ma[ty+dy][tx+dx], dy * ma[ty+dy][tx+dx]
kdx, kdy = -dx * ma[ky-dy][kx-dx], -dy * ma[ky-dy][kx-dx]
ttx,tty,kkx,kky = tx+tdx,ty+tdy,kx+kdx,ky+kdy
if (ttx,tty,kkx,kky) in pas: continue
que.append([ttx,tty,kkx,kky,c+1])
pas.add((ttx,tty,kkx,kky))
print(ans)
if __name__ == "__main__":
# prf = LineProfiler()
# prf.add_function(main)
# prf.runcall(main)
# prf.print_stats()
main()
| # from line_profiler import LineProfiler
from collections import deque
from sys import stdin
def main():
while(True):
W, H = list(map(int, stdin.readline().split()))
if not W: break
tx,ty = list(map(int, stdin.readline().split()))
kx,ky = list(map(int, stdin.readline().split()))
ma = [[False]+[bool(1-int(a)) for a in stdin.readline().split()]+[False] for i in range(H)]
ma = [[False]*(W+2)] + ma + [[False]*(W+2)]
que = deque([[tx,ty,kx,ky,0]])
pas = set()
ans = "NA"
while(que):
tx,ty,kx,ky,c = que.popleft()
if tx == kx and ty == ky:
ans = c
break
if c+1 > 100: continue
for dx,dy in [[-1,0],[0,-1],[1,0],[0,1]]:
tdx, tdy = ( dx, dy) if ma[ty+dy][tx+dx] else (0,0)
kdx, kdy = (-dx,-dy) if ma[ky-dy][kx-dx] else (0,0)
ttx,tty,kkx,kky = tx+tdx,ty+tdy,kx+kdx,ky+kdy
if (ttx,tty,kkx,kky) in pas: continue
que.append([ttx,tty,kkx,kky,c+1])
pas.add((ttx,tty,kkx,kky))
print(ans)
if __name__ == "__main__":
# prf = LineProfiler()
# prf.add_function(main)
# prf.runcall(main)
# prf.print_stats()
main()
| p00223 |
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True and False
BIG = 10**18
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
def cmp1(a,b,stt):
l = []
for i in range(stt,len(a)):
ok = True
for j in range(min(len(b),len(a)-i)):
#ddprint("a {} b {} i {} j {}".format(a,b,i,j))
#ddprint("aij {} bj {}".format(a[i+j],b[j]))
if a[i+j]!='?' and b[j]!='?' and a[i+j]!=b[j]:
ok = False
break
if ok:
l.append(i)
#ddprint("cmp1 a {} b {} l {}".format(a,b,l))
return l
def cmp(a,b):
l1 = cmp1(a,b,0)
l2 = cmp1(b,a,1)
return (l1,l2)
a = ins()
b = ins()
c = ins()
la = len(a)
lb = len(b)
lc = len(c)
ab = cmp(a,b)
ac = cmp(a,c)
bc = cmp(b,c)
ddprint(ab)
ddprint(ac)
ddprint(bc)
ba = (ab[1],ab[0])
ca = (ac[1],ac[0])
cb = (bc[1],bc[0])
mn = la+lb+lc
for p in [0,1]:
for q in [0,1]:
for ii in ab[p]:
i = ii if p==0 else -ii
for jj in ac[q]:
j = jj if q==0 else -jj
if lc+j<=i or lb+i<=j or (j-i) in bc[0] or (i-j) in bc[1]:
v = max([la,lb+i,lc+j]) + max(0,-i,-j)
mn = min(mn,v)
ddprint(mn)
for p in [0,1]:
for q in [0,1]:
for ii in ba[p]:
i = ii if p==0 else -ii
for jj in bc[q]:
j = jj if q==0 else -jj
if lc+j<=i or la+i<=j or (j-i) in ac[0] or (i-j) in ac[1]:
v = max([la+i,lb,lc+j]) + max(0,-i,-j)
mn = min(mn,v)
ddprint(mn)
for p in [0,1]:
for q in [0,1]:
for ii in ca[p]:
i = ii if p==0 else -ii
for jj in cb[q]:
j = jj if q==0 else -jj
if lb+j<=i or la+i<=j or (j-i) in ab[0] or (i-j) in ab[1]:
v = max([la+i,lb+j,lc]) + max(0,-i,-j)
mn = min(mn,v)
ddprint(mn)
for p in [0,1]:
for i in ab[p]:
i = ii if p==0 else -ii
v = max(la,lb+i)+max(0,-i)+lc
mn = min(mn,v)
ddprint(mn)
for p in [0,1]:
for i in ac[p]:
i = ii if p==0 else -ii
v = max(la,lc+i)+max(0,-i)+lb
mn = min(mn,v)
ddprint(mn)
for p in [0,1]:
for i in bc[p]:
i = ii if p==0 else -ii
v = max(lb,lc+i)+max(0,-i)+la
mn = min(mn,v)
print(mn)
| printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True and False
BIG = 10**18
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
def cmp1(a,b):
l = []
for i in range(len(a)):
ok = True
for j in range(min(len(b),len(a)-i)):
#ddprint("a {} b {} i {} j {}".format(a,b,i,j))
#ddprint("aij {} bj {}".format(a[i+j],b[j]))
if a[i+j]!='?' and b[j]!='?' and a[i+j]!=b[j]:
ok = False
break
if ok:
l.append(i)
#ddprint("cmp1 a {} b {} l {}".format(a,b,l))
return l
def chk3(mn,a,b,c,ab,ac,bc):
for i in ab:
v = max(len(a),len(b)+i)+len(c)
mn = min(mn,v)
for j in bc:
if len(a)-i<=j or (j+i) in ac:
v = max([len(a),len(b)+i,len(c)+i+j])
mn = min(mn,v)
for j in ac:
if len(b)+i<=j:
v = max(len(a),len(c)+j)
mn = min(mn,v)
for i in bc:
v = max(len(b),len(c)+i)+len(a)
mn = min(mn,v)
return mn
def solve(a,b,c):
ab = cmp1(a,b)
ac = cmp1(a,c)
bc = cmp1(b,c)
ba = cmp1(b,a)
ca = cmp1(c,a)
cb = cmp1(c,b)
mn = len(a)+len(b)+len(c)
ddprint(mn)
mn = chk3(mn,a,b,c,ab,ac,bc)
ddprint(mn)
mn = chk3(mn,a,c,b,ac,ab,cb)
ddprint(mn)
mn = chk3(mn,b,a,c,ba,bc,ac)
ddprint(mn)
mn = chk3(mn,b,c,a,bc,ba,ca)
ddprint(mn)
mn = chk3(mn,c,a,b,ca,cb,ab)
ddprint(mn)
mn = chk3(mn,c,b,a,cb,ca,ba)
return mn
a = ins()
b = ins()
c = ins()
mn = solve(a,b,c)
print(mn)
| p02745 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(A, B, C):
@lru_cache(maxsize=None)
def g(x, y):
m = []
for i in range(len(x)):
for j in range(min(len(y), len(x)-i)):
if not (x[i+j] == '?' or y[j] == '?' or x[i+j] == y[j]):
break
else:
m.append(i)
m.append(len(x))
return m
def f(x, y, z):
N = len(x) + len(y) + len(z)
ans = N
xy = g(x, y)
yz = g(y, z)
xz = g(x, z)
# print(xy, yz, xz)
xz_set = set(xz)
for i in xy:
for j in yz:
if i + j < len(x) and i + j in xz_set:
s = max(i + len(y), i + j + len(z), len(x))
elif i + j < len(x) and i + len(y) :
l = bisect.bisect_left(xz, i+len(y))
if l >= len(xz):
continue
k = xz[l]
# print(k, xz)
s = max(i + len(y), k + len(z), len(x))
elif i + j >= len(x):
s = max(i + len(y), i + j + len(z), len(x))
else:
continue
# print(x, y, z, i, j, s)
ans = min(ans, s)
return ans
ans = INF
for a, b, c in permutations((A, B, C)):
ans = min(ans, f(a, b, c))
return ans
def ref(A, B, C):
def f(x, y):
for i in range(len(x)):
for j in range(min(len(y), len(x)-i)):
if not (x[i+j] == '?' or y[j] == '?' or x[i+j] == y[j]):
break
else:
if len(y) > len(x)-i:
s = x + y[len(x)-i:]
s = list(s)
for j in range(len(x)-i):
if (x[i+j] == '?' and y[j] != '?'):
s[i+j] = y[j]
yield ''.join(s)
else:
s = list(x)
for j in range(len(y)):
if (x[i+j] == '?' and y[j] != '?'):
s[i+j] = y[j]
yield ''.join(s)
yield x + y
ans = INF
for x, y, z in permutations((A, B, C)):
# print('-----', x, y, z)
for xy in f(x, y):
for xyz in f(xy, z):
# print(xyz, len(xyz), xy)
ans = min(ans, len(xyz))
return ans
def main():
A = read_str()
B = read_str()
C = read_str()
print(slv(A, B, C))
# print(ref(A, B, C))
# # A, B, C = ['b', 'cacdd', 'b']
# # A, B, C = ['d', 'acadcdac', 'ca']
# # A, B, C = ['ab?b', 'bb', 'bc?']
# # A, B, C = ['?aaa', 'b?ac', 'b?a?a']
# # A, B, C = ['acb', 'b??bc', 'cccbc?b']
# A, B, C = ['?bbbb', 'aa', 'cccba?ca']
# # A, B, C = ['abba', '?cb', 'ccacba?a']
# print(slv(A, B, C))
# print(ref(A, B, C))
# D = '?'*2000
# print(slv(D, D, D))
# for _ in range(10000):
# cs = 'abc?'
# A = ''.join(random.choices(cs, k=random.randint(1, 10)))
# B = ''.join(random.choices(cs, k=random.randint(1, 10)))
# C = ''.join(random.choices(cs, k=random.randint(1, 10)))
# a = slv(A, B, C)
# b = ref(A, B, C)
# if a != b:
# print(A)
# print(B)
# print(C)
# print(a, b)
# break
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
from functools import lru_cache
from itertools import permutations
import bisect
INF = 2**62-1
def read_str():
return input().strip()
def slv(A, B, C):
@lru_cache(maxsize=None)
def g(x, y):
m = []
for i in range(len(x)):
for j in range(min(len(y), len(x)-i)):
if not (x[i+j] == '?' or y[j] == '?' or x[i+j] == y[j]):
break
else:
m.append(i)
m.append(len(x))
return m
def f(x, y, z):
lx = len(x)
ly = len(y)
lz = len(z)
ans = lx + ly + lz
xy = g(x, y)
yz = g(y, z)
xz = g(x, z)
xz_set = set(xz)
for i in xy:
for j in yz:
if i + j < lx and i + j in xz_set:
s = max(i + ly, i + j + lz, lx)
elif i + j < lx and i + len(y) :
l = bisect.bisect_left(xz, i+ly)
if l >= len(xz):
continue
k = xz[l]
s = max(i + ly, k + len(z), len(x))
elif i + j >= lx:
s = max(i + ly, i + j + lz, lx)
else:
continue
ans = min(ans, s)
return ans
ans = INF
for a, b, c in permutations((A, B, C)):
ans = min(ans, f(a, b, c))
return ans
def main():
A = read_str()
B = read_str()
C = read_str()
print((slv(A, B, C)))
if __name__ == '__main__':
main()
| p02745 |
def match(ch1, ch2):
return ch1 == ch2 or ch1 == '?' or ch2 == '?'
def solve():
MAXLEN = 2000
a = input()
b = input()
c = input()
lA = len(a); lB = len(b); lC = len(c)
MAXLEN = max(lA, lB, lC)
ab = [True for i in range(10*MAXLEN)]
ac = [True for i in range(10*MAXLEN)]
bc = [True for i in range(10*MAXLEN)]
for i in range(lA):
for j in range(lB):
if not match(a[i], b[j]):
ab[i - j + 5 * MAXLEN] = False
for i in range(lA):
for j in range(lC):
if not match(a[i], c[j]):
ac[i - j + 5 * MAXLEN] = False
for i in range(lB):
for j in range(lC):
if not match(b[i], c[j]):
bc[i - j + 5 * MAXLEN] = False
ret = lA + lB + lC
for i in range(-2*MAXLEN, 2*MAXLEN+1):
for j in range(-2*MAXLEN, 2*MAXLEN+1):
if ab[i + 5*MAXLEN] and ac[j + 5*MAXLEN] and bc[j - i + 5*MAXLEN]:
L = min(0, i, j)
R = max(lA, lB + i, lC + j)
ret = min(ret, R - L)
print(ret)
if __name__ == '__main__':
solve()
| def match(ch1, ch2):
return ch1 == ch2 or ch1 == '?' or ch2 == '?'
def solve():
MAXLEN = 2000
a = input()
b = input()
c = input()
lA = len(a); lB = len(b); lC = len(c)
MAXLEN = max(lA, lB, lC)
ab = [True for i in range(10*MAXLEN)]
ac = [True for i in range(10*MAXLEN)]
bc = [True for i in range(10*MAXLEN)]
for i in range(lA):
for j in range(lB):
if not match(a[i], b[j]):
ab[i - j + 5 * MAXLEN] = False
for i in range(lA):
for j in range(lC):
if not match(a[i], c[j]):
ac[i - j + 5 * MAXLEN] = False
for i in range(lB):
for j in range(lC):
if not match(b[i], c[j]):
bc[i - j + 5 * MAXLEN] = False
ret = lA + lB + lC
for i in range(-2*MAXLEN, 2*MAXLEN+1):
for j in range(-2*MAXLEN, 2*MAXLEN+1):
if i < -MAXLEN and j > 0:
continue
if i > MAXLEN and j < 0:
continue
if j < -MAXLEN and i > 0:
continue
if j > MAXLEN and i < 0:
continue
if ab[i + 5*MAXLEN] and ac[j + 5*MAXLEN] and bc[j - i + 5*MAXLEN]:
L = min(0, i, j)
R = max(lA, lB + i, lC + j)
ret = min(ret, R - L)
print(ret)
if __name__ == '__main__':
solve()
| p02745 |
def solve(N):
d = 10 ** 7
index = d // 2
while True:
k1 = index * (index - 1) // 2
k2 = index * (index + 1) // 2
if k1 <= N < k2:
break
elif k1 < N:
index = (index + d) // 2
else:
d = index
index = index // 2
d = k2 - N
return "\n".join([str(i) for i in range(1, index + 1) if i != d])
if __name__ == "__main__":
N = int(eval(input()))
print((solve(N)))
| def solve(N):
d = 10 ** 7
index = d // 2
while True:
k1 = index * (index - 1) // 2
k2 = index * (index + 1) // 2
if k1 < N <= k2:
break
elif k1 <= N:
index = (index + d) // 2
else:
d = index
index = index // 2
d = k2 - N
return "\n".join([str(i) for i in range(1, index + 1) if i != d])
if __name__ == "__main__":
N = int(eval(input()))
print((solve(N)))
| p03920 |
# -*- coding: utf-8 -*-
n = int(eval(input()))
for k in range(1,n+1):
s = k*(k+1)//2
if s==n:
res = set(range(1,k+1))
break
if s>=n and (s-n)<=k:
res = set(range(1,k+1))
res.remove(s-n)
for r in res:
print(r)
| # -*- coding: utf-8 -*-
n = int(eval(input()))
for k in range(1,n+1):
s = k*(k+1)//2
if s==n:
res = set(range(1,k+1))
break
if s>=n and (s-n)<=k:
res = set(range(1,k+1))
res.remove(s-n)
break
for r in res:
print(r)
| p03920 |
N = int(eval(input()))
n = tri = 1
while tri < N:
n += 1
tri += n
for i in range(1,n+1):
if i == tri - N: continue
print(i) | N = int(input())
m = s = 1
while s < N:
m += 1
s += m
ans = [m]
rem = N-m
if rem:
for n in range(m-1,0,-1):
if n <= rem:
ans.append(n)
rem -= n
if rem==0: break
print(*reversed(ans), sep='\n')
| p03920 |
n = int(eval(input()))
s = 0
cnt = 1
while True:
s += cnt
if s < n <= s+cnt+1:
use = cnt+1
sub = use*(use+1)//2 - n
for i in range(use):
if i+1 == sub:
continue
print((i+1))
exit()
else:
cnt += 1
| n = int(eval(input()))
if n == 1:
print((1))
exit()
s = 0
cnt = 1
while True:
s += cnt
if s < n <= s+cnt+1:
use = cnt+1
sub = use*(use+1)//2 - n
for i in range(use):
if i+1 == sub:
continue
print((i+1))
exit()
else:
cnt += 1
| p03920 |
# Author: cr4zjh0bp
# Created: Sun Mar 22 23:25:40 UTC 2020
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
from collections import Counter
s = ns()
c = Counter(s)
print(("yes" if len(s) == len(c) else "no")) | # Author: cr4zjh0bp
# Created: Sun Mar 22 23:25:40 UTC 2020
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
s = ns()
print(("yes" if len(s) == len(set(s)) else "no")) | p03698 |
s = input()
l = list(s)
ans = "yes"
l.sort()
for i in range(len(s)-1):
if l[i] == l[i+1]:
ans = "no"
break
print(ans) | L = list(input())
print("yes" if len(L) == len(set(L)) else "no")
| p03698 |
def dist(a,b,c,d,n):
L=3**n
area1=(a//L)*3+b//L
if area1==2:
b=3*L-b-1
d=3*L-d-1
if area1==3:
a,b=b,a
c,d=d,c
if area1==5:
a,b=3*L-b-1,a
c,d=3*L-d-1,c
if area1 in [6,7]:
a=L*3-a-1
c=L*3-c-1
if area1==8:
a,b=L*3-a-1,L*3-b-1
c,d=L*3-c-1,L*3-d-1
area1=(a//L)*3+b//L
area2=(c//L)*3+d//L
if area1>8 or area2>8:
a=0
while True:
a+=1
if n==0:
if area1==1 and area2==7: return 4
else: return abs(a-c)+abs(b-d)
if area1>area2:
a,b,c,d=c,d,a,b
area1,area2=area2,area1
if area1==area2:
return dist(a%L,b%L,c%L,d%L,n-1)
elif area1==0:
if area2 in [5,7,8]:
return abs(a-c)+abs(b-d)
elif area2 in [3,6]:
return dist(b,a,d,c,n)
elif area2 in [1,2]:
L=3**(n-1)
a12=(a//L)*3+b//L
a22=(c//L)*3+(d-3*area2*L)//L
if a//L!=c//L:
return abs(a-c)+abs(b-d)
elif a//L==0:
p=(d//L)-(b//L)
if p==1: return dist(a,b-2*L,c,d-2*L,n-1)
else: return dist(a,b%L,c,d-(p-2)*L,n-1)+(p-2)*L
elif a//L==1:
if area2==1 and a12==5 and a22==3:
return dist(a-L,b-2*L,c-L,d-2*L,n)
else:
return min(a+c-2*(L-1),4*L-a-c)+abs(b-d)
elif a//L==2: return dist(a-2*L,b,c-2*L,d,n)
else: return 0
elif area1==1:
if area2 in [3,5,6,8]:
return abs(a-c)+abs(b-d)
elif area2==2:
return dist(a,b-L,c,d-L,n)
elif area2==7:
return min(b+d-2*(L-1),(4*L)-b-d)+abs(a-c)
else: return 0
for i in range(int(eval(input()))):
a,b,c,d=list(map(int,input().split()))
print((dist(a-1,b-1,c-1,d-1,29))) | def dist(a,b,c,d,n):
L=3**n
area1=(a//L)*3+b//L
if area1==2:
b=3*L-b-1
d=3*L-d-1
if area1==3:
a,b=b,a
c,d=d,c
if area1==5:
a,b=3*L-b-1,a
c,d=3*L-d-1,c
if area1 in [6,7]:
a=L*3-a-1
c=L*3-c-1
if area1==8:
a,b=L*3-a-1,L*3-b-1
c,d=L*3-c-1,L*3-d-1
area1=(a//L)*3+b//L
area2=(c//L)*3+d//L
if area1>8 or area2>8:
a=0
while True:
a+=1
if n==0:
if area1==1 and area2==7: return 4
else: return abs(a-c)+abs(b-d)
if area1>area2:
a,b,c,d=c,d,a,b
area1,area2=area2,area1
if area1==area2:
return dist(a%L,b%L,c%L,d%L,n-1)
elif area1==0:
if area2 in [5,7,8]:
return abs(a-c)+abs(b-d)
elif area2 in [3,6]:
return dist(b,a,d,c,n)
elif area2 in [1,2]:
L=3**(n-1)
a12=(a//L)*3+b//L
a22=(c//L)*3+(d-3*area2*L)//L
if a//L!=c//L:
return abs(a-c)+abs(b-d)
elif a//L==0:
p=(d//L)-(b//L)
if p==1: return dist(a,b-2*L,c,d-2*L,n-1)
else: return dist(a,b%L,c,d%L+2*L,n-1) +(p-2)*L
elif a//L==1:
if area2==1 and a12==5 and a22==3: return dist(a-L,b-2*L,c-L,d-2*L,n)
else: return min(a+c-2*(L-1),4*L-a-c)+abs(b-d)
elif a//L==2: return dist(a-2*L,b,c-2*L,d,n)
else: return 0
elif area1==1:
if area2 in [3,5,6,8]:
return abs(a-c)+abs(b-d)
elif area2==2:
return dist(a,b-L,c,d-L,n)
elif area2==7:
return min(b+d-2*(L-1),(4*L)-b-d)+abs(a-c)
else: return 0
for i in range(int(eval(input()))):
a,b,c,d=list(map(int,input().split()))
print((dist(a-1,b-1,c-1,d-1,29))) | p02746 |
def solve(a, b, c, d):
for k in range(29, -1, -1):
block_size = 3**k
box_size = block_size * 3
x1, y1, x2, y2 = [x//block_size for x in (a, b, c, d)]
x1, x2 = sorted([x1, x2])
y1, y2 = sorted([y1, y2])
if x1!=x2 and y1!=y2:
return abs(a-c)+abs(b-d)
if x1==x2 and x1%3==1 and (y1+1)//3*3+1<y2:
a, c = [x%box_size for x in (a, c)]
return min(a+c-2*block_size+2, 4*block_size-a-c)+abs(b-d)
elif y1==y2 and y1%3==1 and (x1+1)//3*3+1<x2:
b, d = [x%box_size for x in (b, d)]
return min(b+d-2*block_size+2, 4*block_size-b-d)+abs(a-c)
return abs(a-c)+abs(b-d)
for i in range(int(eval(input()))):
print((solve(*[int(x)-1 for x in input().split()])))
| def solve(a, b, c, d):
a, c = sorted([a, c])
b, d = sorted([b, d])
for k in range(30, 0, -1):
block_size = 3**k
box_size = block_size // 3
x1, y1, x2, y2 = [x//box_size for x in (a, b, c, d)]
if x1 != x2 and y1 != y2:
return c-a + d-b
elif x1 == x2 and x1%3 == 1 and (y1+1)//3*3+1 < y2:
shifted = (a+c) % (2*block_size)
return min(shifted-2*box_size+2, 4*box_size-shifted) + d-b
elif y1 == y2 and y1%3 == 1 and (x1+1)//3*3+1 < x2:
shifted = (b+d) % (2*block_size)
return min(shifted-2*box_size+2, 4*box_size-shifted) + c-a
return c-a + d-b
for i in range(int(eval(input()))):
print((solve(*[int(x)-1 for x in input().split()])))
| p02746 |
from sys import stdin, stdout
import math
import bisect
import re
s, w = list(map(int, stdin.readline().strip().split()))
stdout.writelines('unsafe\n' if w >= s else 'safe\n')
| a, b = [int(a) for a in input().split()]
print(("unsafe" if a <= b else "safe")) | p02699 |
s,w = list(map(int,input().split()))
if s <= w:
print("unsafe")
else:
print("safe") | s,w = list(map(int,input().split()))
if w >= s:
print("unsafe")
else:
print("safe") | p02699 |
import sys
input = lambda: sys.stdin.readline().rstrip()
safe = lambda boolean: print('safe') if boolean else print('unsafe')
ints = lambda: list(map(int, input().split()))
s,w = ints()
safe(s>w)
| s,w=map(int,input().split());print('safe')if s>w else print('unsafe')
| p02699 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
s, w = list(map(int, readline().split()))
if w >= s:
print("unsafe")
else:
print("safe")
if __name__ == '__main__':
main()
| s, w = list(map(int, input().split()))
if w >= s:
print("unsafe")
else:
print("safe") | p02699 |
a, b = [int(a) for a in input().split()]
print(("unsafe" if a <= b else "safe")) | a, b=[int(yy) for yy in input().split()]
if b>=a:
print('unsafe')
else:
print("safe")
| p02699 |
def main():
ans = 'safe'
s,w = list(map(int, input().split()))
if w >= s:
ans = 'unsafe'
print(ans)
if __name__ == '__main__':
main() | s,w = list(map(int, input().split()))
if s <= w:
print('unsafe')
else:
print('safe') | p02699 |
s , w = list(map(int, input().split()))
if w>=s:
print("unsafe")
else:
print("safe") | S, W =list(map(int,input().split()))
if W>=S:
print("unsafe")
else:
print("safe") | p02699 |
s, w = list(map(int, input().split()))
if w >= s:
print('unsafe')
else:
print('safe') | s, w = map(int, input().split())
print('unsafe') if w >= s else print('safe')
| p02699 |
s,w = (int(x) for x in input().split())
# xl = map(int, input().split())
if w >= s:
print('unsafe')
else:
print('safe')
| s,w = (int(x) for x in input().split())
if w >= s:
print('unsafe')
else:
print('safe')
| p02699 |
S, W = list(map(int, input().split()))
if S>W:
print("safe")
else:
print("unsafe") | s, w = list(map(int, input().split()))
if s>w:
print("safe")
else:
print("unsafe") | p02699 |
def main():
s,w = list(map(int,input().split()))
if s <= w:
print("unsafe")
else:
print("safe")
if __name__ == '__main__':
main()
| def main():
s,w = list(map(int,input().split()))
answer = "unsafe" if w >= s else "safe"
print(answer)
if __name__ == '__main__':
main()
| p02699 |
s,w = list(map(int,input().split()))
print((["safe","unsafe"][w>=s])) | s,w=list(map(int,input().split()));print((["","un"][w>=s]+"safe")) | p02699 |
import sys
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
def solve():
s, w = list(map(int, rl().split()))
if s > w:
print('safe')
else:
print('unsafe')
if __name__ == '__main__':
solve()
| def solve():
S, W = list(map(int,input().split()))
if S > W:
print("safe")
else:
print("unsafe")
if __name__ == '__main__':
solve()
| p02699 |
s,w=list(map(int,input().split()))
if s>w:
print("safe")
else:
print("unsafe") | s,w=list(map(int,input().split()))
if s>w:
print("safe")
elif s<=w:
print("unsafe") | p02699 |
S, W = list(map(int, input().split()))
if W >= S:
print('unsafe')
else:
print('safe') | S, W = input().split()
if int(W) >= int(S):
print('unsafe')
else:
print('safe')
| p02699 |
def issafe(S,W):
if S > W:
return "safe"
return "unsafe"
S,W = list(map(int,input().split()))
print((issafe(S,W)))
| def main():
s,w = list(map(int,input().split()))
if s>w:
print("safe")
else:
print("unsafe")
main()
| p02699 |
s, w = list(map(int,input().split()))
if s <= w:
print('unsafe')
else:
print('safe') | s,w = list(map(int,input().split()))
if s <= w:
print('unsafe')
elif s > w:
print('safe')
| p02699 |
MAX_VAL = 99999999999
while 1:
n,m = list(map(int,input().split()))
if n == 0:break
costs = {x:[] for x in range(1,n+1)}
min_cost = [[MAX_VAL for x in range(2)] for y in range(n+1)]
for i in range(m):
a,b,c = list(map(int,input().split()))
costs[a].append((b,c))
costs[b].append((a,c))
spam = [(0,1,2)] #(cost,num,free tickets count)
while len(spam) > 0:
mc = min(spam)
spam.remove(mc)
tic_i = 0 if mc[2] == 2 else 1
if mc[2] != 1 and min_cost[mc[1]][tic_i] != MAX_VAL:
continue
if mc[2] != 1:
min_cost[mc[1]][tic_i] = mc[0]
#移動できる場所の登録
for cv in costs[mc[1]]:
#チケット不使用
if mc[2] != 1:
spam.append((mc[0] + cv[1],cv[0],mc[2]))
#チケット使用
if mc[2] > 0:
spam.append((mc[0],cv[0],mc[2]-1))
#print(min_cost[n])
print((min(min_cost[n]))) | MAX_V = 999999999999999999999
while 1:
n,m = list(map(int,input().split()))
if n == 0:break
costs = {x:[] for x in range(1,n+1)}
passed = [[0 for x in range(2)] for y in range(n+1)]
result = [MAX_V,MAX_V]
for i in range(m):
a,b,c = list(map(int,input().split()))
costs[a].append((b,c))
costs[b].append((a,c))
spam = [(0,1,2)] #(cost,num,free tickets count)
while len(spam) > 0:
mc = min(spam)
spam.remove(mc)
tic_i = 0 if mc[2] == 2 else 1
if mc[2] != 1 and passed[mc[1]][tic_i] != 0:
continue
if mc[2] != 1:
passed[mc[1]][tic_i] = 1
if n == mc[1]:
result[tic_i] = mc[0]
if max(result) < MAX_V:break
#移動できる場所の登録
for cv in costs[mc[1]]:
#チケット不使用
if mc[2] != 1:
spam.append((mc[0] + cv[1],cv[0],mc[2]))
#チケット使用
if mc[2] > 0:
spam.append((mc[0],cv[0],mc[2]-1))
print((min(result))) | p00244 |
def resolve():
n,x=list(map(int, input().split()))
l=list(map(int, input().split()))
l.sort()
num=0
cnt=0
for i in range(n-1):
if num+l[i]<=x:
num+=l[i]
cnt+=1
if l[n-1]==x-num:
cnt+=1
print(cnt)
resolve() | def resolve():
import sys
n,x=list(map(int, input().split()))
l=list(map(int, input().split()))
l.sort()
cnt=0
for i in range(n):
if l[i]<=x:
x-=l[i]
cnt+=1
else:
print(i)
sys.exit()
if cnt==n and x>0:
cnt-=1
print(cnt)
resolve() | p03254 |
def memoize(f):
table = dict()
def wrapper(x, i, a):
key = (x, i)
if key in table:
return table[key]
else:
v = f(x, i, a)
table[key] = v
return v
return wrapper
@memoize
def solve(x, i, a):
if i == len(a) - 1:
if a[i] == x:
return 1
else:
return 0
if x < a[i]:
return 0
else:
m = solve(x - a[i], i + 1, a) + 1
n = solve(x, i + 1, a)
return max(m, n)
def main():
n, x = [int(s) for s in input().split()]
a = tuple(sorted(int(s) for s in input().split()))
print((solve(x, 0, a)))
main()
| def main():
n, x = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
a.sort()
cnt = 0
for i, y in enumerate(a):
if x < y:
break
x -= y
cnt += 1
else:
# distribute to all child
if x != 0:
cnt -= 1
print(cnt)
main()
| p03254 |
n,x=list(map(int,input().split()))
List=list(map(int,input().split()))
List.sort()
ans=0
if sum(List)==x:
print(n)
exit()
else:
for i in range(len(List)-1):
if x>=List[i]:
ans+=1
x-=List[i]
else:
break
print(ans) | n,x=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
cnt=0
if sum(a)==x:
print(n)
exit()
else:
for i in range(n-1):
if a[i]<=x:
x-=a[i]
cnt+=1
print(cnt) | p03254 |
n, x = list(map(int, input().split()))
l = list(map(int, input().split()))
l.sort()
i = 0
ans = 0
while x > 0 and i<= n-1:
if x >= l[i]:
x -= l[i]
if i == n-1:
if x == 0:
ans += 1
break
else:
break
else:
i += 1
ans += 1
else:
x = 0
break
print(ans)
| n, x = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
ans = 0
for i, a in enumerate(A):
if i != n-1:
if x >= a:
ans += 1
x -= a
else:
break
else:
if x == a:
ans += 1
else:
break
print(ans)
| p03254 |
# _*_ coding:utf-8 _*_
# Atcoder_Beginners_Contest-
# Atcoder_Grand_Contest-
# TODO https://atcoder.jp/contests/abc/tasks/abc_
import time
from contextlib import contextmanager
# from time import sleep
@contextmanager
def timer(title):
t0 = time.time()
yield
print(("{} - done in {:.0f}s".format(title,time.time()-t0) ))
def countJoyChild(haveCookie,joyMeterList):
joyMeterList.sort()
childsCount = len(joyMeterList)
sendCookieRangeMax = list(range(0,childsCount,+1))
sendCookieChilds = 0
for i in sendCookieRangeMax :
haveCookie = haveCookie-joyMeterList[i]
if 0 <= haveCookie:
sendCookieChilds = sendCookieChilds + 1
else:
break
if 0 < haveCookie: # => 最後の一人が多すぎる
sendCookieChilds = sendCookieChilds - 1
answer = sendCookieChilds
return answer
if __name__ == '__main__':
_,X = list(map(int,input().strip().split(' ')))
A = list(map(int,input().strip().split(' ')))
# with timer("countJoyChild"):
solution=countJoyChild(X,A)
print(("{}".format(solution))) | # _*_ coding:utf-8 _*_
# Atcoder_Grand_Contest027-a
# https://atcoder.jp/contests/agc027/tasks/agc027_a
def countJoyChild(haveCookie,joyMeterList):
joyMeterList.sort()
childsCount = len(joyMeterList)
sendCookieRangeMax = list(range(0,childsCount,+1))
sendCookieChilds = 0
for i in sendCookieRangeMax :
haveCookie = haveCookie-joyMeterList[i]
if 0 <= haveCookie:
sendCookieChilds = sendCookieChilds + 1
else:
break
if 0 < haveCookie: # => 最後の一人が多すぎる
sendCookieChilds = sendCookieChilds - 1
answer = sendCookieChilds
return answer
if __name__ == '__main__':
_,X = list(map(int,input().strip().split(' ')))
A = list(map(int,input().strip().split(' ')))
solution=countJoyChild(X,A)
print(("{}".format(solution))) | p03254 |
n,x= list(map(int, input().split()))
a= sorted(list(map(int, input().split())))
cnt=0
for i in range(n):
if x>=a[i]:
cnt+=1
x-=a[i]
else:
break
if i==n-1 and x>0:
cnt-=1
print(cnt) | n,x=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
if a[0]>x:
print((0))
exit()
cnt=1
for i in range(1,n):
a[i]+=a[i-1]
if a[i]>x:
break
cnt+=1
if cnt==n and a[-1]!=x:
cnt-=1
print(cnt) | p03254 |
N, x = list(map(int, input().split()))
a = sorted(map(int, input().split()))
ans = 0
for i in range(N):
if x >= a[i]:
ans += 1
x -= a[i]
else:
break
if i == N - 1:
if x != 0:
ans -= 1
print(ans) | n, x = list(map(int, input().split()))
a = sorted(map(int, input().split()))
ans = 0
for i in range(n):
x -= a[i]
if x < 0:
break
if i == n-1:
if x > 0:
break
ans += 1
print(ans) | p03254 |
n, x = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ans = 0
if x > sum(a):
print((n-1))
else:
for _a in a:
x -= _a
if x < 0:
print(ans)
exit()
else:
ans += 1
print(ans) | n, x = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
ans = 0
for a in A:
x -= a
if x < 0:
break
else:
ans += 1
if 0 < x:
ans -= 1
print((max(ans, 0)))
| p03254 |
import itertools
n,x=list(map(int,input().split()))
a=list(map(int, input().split()))
if sum(a)<x:
print((len(a)-1))
else:
ans=0
for i in range(1,n+1):
for v in itertools.combinations(a,i):
if sum(v)<=x:
ans=len(v)
print(ans) | n,x=list(map(int,input().split()))
a=list(map(int, input().split()))
ans=0
rest=x
target=sorted(a)
if sum(target)<x:
print((n-1))
elif sum(target)==x:
print(n)
else:
for i in range(n):
rest-=target[i]
if rest<0:
ans=i
break
if rest==0:
ans=i+1
break
print(ans)
| p03254 |
N,x = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
if x < min(A):
print((0))
exit()
A.sort()
ans = 0
i = 0
while x > 0 and ans < N:
if x >= A[i]:
x -= A[i]
ans += 1
i += 1
if x > 0:
ans -= 1
print(ans)
| N,x = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
if x < min(A):
print((0))
exit()
A.sort()
ans = 0
i = 0
while x > 0 and ans < N:
if x >= A[i]:
x -= A[i]
ans += 1
i += 1
else:
x = 0
break
if x > 0:
ans -= 1
print(ans)
| p03254 |
n, x = [int(i) for i in input().split()]
A = sorted([int(i) for i in input().split()])
ans = 0
for i in range(n):
if A[i] <= x:
if i == n - 1:
if x == A[i]:
ans += 1
else:
x -= A[i]
ans += 1
else:
break
print(ans)
| # https://atcoder.jp/contests/agc027/tasks/agc027_a
n, x = [int(i) for i in input().split()]
A = sorted([int(i) for i in input().split()])
if sum(A) == x:
ans = n
elif sum(A) < x:
ans = n - 1
else:
ans = 0
for i in range(n):
if A[i] <= x:
if i == n - 1:
if x == A[i]:
ans += 1
else:
x -= A[i]
ans += 1
else:
continue
print(ans)
| p03254 |
import itertools
n,x=list(map(int,input().split()))
a=list(map(int,input().split()))
a.append(0)
comb=list(itertools.combinations_with_replacement(a,n))
ans=[]
for i in comb:
per=sum(i)
if per==x:
if 0 in i:
ans.append(len(set(i))-1)
else:
ans.append(len(set(i)))
if len(ans)==0:
print((0))
else:
print((max(ans)))
| cnt=0
n,x=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
for i,j in enumerate(a):
if x>=j:
x-=j
cnt+=1
if i==(n-1) and x>0:
cnt-=1
print(cnt)
| p03254 |
n,x=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
ans=0
for i in range(n):
if x>=a[i]:
ans+=1
x-=a[i]
else:
break
if ans == n:
if x!=0:
ans-=1
print(ans) | n,x=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
ans=0
a.sort()
for i in range(n):
if x>=a[i]:
if i == n-1:
if a[i]==x:
ans+=1
else:
x-=a[i]
ans+=1
else:
break
print(ans) | p03254 |
N, V = list(map(int, input().split()))
C = list(map(int, input().split()))
assert len(C)==N
W = [1 for i in range(N)]
F = [0 for i in range(V+1)]
def pack01(F, c, w):
"""
f: states
c: cost
w: value
v: volume
"""
for v in range(c, V+1)[::-1]:
F[v] = max(F[v], F[v-c]+w)
for i in range(N):
pack01(F, C[i], W[i])
s = sum(C)
if s==V or s>V:
print((F[-1]))
elif sum(C)<V:
print((F[-1]-1))
| N, V = list(map(int, input().split()))
C = list(map(int, input().split()))
N = len(C)
if sum(C)==V:
print(N)
else:
cnt = 0
for c in sorted(C):
if V-c>0:
cnt += 1
V -= c
elif V-c==0:
cnt += 1
break
else:
break
print((min(cnt, N-1)))
| p03254 |
N, x = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = 0
use_list = []
for i in range(2**N):
use_list.append(list(map(int, list(bin(i)[2::].zfill(N)))))
for u in use_list:
s = 0
for i in range(N):
if u[i] == 1:
s += a[i]
if s < x:
ans = max(ans, sum(u)-1)
elif s == x:
ans = max(ans, sum(u))
print(ans) | N, x = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [[]]
a.sort()
ans = 0
f = False
for b in a:
if b <= x:
ans += 1
x -= b
f = True
else:
f = False
if x > 0 and f:
ans -= 1
print(ans)
| p03254 |
n, x = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
cnt = 0
flag = False
for i in a:
if i <= x:
x -= i
cnt += 1
if x == 0:
flag = True
else:
break
else:
if not flag:
cnt -= 1
print(cnt) | n, x = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
cnt = 0
flag = False
for i in a:
if i <= x:
x -= i
cnt += 1
if x == 0:
break
else:
break
else:
cnt -= 1
print(cnt) | p03254 |
from collections import Counter,defaultdict,deque
from heapq import heapify,heappop,heappush
import sys,bisect,math,itertools,string,queue
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n,x = inpl()
a = inpl()
a.sort()
if sum(a) < x:
print((n-1))
else:
s = 0
for i,y in enumerate(a):
# print(i,y)
if s + y < x:
s += y
elif s + y == x:
print((i+1))
break
else:
print(i)
break
else:
print((n-1)) | from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools
sys.setrecursionlimit(10**8)
mod = 10**9+7
mod2 = 998244353
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n,x = inpl()
a = inpl()
a.sort()
for i in range(n):
if a[i] <= x:
x -= a[i]
else:
print(i)
break
else:
if x == 0:
print(n)
else:
print((n-1)) | p03254 |
n, x = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
count = 0
for i in range(n):
if i == n-1:
if x == a[i]:
count += 1
elif x >= a[i]:
count += 1
x -= a[i]
print(count) | n,x = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
cnt = 0
while a[cnt] <= x:
x = x - a[cnt]
cnt += 1
if cnt >= len(a):
break
if x > 0 and len(a) == cnt:
cnt -= 1
print(cnt) | p03254 |
N, x = [int(i) for i in input().split(" ")]
lst = [int(i) for i in input().split(" ")]
lst.sort()
cnt = 0
for i in range(0,N-1):
if x >= lst[i]:
x -= lst[i]
cnt += 1
else:
break
if x == lst[N-1]:
cnt +=1
print(cnt) | N, x = [int(i) for i in input().split(" ")]
lst = [int(i) for i in input().split(" ")]
lst.sort()
cnt = 0
for i in range(0,N-1):
if x >= lst[i]:
x -= lst[i]
cnt += 1
else:
break
print((cnt+(x==lst[N-1])))
| p03254 |
import sys
input = lambda :sys.stdin.readline().rstrip()
N, x = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
if x > sum(A):
cnt = -1
else:
cnt = 0
for i in range(N):
if x - A[i] >= 0:
cnt += 1
x -= A[i]
if x <= 0:
break
#print(cnt, x)
print(cnt) | n, x = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
if sum(A) < x:
cnt = -1
else:
cnt = 0
for a in A:
x -= a
if x >= 0:
cnt += 1
if x <= 0:
print(cnt)
exit()
print(cnt) | p03254 |
#!/usr/bin/env python
n, x = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
if x < a[0]:
print((0))
exit()
cnt = 0
al = False
for i in range(n):
if x >= a[i]:
x -= a[i]
cnt += 1
else:
break
if i == n-1:
al = True
if al:
if x > 0:
ans = cnt-1
else:
ans = cnt
else:
ans = cnt
print(ans)
| #!/usr/bin/env python
n, x = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
if x < a[0]:
print((0))
exit()
if sum(a) < x:
print((n-1))
exit()
cnt = 0
for i in range(n):
if x >= a[i]:
x -= a[i]
cnt += 1
ans = cnt
print(ans)
| p03254 |
from itertools import permutations
n, m = list(map(int, input().split()))
list_AB = [ list(map(int,input().split(" "))) for i in range(m)]
list_MAP = [[0]*n for _ in range(n)]
list_N = [i for i in range(2, n+1)]
for a, b in list_AB:
list_MAP[a-1][b-1] = 1
list_MAP[b-1][a-1] = 1
ans = 0
for l in permutations(list_N, n-1):
cnt = 0
p = 1
q = 0
for num in l:
q = num
cnt += list_MAP[p-1][q-1]
p = num
if cnt == n-1:
ans += 1
print(ans) | n, m = list(map(int, input().split()))
list_MAP = [[0]*n for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
list_MAP[a-1][b-1] = 1
list_MAP[b-1][a-1] = 1
dp = [[0]*n for _ in range(1<<n)]
dp[1][0] = 1
for num in range(1<<n):
for v in range(n):
if num & (1<<v) == 0:
continue
sub = num ^ (1<<v)
for u in range(n):
if sub & (1<<u) and list_MAP[v][u]:
dp[num][v] += dp[sub][u]
ans = sum(dp[(1 << n) - 1][u] for u in range(1, n))
print(ans) | p03805 |
n, m = list(map(int, input().split()))
list_MAP = [[0]*n for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
list_MAP[a-1][b-1] = 1
list_MAP[b-1][a-1] = 1
dp = [[0]*n for _ in range(1<<n)]
dp[1][0] = 1
for num in range(1<<n):
for v in range(n):
if num & (1<<v) == 0:
continue
sub = num ^ (1<<v)
for u in range(n):
if sub & (1<<u) and list_MAP[v][u]:
dp[num][v] += dp[sub][u]
ans = sum(dp[(1 << n) - 1][u] for u in range(1, n))
print(ans) | n, m = list(map(int, input().split()))
list_MAP = [[0]*n for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
list_MAP[a-1][b-1] = 1
list_MAP[b-1][a-1] = 1
dp = [[0]*n for _ in range(1<<n)]
dp[1][0] = 1
for num in range(1<<n):
for v in range(n):
if num & (1<<v) == 0:
continue
sub = num ^ (1<<v)
for u in range(n):
if sub & (1<<u) and list_MAP[v][u]:
dp[num][v] += dp[sub][u]
ans = sum(dp[(1 << n) - 1])
print(ans) | p03805 |
import itertools
n, m = list(map(int, input().split()))
AB = []
for i in range(m):
AB.append(list(map(int, input().split())))
ct = 0
N_lis = [(i + 2) for i in range(n - 1)]
Pat = itertools.permutations(N_lis)
for one_case in Pat:
tmp = 1
all_flag = True
for j in one_case:
flag = False
for k in range(m):
if AB[k][0] == tmp:
if AB[k][1] == j:
tmp = j
flag = True
break
elif AB[k][1] == tmp:
if AB[k][0] == j:
tmp = j
flag = True
break
if not flag:
all_flag = False
break
if all_flag:
ct += 1
print(ct) | n, m = list(map(int, input().split()))
P = [[0] * n for i in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
P[a-1][b-1] = 1
P[b-1][a-1] = 1
#dp[S][v] := 頂点０から出発し、集合Sに含まれる頂点を全て訪れるpathのうち、頂点vが最後になるようなpathの総数
dp = [[0] * n for _ in range(1 << n)]
#dpの初期化 dp({0}, 0) = 1
dp[1][0] = 1
for S in range(1 << n):
for v in range(n):
#vがSに含まれていないときはパスする
if S & (1 << v) == 0:
continue
#sub = S - {v}
sub = S ^ (1 << v)
for u in range(n):
#subにuが含まれており、かつuとvが辺で結ばれている
if sub & (1 << u) and P[u][v]:
dp[S][v] += dp[sub][u]
ans = sum(dp[(1 << n) - 1][u] for u in range(1, n))
print(ans) | p03805 |
import copy
n,m = list(map(int, input().split()))
paths = [[] for _ in range(n)]
for i in range(m):
a,b = list(map(int, input().split()))
paths[a-1].append(b-1)
paths[b-1].append(a-1)
ans = 0
checked = [False for _ in range(n)]
def solve(i, c):
c[i] = True
global ans
if c.count(False) == 0:
ans += 1
return
else:
for j in paths[i]:
if c[j] == False:
solve(j, copy.deepcopy(c))
solve(0, copy.deepcopy(checked))
print(ans)
#print(paths[0]) | N, M = list(map(int, input().split()))
if M == 0:
print((0))
exit()
es = [[] for i in range(M+1)]
for i in range(M):
a, b = list(map(int, input().split()))
a,b = a-1, b-1
es[a].append(b)
es[b].append(a)
def dfs(v, visited, es, cnt):
#print("--------------")
#print((v, visited, cnt))
if cnt == N-1:
return 1
ret = 0
for i in es[v]:
if visited[i] == True:
continue
visited[i] = True
ret += dfs(i, visited, es, cnt+1)
visited[i] = False
return ret
visited = [False] * N
visited[0] = True
ans = dfs(0,visited,es,0)
print(ans) | p03805 |
def perm(k,x):
v=[]
for i in range(x):
c=k%x+2
if c not in v:
v.append(c)
k//=x
else:
return []
return v
N,M=list(map(int,input().split()))
e=[[False for i in range(N+1)] for i in range(N+1)]
for i in range(M):
a,b=list(map(int,input().split()))
e[a][b]=e[b][a]=True
if N==2:
ans=1 if e[1][2] else 0
else:
ans=0
for k in range((N-1)**(N-1)):
v=perm(k,N-1)
if v and e[1][v[0]]:
f=True
for j in range(N-2):
if not e[v[j]][v[j+1]]:
f=False
break
if j==N-3:
ans+=1
print(ans) | import itertools as it
N,M=list(map(int,input().split()))
e=[[False for j in range(N+1)] for i in range(N+1)]
for i in range(M):
a,b=list(map(int,input().split()))
e[a][b]=e[b][a]=True
# print(e) #DB
ans=0
l=list(range(2,N+1))
for p in it.permutations(l,N-1):
q=(1,)+p
# print(q) #DB
f=True
for i in range(N-1):
# print((q[i],q[i+1])) #DB
if not e[q[i]][q[i+1]]:
f=False
break
if f:
ans+=1
print(ans) | p03805 |
from typing import List, Tuple
def main():
n, m = list(map(int, input().split()))
g = []
for _ in range(m):
a, b = list(map(int, input().split()))
g.append((a, b))
print((osp(n, g)))
def osp(n: int, g: List[Tuple[int, int]]) -> int:
v = [False] * n
return dfs(0, v, n, g)
def dfs(i, v, n, g):
v[i] = True
if all(v):
v[i] = False
return 1
cnt = 0
for j in range(n):
if v[j]:
continue
if not ((i + 1, j + 1) in g or (j + 1, i + 1) in g):
continue
cnt += dfs(j, v, n, g)
v[i] = False
return cnt
if __name__ == '__main__':
main()
| from typing import List, Tuple
def main():
n, m = list(map(int, input().split()))
g = []
for _ in range(m):
a, b = list(map(int, input().split()))
g.append((a, b))
print((osp(n, g)))
def osp(n: int, g: List[Tuple[int, int]]) -> int:
v = [False] * n
g = set(g)
return dfs(0, v, n, g)
def dfs(i, v, n, g):
v[i] = True
if all(v):
v[i] = False
return 1
cnt = 0
for j in range(n):
if v[j]:
continue
if not ((i + 1, j + 1) in g or (j + 1, i + 1) in g):
continue
cnt += dfs(j, v, n, g)
v[i] = False
return cnt
if __name__ == '__main__':
main()
| p03805 |
N,M=list(map(int,input().split()))
original_paths={}
for n in range(1,N+1):
original_paths[n]=[]
for m in range(1,M+1):
s,e=list(map(int,input().split()))
original_paths[s].append(e)
original_paths[e].append(s)#以上地図(原本)作り
visited=[1]
current_point=1
answer=0
import copy
paths=copy.deepcopy(original_paths)
while len(paths[1])!=0:#すべてのルートを探索済み==点1から動けない
if len(paths[current_point])!=0:
next_point=paths[current_point][0]
if next_point in visited:#next_pointに行ったことがある
if len(paths[current_point])!=1:#next_point以外に選択肢がある
paths[current_point].remove(next_point)#next_pointを選択肢から消す
else:#next_point以外に選択肢がない(current_pointは行き止まり)
if len(visited)==N:#すべての点を訪れたかチェック
answer+=1
prior_point=visited[-2]#ひとつ前にいた点をprior_pointとし、
paths[current_point]=original_paths[current_point].copy()#current_pointからの選択肢を初期化
paths[prior_point].remove(current_point)#prior_pointの選択肢からcurrent_pointを除く
visited.remove(current_point)#current_pointをvisitedから除き、
current_point=prior_point#prior_pointに戻る
else:#next_pointに行ったことがない
visited.append(next_point)#next_pointをvisitedに加え、
current_point=next_point#next_pointに進む
else:
prior_point=visited[-2]#ひとつ前にいた点をprior_pointとし、
paths[current_point]=original_paths[current_point].copy()#current_pointからの選択肢を初期化
paths[prior_point].remove(current_point)#prior_pointの選択肢からcurrent_pointを除く
visited.remove(current_point)#current_pointをvisitedから除き、
current_point=prior_point#prior_pointに戻る
print(answer)
| N,M=list(map(int,input().split()))
original_paths={}
paths={}
for n in range(1,N+1):
original_paths[n]=[]
paths[n]=[]
for m in range(1,M+1):
s,e=list(map(int,input().split()))
original_paths[s].append(e)
original_paths[e].append(s)
paths[s].append(e)
paths[e].append(s)#以上地図作り
visited=[1]
current_point=1
answer=0
while len(paths[1])!=0:#すべてのルートを探索済み==点1から動けない
if len(paths[current_point])!=0:
next_point=paths[current_point][0]
if next_point in visited:#next_pointに行ったことがある
if len(paths[current_point])!=1:#next_point以外に選択肢がある
paths[current_point].remove(next_point)#next_pointを選択肢から消す
else:#next_point以外に選択肢がない(current_pointは行き止まり)
if len(visited)==N:#すべての点を訪れたかチェック
answer+=1
prior_point=visited[-2]#ひとつ前にいた点をprior_pointとし、
paths[current_point]=original_paths[current_point].copy()#current_pointからの選択肢を初期化
paths[prior_point].remove(current_point)#prior_pointの選択肢からcurrent_pointを除く
visited.remove(current_point)#current_pointをvisitedから除き、
current_point=prior_point#prior_pointに戻る
else:#next_pointに行ったことがない
visited.append(next_point)#next_pointをvisitedに加え、
current_point=next_point#next_pointに進む
else:
prior_point=visited[-2]#ひとつ前にいた点をprior_pointとし、
paths[current_point]=original_paths[current_point].copy()#current_pointからの選択肢を初期化
paths[prior_point].remove(current_point)#prior_pointの選択肢からcurrent_pointを除く
visited.remove(current_point)#current_pointをvisitedから除き、
current_point=prior_point#prior_pointに戻る
print(answer)
| p03805 |
ans = 0
def dfs(v, visitedNode, graph):
visitedNode[v] = 1
if all(visitedNode):
global ans
ans += 1
return
for node in graph[v]:
if visitedNode[node]:
continue
else:
dfs(node, visitedNode[:], graph)
N, M = list(map(int, input().split()))
v = 0
visitedNode = [0] * N
# 隣接リストを作成する
graph = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
graph[a].append(b)
graph[b].append(a)
# 深さ優先探索で経路数を数える
dfs(v, visitedNode, graph)
print(ans)
| ans = 0
def dfs(v, visitedNode, graph):
visitedNode[v] = 1
# print(visitedNode)
if all(visitedNode):
global ans
ans += 1
return
for node in graph[v]:
if visitedNode[node]:
# 探索済みならば、ほかの隣接候補へ。
continue
else:
# 未探索ならば、次の階層を調べる。
dfs(node, visitedNode[:], graph)
N, M = list(map(int, input().split()))
v = 0
visitedNode = [0] * N
graph = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
graph[a].append(b)
graph[b].append(a)
# print(graph)
dfs(v, visitedNode, graph)
print(ans)
| p03805 |
n,m=list(map(int, input().split()))
q=[]
for i in range(m):
a,b=list(map(int, input().split()))
q.append([a,b])
q.append([b,a])
p=[[1]]
count=0
route=set()
while len(p)!=0:
p1=p.pop()
for i,j in q:
#print(i,j)
if i == p1[-1]:
if j not in p1:
p.append(p1+[j])
if len(p1)==n: count+=1
route |= {tuple(p1)}
#print(p,p1)
print(count) | n,m=list(map(int, input().split()))
q=[]
for i in range(m):
a,b=list(map(int, input().split()))
q+=[[a,b],[b,a]]
p=[[1]]
count=0
while p:
p1=p.pop()
if len(p1)==n:count+=1
else:
for i,j in q:
if i == p1[-1] and j not in p1:
p.append(p1+[j])
#print(p1,p)
print(count) | p03805 |
from collections import deque
import copy
# https://atcoder.jp/contests/abc054/tasks/abc054_c
# n!の全探索が答えというのは知っているが、自分の開放の誤りを見つけるために自分のやり方でといてみる。
N, M = list(map(int, input().split()))
V = [[] for _ in range(N)]
cont = [0 for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
V[a-1].append([b, copy.deepcopy(cont)])
V[b-1].append([a, copy.deepcopy(cont)])
# solution
q = deque()
q.append([1, copy.deepcopy(cont)])
count = 0
while q:
c_v = q.pop()
c_v[1][c_v[0]-1] = 1
next_vs = V[c_v[0]-1]
ifComplete = 1
for v in next_vs:
if c_v[1][v[0]-1] == 1:
continue
else:
ifComplete = 0
# ここで続くvの探索が始まる時に全て訪問されていればcountを増やす。
# その状態をどうやって管理すればいい？
v[1] = copy.deepcopy(c_v[1])
q.append(v)
# 遷移先のノードが存在しない場合
if ifComplete:
flag = 1
for x in c_v[1]:
if x == 0:
flag = 0
break
if flag:
count += 1
print(count)
| import itertools
N, M = list(map(int, input().split()))
V = [[] for _ in range(N)]
bag = set()
for _ in range(M):
a, b = list(map(int, input().split()))
bag.add(a)
bag.add(b)
V[a-1].append(b)
V[b-1].append(a)
count = 0
for c in itertools.permutations(bag):
if not c[0] == 1:
continue
flag = False
for i in range(N-1):
if not c[i+1] in V[c[i]-1]:
flag = True
break
if not flag:
count += 1
print(count)
| p03805 |
N, M=list(map(int,input().split()))
a=[0]*0
b=[0]*0
choice=[0]*(N-1)
chosen_a=[0]*(N-1)
chosen_b=[0]*(N-1)
c_patern=0
for i in range(M):
a_tmp, b_tmp=list(map(int,input().split()))
a.append(a_tmp)
b.append(b_tmp)
# for i in range(M):
# c_point = [0] * N
# if a[i]==1:
# c_point[a[i]-1]+=1
# for j in range(M):
# if a[j]==b[i]:
# for i in range(N):
# if c_point[i]!=1:
# break
# c_patern+=1
for i in range(pow(M,(N-1))):
flg=0
for j in range(N-1):
choice[j]=i//pow(M,(N-1)-j-1)
chosen_a[j]=a[choice[j]]
chosen_b[j]=b[choice[j]]
i=i%pow(M,(N-1)-j-1)
if chosen_a[0]!=1:
flg=1
for k in range(N-1):
if k>0:
if chosen_a[k]!=chosen_b[k-1]:
tmp=chosen_a[k]
chosen_a[k]=chosen_b[k]
chosen_b[k]=tmp
if chosen_a[k]!=chosen_b[k-1]:
flg=1
chosen_b_sorted=sorted(chosen_b)
for l in range(N-1):
if chosen_b_sorted[l]!=l+2:
flg=1
if flg==0:
c_patern+=1
print(c_patern) | #ABC054C
import itertools
N, M=list(map(int,input().split()))
a=[0]*0
b=[0]*0
order=list(itertools.permutations(list(range(N-1)) ) )#0～N-2のN-1個の順列ができる。2を足すと、2～Nの配列。
c_patern=0
for i in range(M):
a_tmp, b_tmp=list(map(int,input().split()))
a.append(a_tmp)
b.append(b_tmp)
for i in range(len(order)):
for j in range(N-1):
flg = False
if j==0:
for k in range(M):
if (a[k]==1 and b[k]==order[i][0]+2):
flg=True
break
else:
for k in range(M):
if (a[k]==order[i][j-1]+2 and b[k]==order[i][j]+2) or (a[k]==order[i][j]+2 and b[k]==order[i][j-1]+2):
flg=True
break
if flg==False:
break
if flg==True:
c_patern+=1
print(c_patern) | p03805 |
def dfs(parent, connect, passed, N): #深さ優先探索
cnt = 0
passed.append(parent) #通った点をメモ
if len(passed) == N: #全ての点を通過したかの判定
cnt = 1
for next_ in connect[parent]:
if next_ in passed:
continue
cnt += dfs(next_, connect, passed, N) #全ての点を通るまで再帰. 戻り値の和で何通りかカウント
passed.pop() #分岐点に戻る前にメモを1段だけ破棄
return cnt
N, M = list(map(int, input().split()))
connect = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
connect[a-1].append(b-1)
connect[b-1].append(a-1)
ans = dfs(0, connect, [], N) #点0からのdfs
print(ans) | N, M = list(map(int, input().split()))
Edge = [tuple(map(int, input().split())) for _ in range(M)]
Graph = [[] for _ in range(N)]
for a,b in Edge:
Graph[a-1].append(b-1)
Graph[b-1].append(a-1)
def dfs(v, seen):
global Graph
seen.add(v)
if len(seen) == N:
seen.remove(v)
return 1
Res = [dfs(nv, seen) for nv in Graph[v] if not nv in seen]
seen.remove(v)
return sum(Res)
print((dfs(0, set()))) | p03805 |
N, M = list(map(int, input().split()))
Edge = [tuple(map(int, input().split())) for _ in range(M)]
Graph = [[] for _ in range(N)]
for a,b in Edge:
Graph[a-1].append(b-1)
Graph[b-1].append(a-1)
seen = set()
def dfs(v):
global Graph, seen
seen.add(v)
if len(seen) == N:
seen.remove(v)
return 1
Res = [dfs(nv) for nv in Graph[v] if not nv in seen]
seen.remove(v)
return sum(Res)
print((dfs(0))) | N, M = list(map(int, input().split()))
Edge = [tuple(map(int, input().split())) for _ in range(M)]
Graph = [[] for _ in range(N)]
for a,b in Edge:
Graph[a-1].append(b-1)
Graph[b-1].append(a-1)
seen = set()
def dfs(v):
seen.add(v)
if len(seen) == N:
seen.remove(v)
return 1
Res = [dfs(nv) for nv in Graph[v] if not nv in seen]
seen.remove(v)
return sum(Res)
print((dfs(0))) | p03805 |
# ABC054C - One-stroke Path
# graph theory
# an undirected unweighted graph is given
# -> count up paths which visit all the vertices exactly once
import sys
input = sys.stdin.readline
from itertools import permutations as perm
def main():
N, M = tuple(map(int, input().split()))
A = set(tuple(map(int, input().split())) for _ in range(M))
ans = 0
for path in perm(list(range(2, N + 1)), N - 1): # check all possible paths (O(N!))
path = (1,) + path
if all((i, j) in A or (j, i) in A for i, j in zip(path, path[1:])):
ans += 1
print(ans)
if __name__ == "__main__":
main() | # ABC054C - One-stroke Path
# an undirected unweighted graph is given
# -> count up paths which visit all the vertices exactly once
# exhaustive search
from itertools import permutations as perm
def main():
N, M = tuple(map(int, input().split()))
E = set(tuple(map(int, input().split())) for _ in range(M)) # edges
E |= {(j, i) for i, j in E} # undirected graph -> add reversed paths
ans = 0
for path in perm(list(range(2, N + 1)), N - 1): # check all possible paths (O(N!))
path = (1,) + path
if all((i, j) in E for i, j in zip(path, path[1:])):
ans += 1
print(ans)
if __name__ == "__main__":
main() | p03805 |
import itertools
n, m = list(map(int, input().split()))
ab_list = [tuple(map(int, input().split())) for _ in range(m)]
path_list = sorted(iter for iter in itertools.permutations(list(range(2, n+1)), n-1))
counter = 0
for path_i in path_list:
path = (1, )+path_i
result_list = [True for s_e in zip(path, path[1:]) if tuple(sorted(s_e)) in ab_list]
if sum(result_list) == len(path)-1: counter += 1
print(counter) | import itertools
n,m = list(map(int, input().split()))
edge_set = {tuple(map(int, input().split())) for _ in range(m)}
counter = 0
for i in itertools.permutations(list(range(2, n+1)), n-1):
path = [1] + list(i)
path_set = {tuple(sorted(edge)) for edge in zip(path, path[1:])}
if path_set <= edge_set:
counter += 1
print(counter) | p03805 |
n, m = list(map(int, input().split()))
sign = []
for i in range(n):
sign.append("o")
graph = []
for i in range(n):
graph.append([])
for i in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
for j in range(n):
if a == j:
graph[j].append(b)
if b == j:
graph[j].append(a)
def dfs(x, i=0):
sign[x] = "x"
if sign == ["x" for k in range(n)]:
return i + 1
for j in graph[x]:
if sign[j] == "o":
sign[j] = "x"
i = dfs(j, i)
sign[j] = "o"
return i
print((dfs(0)))
| ###入力
n, m = list(map(int, input().split()))
###到達しているか否かのサイン
sign = []
for i in range(n):
sign.append("o")
###グラフ
graph = []
for i in range(n):
graph.append([])
###隣接行列
for i in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
for j in range(n):
if a == j:
graph[j].append(b)
if b == j:
graph[j].append(a)
###深さ優先探索
###dfsはxからスタートしてoの箇所を全て回収する場合の数
def dfs(x, i=0):
sign[x] = "x"
###すべてのノードが到達済みなら終了
if sign == ["x" for k in range(n)]:
return i + 1
###隣接するすべての点に対して、未到達ならdfsを適用
for j in graph[x]:
if sign[j] == "o":
###一旦xにする（後で戻す）
sign[j] = "x"
###重要重要重要重要重要重要重要重要重要重要重要重要重要重要重要重要重要重要
###右辺のiにはこれまでの場合の数が蓄積されている
###そのiの上にjスタートの場合の数が加算される
###それを新たなiとする
###つまり、足し算の操作は右辺で完結している
###iはここでしか動かないことに注意
###重要重要重要重要重要重要重要重要重要重要重要重要重要重要重要重要重要重要
i = dfs(j, i)
###戻した
sign[j] = "o"
return i
print((dfs(0)))
| p03805 |
import collections
def main():
N, M = list(map(int, input().split()))
graph = collections.defaultdict(list)
for _ in range(M):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
cur = [[1, set([1])]]
for _ in range(N-1):
temp = []
for a, visited in cur:
for b in graph[a]:
if b not in visited:
temp.append([b, visited | {b}])
cur = temp
return len(cur)
if __name__ == '__main__':
print((main())) | import collections
def main():
N, M = list(map(int, input().split()))
graph = collections.defaultdict(list)
for _ in range(M):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
# print(graph)
cur = [[1, 1 << 1]]
for _ in range(N-1):
temp = []
for a, h in cur:
for b in graph[a]:
if (h >> b) % 2 == 0:
temp.append([b, h | (1 << b)])
cur = temp
# print(cur)
return len(cur)
if __name__ == '__main__':
print((main()))
| p03805 |
import itertools
n, m = list(map(int, input().split()))
l = [list(map(int, input().split())) for i in range(m)]
r = [[] for i in range(n + 1)]
ans = 0
for i in range(m):
r[l[i][0]].append(l[i][1])
r[l[i][1]].append(l[i][0])
p = []
for i in range(n):
p.append(i + 1)
p = list(itertools.permutations(p))
for i in range(len(p)):
check = True
t = list(p[i])
if t[0] != 1:
check = False
for j in range(len(t)-1):
if not t[j + 1] in r[t[j]]:
check = False
if check:
ans += 1
print(ans) | import itertools
n, m = list(map(int, input().split()))
l = [list(map(int, input().split())) for i in range(m)]
r = [[] for i in range(n + 1)]
ans = 0
for i in range(m):
r[l[i][0]].append(l[i][1])
r[l[i][1]].append(l[i][0])
p = "2345678"[:n-1]
p = list(itertools.permutations(p))
for i in range(len(p)):
check = True
t = "1" + "".join(p[i])
for j in range(len(t)-1):
if not int(t[j + 1]) in r[int(t[j])]:
check = False
if check:
ans += 1
print(ans) | p03805 |
n,m=list(map(int,input().split()))
edge=[list(map(int,input().split())) for i in range(m)]
ans=0
rout=[[0 for i in range(n)]]
rout[0][0]=1
for i in range(2,n+1):
rout2=[]
for j in range(len(rout)):
for k in range(n):
if rout[j][k]==0:
r=rout[j][:]
r[k]=i
rout2.append(r)
rout=rout2
for r in rout:
lim=0
while lim<n-1:
if [r[lim],r[lim+1]] in edge or [r[lim+1],r[lim]] in edge:
lim+=1
else:
lim=0
break
if lim:
ans+=1
print(ans) | import itertools
n,m=list(map(int,input().split()))
edge=[list(map(int,input().split())) for i in range(m)]
ans=0
nums=[i for i in range(1,n+1)]
rout=itertools.permutations(nums,n)
for r in rout:
if r[0]!=1:
continue
lim=0
while lim<n-1:
if [r[lim],r[lim+1]] in edge or [r[lim+1],r[lim]] in edge:
lim+=1
else:
lim=0
break
if lim:
ans+=1
print(ans) | p03805 |
f=lambda:list(map(int,input().split()))
n,m=f()
g=[[0]*n for _ in range(n)]
for i in range(m):
a,b=f(); g[a-1][b-1]=g[b-1][a-1]=1
import itertools as it
c=0
for t in it.permutations(list(range(1,n))):
p,d=0,1
for q in t: d*=g[p][q]; p=q
c+=d
print(c) | f=lambda:list(map(int,input().split()))
n,m=f()
g=[[0]*n for _ in range(n)]
for i in range(m):
a,b=f(); g[a-1][b-1]=g[b-1][a-1]=1
import itertools as it
c=0
for t in it.permutations(list(range(1,n))):
p=0
for q in t:
if g[p][q]<1: break
p=q
else: c+=1
print(c) | p03805 |
f=lambda:list(map(int,input().split()))
n,m=f()
g=[[0]*n for _ in range(n)]
for _ in range(m):
a,b=f()
g[a-1][b-1]=1
g[b-1][a-1]=1
from itertools import *
p=[*permutations(list(range(1,n)))]
a=0
for t in p:
v=0
for c in t:
if g[v][c]: v=c
else: break
else: a+=1
print(a) | f=lambda:list(map(int,input().split()))
n,m=f()
g=[[] for _ in range(n)]
for _ in range(m):
a,b=f()
g[a-1]+=[b-1]
g[b-1]+=[a-1]
from itertools import *
p=[*permutations(list(range(1,n)))]
a=0
for t in p:
v=0
for c in t:
if c in g[v]: v=c
else: break
else: a+=1
print(a) | p03805 |
from itertools import permutations
n, m = list(map(int, input().split()))
pair = [tuple(map(int, input().split())) for i in range(m)]
num = [i+1 for i in range(n)]
box = []
for p in permutations(num):
if p[0] == 1:
box.append(p)
ans = 0
for p in box:
already = []
state = True
for i in range(n-1):
if p[i] in already:
state = False
break
if (min(p[i], p[i+1]), max(p[i], p[i+1])) not in pair:
state = False
break
already.append(p[i])
if state:
ans += 1
print(ans)
| from itertools import permutations
n, m = list(map(int, input().split()))
pair = [tuple(map(int, input().split())) for i in range(m)]
num = [i for i in range(1,n+1)]
ans = 0
for p in permutations(num):
if p[0] != 1:
continue
already = []
state = True
for i in range(n-1):
if p[i] in already:
state = False
break
if (min(p[i], p[i+1]), max(p[i], p[i+1])) not in pair:
state = False
break
already.append(p[i])
if state:
ans += 1
print(ans)
| p03805 |
def dfs(t):
if 0 not in already:
return 1
allReach=0
for i in range(n):
if connect[t][i]==1 and already[i]==0:
already[i]=1
allReach+=dfs(i)
already[i]=0
return allReach
n,m=list(map(int,input().split()))
connect=[[0 for i in range(n)]for j in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
connect[a-1][b-1]=1
connect[b-1][a-1]=1
already=[0 for i in range(n)]
already[0]=1
print((dfs(0)))
| def dfs(t):
if 0 not in already:#全ての辺を訪問していた場合
return 1
allReach=0
for i in range(n):
if connect[t][i]==1 and already[i]==0:#辺があり、訪問しいない場合
already[i]=1
allReach+=dfs(i)
already[i]=0
return allReach
n,m=list(map(int,input().split()))
connect=[[0 for i in range(n)]for j in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
#辺の情報を記録する
connect[a-1][b-1]=1
connect[b-1][a-1]=1
already=[0 for i in range(n)]#訪問した点を記録する
already[0]=1#必ず1から始まるので訪問履歴をつけておく
print((dfs(0)))#記録した情報をもとに0からdfs
| p03805 |
def dfs(v,n,visited):
all_visted=1
for i in range(n):
if visited[i]==0:
all_visted=0
if all_visted==1:
return 1
ret=0
for i in range(n):
if path[v][i]==0:
continue
if visited[i]==1:
continue
visited[i]=1
ret+=dfs(i,n,visited)
visited[i]=0
return ret
n,m=list(map(int,input().split()))
path=[[0]*n for i in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
path[a-1][b-1]=1
path[b-1][a-1]=1
visited=[0]*n
visited[0]=1
print((dfs(0,n,visited)))
| def dfs(v,n,visited):
all_visted=1
for i in range(n):
if visited[i]==0:
all_visted=0
if all_visted==1:
return 1
count=0#全ての辺を訪問する回数を格納する変数
for i in range(n):
if path[v][i]==0:#辺がないとき、つまり隣接していない時
continue
if visited[i]==1:#既に訪問している
continue
visited[i]=1#訪問する
count+=dfs(i,n,visited)
visited[i]=0
return count
#グラフの位置情報を読み取る
n,m=list(map(int,input().split()))
path=[[0]*n for i in range(n)]#0は未訪問,1は訪問済み
for i in range(m):
a,b=list(map(int,input().split()))
path[a-1][b-1]=1#隣接しているところは1になる
path[b-1][a-1]=1
visited=[0]*n
visited[0]=1#点1は既に訪問済みなので記録
print((dfs(0,n,visited))) | p03805 |
n,m=list(map(int,input().split()))
def dfs(now,depth):
if used[now]:
return 0
if depth==n:
return 1
used[now]=1
ans=0
for i in range(n):
if connect[now][i]:
ans+=dfs(i,depth+1)
used[now]=0
return ans
edge=[[int(i)for i in input().split()]for i in range(m)]#入力値受け取り、グラフの初期設定
connect=[[0 for i in range(n)]for i in range(n)]
for i in range(m):
connect[edge[i][0]-1][edge[i][1]-1]=1
connect[edge[i][1]-1][edge[i][0]-1]=1
used=[0]*n
print((dfs(0,1)))
| n,m=list(map(int,input().split()))
def dfs(now,depth):#現在見ている点、今まで列挙した頂点数
if used[now]:
return 0
if depth==n:
return 1
used[now]=1#使用済みグラフを立てる
ans=0#出力値を数える変数
for i in range(n):#全部の遷移先を調べる
if connect[now][i]:#nowから繋がっている頂点であれば遷移を試す。
ans+=dfs(i,depth+1)
used[now]=0#使用済みグラフを折る
return ans
edge=[[int(i)for i in input().split()]for i in range(m)]#入力値受け取り、グラフの初期設定
connect=[[0 for i in range(n)]for i in range(n)]#接続状況を管理する配列
for i in range(m):
connect[edge[i][0]-1][edge[i][1]-1]=1
connect[edge[i][1]-1][edge[i][0]-1]=1
used=[0]*n#既にその頂点を訪問したか管理する配列
print((dfs(0,1)))
| p03805 |
n,m=list(map(int,input().split()))
def dfs(now,depth):#現在見ている点、今まで列挙した頂点数
if used[now]:
return 0
if depth==n:
return 1
used[now]=1#使用済みグラフを立てる
ans=0#出力値を数える変数
for i in range(n):#全部の遷移先を調べる
if connect[now][i]:#nowから繋がっている頂点であれば遷移を試す。
ans+=dfs(i,depth+1)
used[now]=0#使用済みグラフを折る
return ans
edge=[[int(i)for i in input().split()]for i in range(m)]#入力値受け取り、グラフの初期設定
connect=[[0 for i in range(n)]for i in range(n)]#接続状況を管理する配列
for i in range(m):
connect[edge[i][0]-1][edge[i][1]-1]=1
connect[edge[i][1]-1][edge[i][0]-1]=1
used=[0]*n#既にその頂点を訪問したか管理する配列
print((dfs(0,1)))
| def dfs(now,depth):
if visited[now]:
return 0
if depth==n:
return 1
visited[now]=1
ans=0
for i in range(n):
if connect[now][i]==1:
ans+=dfs(i,depth+1)
visited[now]=0
return ans
n,m=list(map(int,input().split()))
visited=[0]*n
edge=[[int(i)for i in input().split()]for i in range(m)]#入力値を受け取っている
connect=[[0 for i in range(n)]for i in range(n)]#隣接行列
for i in range(m):
connect[edge[i][0]-1][edge[i][1]-1]=1
connect[edge[i][1]-1][edge[i][0]-1]=1
print((dfs(0,1))) | p03805 |
import itertools
N, M = list(map(int, input().split()))
ab=[]
for _ in range(M):
ab.append(tuple(map(int, input().split())))
lst=[[] for _ in range(N+1)]
for el in ab:
lst[el[0]].append(el[1])
lst[el[1]].append(el[0])
#print(lst)
count=0
for permu in itertools.permutations(list(range(1,N+1))):
if permu[0] == 1:
for i in range(0,N-1):
if permu[i+1] in lst[permu[i]]:
pass
else:
break
else:
count+=1
#print(permu)
print(count)
| N, M = list(map(int, input().split()))
ab=[]
for _ in range(M):
ab.append(tuple(map(int, input().split())))
lst=[[] for _ in range(N+1)]
for el in ab:
lst[el[0]].append(el[1])
lst[el[1]].append(el[0])
#print(lst)
seen=[False]*(N+1)
todo=[]
counter=0
def func(n):
global counter
#print(n, seen, seen.count(True), counter)
if seen.count(True)==N:
counter+=1
#print(counter)
seen[n]=True
for val in lst[n]:
if seen[val]==False:
seen[val]=True
func(val)
seen[val]=False
func(1)
print(counter)
| p03805 |
from itertools import permutations
n,m=list(map(int,input().split()))
es=set()
for _ in range(m):
u,v=list(map(int,input().split()))
u,v=u-1,v-1
es|={(u,v),(v,u)}
res=0
for p in permutations(list(range(n))):
if p[0]!=0: continue
if all((p[i],p[i+1]) in es for i in range(n-1)):
res+=1
print(res)
| from itertools import permutations
n,m=list(map(int,input().split()))
es=set()
for _ in range(m):
u,v=list(map(int,input().split()))
es|={(u-1,v-1),(v-1,u-1)}
print((sum(all((u,v) in es for u,v in zip(p,p[1:]))
for p in permutations(list(range(n))) if p[0]==0)))
| p03805 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.