input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from math import ceil
L=[]
X=0
M=int(eval(input()))
L.append(M)
for i in range(4) :
A=int(eval(input()))
L.append(A)
if A%10 < M%10 and A%10!=0 :
M=A
L.remove(M)
for i in L :
X+=ceil(i/10)*10
print((X+M)) | L=[]
M=[0]
for i in range(5) :
A=int(eval(input()))
L.append(A)
if A%10!=0 :
M.append(10-A%10)
print((sum(L+M)-max(M))) | p03076 |
from math import ceil
ord = [int(eval(input())) for _ in range(5)]
max_wait = 0
max_idx = 0
for i in range(5):
cur = ceil(ord[i] / 10) * 10 - ord[i]
if max_wait < cur:
max_wait = cur
max_idx = i
ans = 0
for i in range(5):
if i != max_idx:
ans += ceil(ord[i] / 10) * 10
ans += ord[max_idx]
print(ans) | ant = [int(eval(input())) for _ in range(5)]
minidx = 0
minval = 124
i = 0
for a in ant:
while 10 < a:
a %= 10
if a == 0:
a = 10
if a < minval:
minidx = i
minval = a
i += 1
ans = 0
for i in range(5):
if i == minidx:
continue
fact = 10
while fact - ant[i] < 0:
fact += 10
ans += fact
ans += ant[minidx]
print(ans) | p03076 |
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime,random
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
aa = [int(eval(input())) for _ in range(5)]
ans = 0
tmp = INF
for a in aa:
ans += (a-1)//10 * 10 + 10
tmp = min(tmp,(a-1)%10+1)
print((ans+tmp-10))
| from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())
order = [int(eval(input())) for _ in range(5)]
ans = 0
last = INF
for i in range(5):
ans += ((order[i]-1)//10+1) * 10
last = min(last,(order[i]-1)%10+1)
print((ans-10+last))
| p03076 |
"""
author : halo2halo
date : 9, Jan, 2020
"""
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
DISH = list(map(int, read().split()))
temp = 10
im = 0
for num, i in enumerate(DISH):
if i % 10 < temp and i % 10 != 0:
temp = i % 10
im = num
ans = 0
for num, i in enumerate(DISH):
if num != im:
ans += ((i + 9) // 10) * 10
else:
ans += i
print(ans)
| """
author : halo2halo
date : 9, Jan, 2020
"""
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
DISH = [int(readline()) for _ in range(5)]
Ceiled = [(i + 9) // 10 * 10 for i in DISH]
div = [y - x for x, y in zip(DISH, Ceiled)]
print((sum(Ceiled)-max(div)))
| p03076 |
import math
import sys
ts = [int(i) for i in sys.stdin.read().split('\n') if i != '']
ds = [int(math.ceil(t / 10) * 10) - t for t in ts]
m = max(ds)
ds.remove(m)
ans = sum(ts) + sum(ds)
print(ans)
| import math
import sys
ts = [int(i) for i in sys.stdin.read().strip().split('\n')]
ds = [int(math.ceil(t / 10) * 10) - t for t in ts]
ans = sum(ts) + sum(ds) - max(ds)
print(ans)
| p03076 |
a = [[int(eval(input())), 0]for i in range(5)]
for i in range(5):
if a[i][0] % 10 == 0:
a[i][1] = 9
else:
a[i][1] = a[i][0] % 10
a = sorted(a, key=lambda x: x[1], reverse=True)
b = 0
for i in range(5):
if i == 4:
b += a[i][0]
else:
b += (a[i][0] + 9) // 10 * 10
print(b)
| a = []
for i in range(5):
b = int(eval(input()))
a.append([(b+9) % 10, b])
a = sorted(a, reverse=True)
c = 0
for i in range(4):
c += (a[i][1] + 9) // 10 * 10
print((c + a[4][1]))
| p03076 |
import itertools
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
ls = [A,B,C,D,E]
ls2 = []
for i in itertools.permutations(ls, 5):
ls2.append(list(i))
minimum = 10**9+7
for i in range(120):
ls3 = ls2[i]
now = 0
for j in range(5):
if j == 0:
now += ls3[j]
else:
if now%10 == 0:
now += ls3[j]
else:
now = 10*(now//10+1)
now += ls3[j]
if now < minimum:
minimum = now
print(minimum)
| import itertools
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
ls = [A,B,C,D,E]
ls2 = []
for i in itertools.permutations(ls,5):
ls2.append(list(i))
minimum = 10**5
for i in ls2:
now = 0
for j in range(5):
if j == 0:
now += i[j]
else:
if now % 10 == 0:
now += i[j]
else:
now = 10 * (now//10+1)
now += i[j]
if now < minimum:
minimum = now
print(minimum) | p03076 |
A = 0
B = []
B.append(0)
for i in range(5):
I = int(eval(input()))
A += I
T = I % 10
if T != 0:
B.append(10 - T)
print((A + sum(B) - max(B)))
| import math
A = [int(eval(input())) for _ in range(5)]
B = 10
ans = 0
for i in range(5):
if A[i] % 10 < B and A[i]%10 > 0:
B = A[i] % 10
ans = -10+B
for j in A:
ans += math.ceil(j/10)*10
print(ans)
| p03076 |
import itertools
import math
import fractions
import functools
import copy
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
original = [a,b,c,d,e]
sum = 0
minimum = 10
index = 0
for i in range(len(original)):
if original[i] % 10 != 0:
sum += original[i]//10 * 10 + 10
if original[i]%10 < minimum:
index = i
minimum = original[i]%10
else:
sum += original[i]
if minimum != 10:
print((sum-(original[index]//10 * 10 + 10)+original[index]))
else: print((a+b+c+d+e)) | def main():
# s = int(input())
# n, k = map(int, input().split())
# h = list(map(int, input().split()))
# s = input()
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
total = 0
li = [a, b, c, d, e]
mini = 10**10
ans_idx = 0
for i, s in enumerate(li):
last_s = int(str(s)[-1])
if mini > last_s and last_s != 0:
mini = last_s
ans_idx = i
for i, s in enumerate(li):
if i != ans_idx:
if s % 10 != 0:
total += s // 10 * 10 + 10
else:
total += s
else:
total += s
print(total)
if __name__ == '__main__':
main()
| p03076 |
import math
al = []
for _ in range(5):
al.append(int(eval(input())))
tmp = 11
log = -1
for idx,a in enumerate(al):
point = a % 10
if point == 0:
point = 10
if tmp > point:
tmp = point
log = idx
ans = 0
for idx, a in enumerate(al):
if idx != log:
ans += math.ceil(a / 10) * 10
else:
ans += a
print(ans) | ans = 0
def ceil(a, b):
return a // b + (a % b > 0)
big = 0
for _ in range(5):
a = int(eval(input()))
ans += ceil(a, 10) * 10
if a % 10 != 0:
big = max(big, 10-(a%10))
print((ans-big))
| p03076 |
import math
Z = [int(eval(input())) for _ in range(5)]
ans = 0
r = 0
for z in Z:
if z%10 != 0:
r = max(10 - z%10, r)
ans += math.ceil(z/10) * 10
print((ans - r)) | Z = [int(eval(input())) for _ in range(5)]
ans = 0
r = 0
for z in Z:
time = (z+9) // 10 * 10
r = max(r, time - z)
ans += time
print((ans - r)) | p03076 |
import itertools
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
ans = 10**18
for v in itertools.permutations([a, b, c, d, e], 5):
m = 0
for i in range(len(v)):
m += v[i]
if i == len(v)-1:
break
if v[i] % 10 != 0:
m += 10 - v[i] % 10
ans = min(ans, m)
print(ans)
| import itertools
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
l = sorted([a, b, c, d, e], key=lambda x: x % 10)
ans = 0
flag = False
for i in range(len(l)):
if l[i] % 10 == 0:
ans += l[i]
elif flag == False:
ans += l[i]
flag = True
else:
ans += l[i]
ans += 10 - l[i] % 10
print(ans)
'''
ans = 10**18
for v in itertools.permutations([a, b, c, d, e], 5):
m = 0
for i in range(len(v)):
m += v[i]
if i == len(v)-1:
break
if v[i] % 10 != 0:
m += 10 - v[i] % 10
ans = min(ans, m)
print(ans)
'''
# 全ての順列を計算する、最後の値は１０の余りを加算しない。
| p03076 |
a = []
for i in range(5):
b = int(eval(input()))
c = b % 10 if b % 10 != 0 else 9
d = (b + 10 - 1) // 10 * 10
a.append([b, c, d])
a = sorted(a, key=lambda x: x[1], reverse=True)
total = 0
for i in range(len(a)):
total += a[i][2]
print((total - a[i][2] + a[i][0]))
| import itertools
a = [int(eval(input())) for _ in range(5)]
mi = 10 ** 10
for i in itertools.permutations(a, 5):
t = 0
for j, v in enumerate(i):
if j == 4:
t += v
else:
t += ((v + 9) // 10 * 10)
mi = min(t, mi)
print(mi)
| p03076 |
import math
# 定義
minutes = [int(eval(input())) for i in range(5)]
m = [math.ceil(minutes[k] / 10) * 10 for k in range(5)]
# 最後に注文するやつを決める
last = min((minutes[l] - 1) % 10 for l in range(5))
last += 1
# 出力
print((m[0] + m[1] + m[2] + m[3] + m[4] + last - 10))
| from math import ceil
A = [int(eval(input())) for _ in range(5)]
mmin = 10
ans = 0
for ai in A:
ans += 10*ceil(ai/10)
if ai%10 != 0:
mmin = min(mmin, ai%10)
if mmin%10 == 0:
print(ans)
else:
print((ans - 10 + mmin))
| p03076 |
import math
S = []
L = []
for i in range(5):
D = int(eval(input()))
T = math.ceil(D/10)
S.append(T)
L.append(T-D/10)
print((int((sum(S) - max(L))*10))) | import math
s = []
l = []
for i in range(5):
d = int(eval(input()))
t = math.ceil(d / 10)
s.append(t)
l.append(t-d/10)
print((int((sum(s) - max(l))*10))) | p03076 |
ans = 0
b = 0
for i in range(5):
a = int(eval(input()))
ans += -(-a//10)*10
b = max(b, (10-a%10)%10)
ans -= b
print(ans) | ans = 0
b = 0
for i in range(5):
a = int(eval(input()))
ans += -(-a//10)*10
b = max(b, -a%10)
ans -= b
print(ans) | p03076 |
from itertools import permutations
from math import ceil
times = list(int(eval(input())) for _ in range(5))
orders = list(permutations(times, 5))
minimum = sum(ceil(time/10)*10 for time in times)
for order in orders:
cnt = order[0]
for i in range(1, 5):
cnt += ceil(order[i]/10)*10
minimum = min(minimum, cnt)
print(minimum)
| from itertools import permutations
from math import ceil
times = list(int(eval(input())) for _ in range(5))
orders = list(permutations(times, 5))
minimum = sum(ceil(time/10)*10 for time in times)
for order in orders:
total = order[0]
for i in range(1, 5):
total += ceil(order[i]/10)*10
minimum = min(minimum, total)
print(minimum)
| p03076 |
a = [int(eval(input())) for i in range(5)]
if all(n%10==0 for n in a):
b = sum([((k//10)+1)*10 for k in a if k%10 != 0])
b += sum([l for l in a if l%10 ==0])
print(b)
else:
A = min([j%10 for j in a if j%10 != 0])
b = sum([((k//10)+1)*10 for k in a if k%10 != 0])
b += sum([l for l in a if l%10 ==0])
print((b-(10-A))) | l = [int(eval(input())) for _ in range(5)]
l.sort(key=lambda x: 10 if x%10==0 else x%10)
l = l[::-1]
ans = 0
for i in range(5):
if i == 4 or l[i]%10==0:
ans += l[i]
else:
ans += ((l[i]//10)+1)*10
print(ans) | p03076 |
import itertools
import math
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
tlist = [A, B, C, D, E]
l = itertools.permutations(tlist, 5)
t = []
count = 0
for i in l:
count = 0
for j in range(5):
if j != 4 :
count += int(math.ceil(i[j] / 10) * 10)
else:
count += i[j]
t.append(count)
print((min(t))) | import math
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
tlist = [A, B, C, D, E]
mod_list = [A % 10, B % 10, C % 10, D % 10, E % 10]
mod_list_2 = mod_list[:]
count = 0
already = 0
while 0 in mod_list_2:
mod_list_2.pop(mod_list_2.index(0))
min_mod = 0
if mod_list_2:
min_mod = min(mod_list_2)
if min_mod == 0:
print((A + B + C + D + E))
else:
for i in tlist:
if (i % 10 == min_mod) and already == 0:
already = i
else:
count += int(math.ceil(i / 10) * 10)
else:
count += already
print(count)
| p03076 |
from itertools import permutations
cook_times = [int(eval(input())) for _ in range(5)]
ans = float('inf')
for ts in permutations(cook_times):
total = 0
for t in ts[:-1]:
if t % 10 == 0:
total += t
else:
total += (t + 9) // 10 * 10
ans = min(ans, total + ts[-1])
print(ans) | cook_times = sorted([int(eval(input())) for _ in range(5)], key=lambda x: (x + 9) // 10 * 10 - x)
ans = 0
for t in cook_times[:-1]:
ans += (t + 9) // 10 * 10
print((ans + cook_times[-1])) | p03076 |
def stupid():
from itertools import permutations
ret = float('inf')
for p in permutations(a):
time = 0
for dish in p:
time += (10 - (time % 10)) % 10
time += dish
ret = min(ret, time)
return ret
a = [int(eval(input())) for _ in range(5)]
print((stupid())) | def stupid(a):
from itertools import permutations
ret = float('inf')
for p in permutations(a):
time = 0
for dish in p:
time += (10 - (time % 10)) % 10
time += dish
ret = min(ret, time)
return ret
def fast(a):
temp = a[::]
temp.sort(key=lambda x: (10 - (x % 10)) % 10)
ret = 0
for dish in temp:
ret += (10 - (ret % 10)) % 10
ret += dish
return ret
def stress(n):
from random import randint
for _ in range(n):
a = [randint(1, 123) for _ in range(5)]
expected = stupid(a)
got = fast(a)
if got != expected:
raise Exception('%s -> expected:%d, got:%d' % (' '.join(map(str, a)), expected, got))
test = False
if test:
stress(1000)
else:
a = [int(eval(input())) for _ in range(5)]
print((fast(a))) | p03076 |
from functools import reduce
l = [int(eval(input())) for _ in range(5)]
r = [10 if i % 10 == 0 else i % 10 for i in l]
m = [i if i % 10 == 0 else i // 10 * 10 + 10 for i in l]
print((sum(m) + min(r) - 10)) | l = [int(eval(input())) for _ in range(5)]
r = [10 if i % 10 == 0 else i % 10 for i in l]
m = [i if i % 10 == 0 else i // 10 * 10 + 10 for i in l]
print((sum(m) + min(r) - 10)) | p03076 |
import math
a = [input().rstrip() for _ in range(5)]
a = sorted(a, key=lambda x: x[-1], reverse=True)
while True:
m = a.pop()
if m[-1] == '0':
a.insert(0, m)
else:
break
s = sum([math.ceil(int(n) / 10) * 10 for n in a])
s += int(m)
print(s)
| s = 0
mod = 0
for _ in range(5):
i = int(eval(input()))
m = i % 10
if m != 0:
if mod == 0:
mod = m
else:
mod = min(mod, m)
s += (i // 10 + 1) * 10
else:
s += i
if mod != 0:
s = s - 10 + mod
print(s)
| p03076 |
A = [int(eval(input())) for i in range(5)]
B = [(10 - a % 10) % 10 for a in A]
print((sum(A) + sum(B) - max(B)))
| A = [int(eval(input())) for i in range(5)]
# A = [101, 86, 119, 108, 57]
# A = [29, 20, 7, 35, 120]
# A = [123, 123, 123, 123, 123]
B = [(10-a % 10) % 10 for a in A]
C = [-(-a//10)*10 for a in A]
print((sum(C)-max(B)))
| p03076 |
"""ABC091 2D Plane 2N Points diff:
"""
N = int(eval(input()))
ab = [tuple(map(int, input().split())) for _ in range(N)]
cd = [tuple(map(int, input().split())) for _ in range(N)]
ans_x = 0
cd.sort(key=lambda x: x[0])
ab.sort(key=lambda x: x[1], reverse=True)
ab_used = [0]*N
for i, (c, d) in enumerate(cd):
for j, (a, b) in enumerate(ab):
if not ab_used[j] and a < c and b < d:
ab_used[j] = 1
ans_x += 1
break
ans_y = 0
cd.sort(key=lambda x: x[1])
ab.sort(key=lambda x: x[0], reverse=True)
ab_used = [0]*N
for i, (c, d) in enumerate(cd):
for j, (a, b) in enumerate(ab):
if not ab_used[j] and a < c and b < d:
ab_used[j] = 1
ans_y += 1
break
print((max(ans_x, ans_y))) | """ABC091 2D Plane 2N Points diff:
"""
N = int(eval(input()))
ab = [tuple(map(int, input().split())) for _ in range(N)]
cd = [tuple(map(int, input().split())) for _ in range(N)]
ans_x = 0
cd.sort(key=lambda x: x[0])
ab.sort(key=lambda x: x[1], reverse=True)
ab_used = [0]*N
for i, (c, d) in enumerate(cd):
for j, (a, b) in enumerate(ab):
if not ab_used[j] and a < c and b < d:
ab_used[j] = 1
ans_x += 1
break
# ans_y = 0
# cd.sort(key=lambda x: x[1])
# ab.sort(key=lambda x: x[0], reverse=True)
# ab_used = [0]*N
# for i, (c, d) in enumerate(cd):
# for j, (a, b) in enumerate(ab):
# if not ab_used[j] and a < c and b < d:
# ab_used[j] = 1
# ans_y += 1
# break
print(ans_x) | p03409 |
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def pf(s): return print(s, flush=True)
N = I()
A,B = [], []
for n in range(N):
A.append(LI())
for n in range(N):
B.append(LI())
"""
一旦赤い点がどの青い点を持てるのかを洗い出す
lenが小さい順に青を消していく。
何個消せるかで勝負
"""
b_a = []
for b in B:
tmp = []
for a in A:
if a[0] < b[0] and a[1] < b[1]:
# 赤が青より小さいとき
tmp.append(a)
if tmp:
b_a.append(tmp)
# print(b_a)
result = 0
results = []
# print('ba', b_a)
def dfs(arr, count):
for i in range(len(arr)-1, -1, -1):
tmp = sorted(arr, reverse=True, key=lambda x: len(x))
popped = tmp.pop()
# print('popped', popped)
# tmp = [_ for _ in arr]
for p in popped:
l = [[k for k in j if k != p] for j in tmp]
l = [j for j in l if j != []]
# print('l',l)
if not l:
results.append(count+1)
else:
dfs(l, count+1)
dfs(b_a, 0)
# print(results)
if not results:
print(0)
exit()
print(max(results))
| import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def pf(s): return print(s, flush=True)
N = I()
A,B = [], []
for n in range(N):
A.append(LI())
for n in range(N):
B.append(LI())
# N = 100
# A,B = [], []
# for n in range(N):
# A.append([random.randint(0,2*N), random.randint(0, 2*N)])
# for n in range(N):
# B.append([random.randint(0,2*N), random.randint(0, 2*N)])
B = sorted(B, key=lambda x: x[0])
result = 0
for b in B:
tmp = [a for a in A if a[0] < b[0] and a[1] < b[1]]
if not tmp:
continue
result += 1
closest = max(tmp, key=lambda x: x[1])
A.remove(closest)
print(result)
| p03409 |
n = int(eval(input()))
red = [list(map(int,input().split())) for _ in range(n)]
blue = [list(map(int,input().split())) for _ in range(n)]
red_count = []
import copy
for i in range(n):
index_list = []
for j in range(n):
if blue[j][0]>red[i][0] and blue[j][1]>red[i][1]:
index_list.append(j)
red_count.append(index_list)
red_count.sort(key=lambda x: len(x))
def redcounter(count,i,red_count):
if i == len(red_count)-1 and red_count[i]:
return count+1
elif i == len(red_count)-1:
return count
if red_count[i]:
for index in range(len(red_count[i])): ## removeするindex
remove_index = red_count[i][index]
red_count_copy = copy.deepcopy(red_count)
c = count
for j in range(i+1,len(red_count_copy)): ## removeしていく
if remove_index in red_count_copy[j]:
red_count_copy[j].remove(remove_index)
c = max(count,redcounter(c,i+1,red_count_copy))
return c+1
else:
return redcounter(count,i+1,red_count)
print((redcounter(0,0,red_count)))
| n = int(eval(input()))
lired = [list(map(int,input().split())) for _ in range(n)]
liblue = [list(map(int,input().split())) for _ in range(n)]
lired = sorted(lired,key = lambda x:-x[1])
liblue = sorted(liblue,key = lambda x:x[0])
li = list(range(n))
count = 0
for i in range(n):
for j in li:
if lired[i][0] < liblue[j][0] and lired[i][1] < liblue[j][1]:
count += 1
li.remove(j)
break
print(count)
| p03409 |
n = int(eval(input()))
red = [list(map(int,input().split())) for _ in range(n)]
blue = [list(map(int,input().split())) for _ in range(n)]
blue.sort(key=lambda x:(x[0],x[1]))
check = [False]*n
for i in range(n):
a = -1
c = -1
for j in range(n):
if check[j]:continue
if blue[i][0] > red[j][0] and blue[i][1] > red[j][1]:
if a < red[j][1]:
a = red[j][1]
c = j
if c != -1:
check[c] = True
print((check.count(True))) | n = int(eval(input()))
red = [list(map(int,input().split())) for _ in range(n)]
red.sort(key=lambda x:(x[1]))
blue = sorted(list(map(int,input().split())) for _ in range(n))
blue.sort(key=lambda x:(x[0],x[1]))
seen = [False]*n
for i in range(n):
check = -1
for j in range(n):
if seen[j]:continue
if blue[i][0] > red[j][0] and blue[i][1] > red[j][1]:
check = j
if check != -1:seen[check] = True
print((seen.count(True))) | p03409 |
import heapq
N = int(eval(input()))
red = []
for i in range(N):
x,y = list(map(int, input().split()))
heapq.heappush(red, (-y, x))
blue = []
for i in range(N):
x,y = list(map(int, input().split()))
heapq.heappush(blue, (x,y))
ans = 0
for i in range(N):
tmp = []
bx,by = heapq.heappop(blue)
flag = True
while flag:
mry, rx = heapq.heappop(red)
if bx > rx and by > -mry:
ans += 1
flag = False
if len(tmp) > 0:
for mry,rx in tmp:
heapq.heappush(red, (mry, rx))
else:
tmp.append((mry, rx))
if len(red) == 0:
if len(tmp) > 0:
for mry,rx in tmp:
heapq.heappush(red, (mry, rx))
break
print(ans)
|
N = int(eval(input()))
r = []
for _ in range(N):
x,y = list(map(int, input().split()))
r.append((-y,x))
b = []
for _ in range(N):
x,y = list(map(int, input().split()))
b.append((x,y))
r.sort()
b.sort()
ans = 0
for my,x in r:
for j in range(len(b)):
if -my < b[j][1] and x < b[j][0]:
ans += 1
b.pop(j)
break
print(ans)
| p03409 |
n=int(eval(input()))
ab=[list(map(int, input().split())) for _ in range(n)]
cd=[list(map(int, input().split())) for _ in range(n)]
#ab = sorted(ab, key=lambda x:x[1]*(-1))
ab.sort(key=lambda x: x[1],reverse=True)
cd=sorted(cd)
cnt=0
for i in range(n):#ab
for j in range(len(cd)):#cd
if ab[i][0]<cd[j][0] and ab[i][1]<cd[j][1]:
cnt+=1
cd.pop(j)
break
print(cnt) | n=int(eval(input()))
ab=[list(map(int, input().split())) for _ in range(n)]
cd=[list(map(int, input().split())) for _ in range(n)]
#ab = sorted(ab, key=lambda x:x[1]*(-1))
ab.sort(key=lambda x: x[0],reverse=True)
ab.sort(key=lambda x: x[1],reverse=True)
cd=sorted(cd)
cnt=0
for i in range(n):#ab
for j in range(len(cd)):#cd
if ab[i][0]<cd[j][0] and ab[i][1]<cd[j][1]:
cnt+=1
cd.pop(j)
break
print(cnt) | p03409 |
import sys
sys.setrecursionlimit(10000)
def resolve():
N = int(eval(input()))
Reds = [list(map(int, input().split(" "))) for i in range(N)]
Blues = [list(map(int, input().split(" "))) for i in range(N)]
maxpairs = 0
BluePerms = permutations(Blues)
for blues in BluePerms:
npairs = 0
for i in range(N):
if able_to_be_pair(Reds[i], blues[i]):
npairs += 1
maxpairs = max(maxpairs, npairs)
print(maxpairs)
def able_to_be_pair(red, blue):
return True if (blue[0] - red[0]) > 0 and (blue[1] - red[1]) > 0 else False
import itertools
def permutations(array, choose=None):
if choose is None:
choose = len(array)
return list(itertools.permutations(array, choose))
if '__main__' == __name__:
resolve() | import sys
import itertools
sys.setrecursionlimit(10000)
def resolve():
N = int(eval(input()))
Reds = [list(map(int, input().split(" "))) for i in range(N)]
Blues = [list(map(int, input().split(" "))) for i in range(N)]
maxpairs = 0
for blues in itertools.permutations(Blues, N):
npairs = 0
for i in range(N):
if able_to_be_pair(Reds[i], blues[i]):
npairs += 1
maxpairs = max(maxpairs, npairs)
print(maxpairs)
def able_to_be_pair(red, blue):
return True if (blue[0] - red[0]) > 0 and (blue[1] - red[1]) > 0 else False
if '__main__' == __name__:
resolve() | p03409 |
n = int(eval(input()))
r=[list(map(int, input().split())) for i in range(n)]
b=[list(map(int, input().split())) for i in range(n)]
p=[]
v=[0]*n
def dfs(li,m,num):
global ma
if num==n:
ma=max(ma,m)
return
for i in p[num]:
if li[i]==0:
li[i]=1
m+=1
dfs(li,m,num+1)
li[i]=0
m-=1
dfs(li,m,num+1)
ma = 0
for i in range(n):
q=[]
for j in range(n):
if r[i][0]<b[j][0] and r[i][1]<b[j][1]:
q.append(j)
p.append(q)
dfs(v,0,0)
print(ma)
| n = int(eval(input()))
r=[list(map(int, input().split())) for i in range(n)]
b=[list(map(int, input().split())) for i in range(n)]
b.sort(key=lambda x:x[0])
p=[]
r_used=[0]*n
for i in range(n):
q=[]
for j in range(n):
if r[j][0]<b[i][0] and r[j][1]<b[i][1]:
q.append([r[j][1],j])
q.sort(key=lambda x:x[0],reverse=True)
p.append(q)
ans = 0
for i in range(n):
for j in range(len(p[i])):
if p[i][j][0]<b[i][1] and r_used[p[i][j][1]]==0:
ans+=1
r_used[p[i][j][1]]=1
break
print(ans)
| p03409 |
import itertools
N = int(eval(input()))
red = [tuple(map(int, input().split())) for i in range(N)]
blue = [tuple(map(int, input().split())) for i in range(N)]
res = 0
for _blue in itertools.permutations(blue):
sum_pair = len([1 for (a, b), (c, d) in zip(red, _blue) if a < c and b < d])
res = max(res, sum_pair)
print(res) |
N = int(eval(input()))
red = [list(map(int, input().split())) for i in range(N)]
blue = [list(map(int, input().split())) for i in range(N)]
red.sort(key=lambda x:x[1], reverse=True)
blue.sort()
c = 0
for bx, by in blue:
for i, (rx, ry) in enumerate(red):
if rx<bx and ry<by:
c += 1
red.pop(i)
break
print(c) | p03409 |
import sys
def resolve():
readline = sys.stdin.readline # 1行だけ文字列にする
N = int(readline())
NN = 2 * N + 1
# 青色はx座標をlistのindex,y座標をlistのvalueとして入力，赤は逆
red = [[] for _ in [0] * NN]
blue = [[] for _ in [0] * NN]
for _ in [0] * N:
a, b = list(map(int, readline().split()))
red[b].append(a)
for _ in [0] * N:
c, d = list(map(int, readline().split()))
blue[c].append(d)
# 青色でvalueのy座標について降順(大きい順)でソート
# 赤色ではvalueのx座標について降順でソート
# これで青色はx座標は昇順(index)，y座標は降順(value)にソートされる
# 赤色はy座標が昇順(index)，x座標が降順(value)
for i in range(NN):
r = red[i]
b = blue[i]
r.sort(reverse=True)
b.sort(reverse=True)
r[0:0] = [i]
b[0:0] = [i]
# 青点はx座標の昇順で，赤点はy座標の降順
# 最小のxの青点で最大のyを持つ赤点を選択
ans = 0
flag = False
while blue:
cd_blue = blue.pop(0)
c = cd_blue.pop(0)
if cd_blue:
for d in cd_blue:
for ba_red in red[::-1]:
b = ba_red[0]
if ba_red[1:]:
for i in range(1, len(ba_red)):
a = ba_red[i]
if a <= c and b <= d:
ans += 1
del red[b][i]
flag = True
break
if flag:
break
if flag:
flag = False
break
print(ans)
resolve()
| def resolve():
import sys
readline = sys.stdin.readline # 1行だけ文字列にする
N = int(readline())
# 赤，青点をx,y座標の2次元リストとして入力
red = [list(map(int, readline().split())) for _ in [0] * N]
blue = [list(map(int, readline().split())) for _ in [0] * N]
# 赤はy座標で降順ソート，青はx座標で昇順ソート
red.sort(key=lambda x: x[1], reverse=True)
blue.sort()
ans = 0
for c, d in blue:
for a, b in red:
if a <= c and b <= d:
ans += 1
red.remove([a, b])
break
print(ans)
resolve()
| p03409 |
# AtCoder Beginner Contest 091
# C - 2D Plane 2N Points
# https://atcoder.jp/contests/abc091/tasks/arc092_a
N = int(eval(input()))
A = [tuple(map(int, input().split())) for _ in range(N)]
B = [tuple(map(int, input().split())) for _ in range(N)]
A.sort(key=lambda x: x[0])
B.sort(key=lambda x: x[0])
used = [False]*N
cnt = 0
for u, v in B:
maxy = -1
maxi = -1
for i, (x, y) in enumerate(A):
if x >= u:
break
if used[i] or y >= v:
continue
if maxy < y:
maxy = y
maxi = i
if maxy > -1:
used[maxi] = True
cnt += 1
print(cnt)
| N = int(eval(input()))
A = [tuple(map(int, input().split())) for _ in range(N)]
B = [tuple(map(int, input().split())) for _ in range(N)]
A.sort()
B.sort()
cnt = 0
for u, v in B:
maxy = -1
maxi = -1
for i, (x, y) in enumerate(A):
if x >= u:
break
if y >= v:
continue
if maxy < y:
maxy = y
maxi = i
if maxy > -1:
A.pop(maxi)
cnt += 1
print(cnt)
| p03409 |
N=int(eval(input()))
AB=list()
for i in range(N):
AB.append(list(map(int,input().split())))
CD=list()
for i in range(N):
CD.append(list(map(int,input().split())))
import itertools
ans=0
for v in itertools.permutations(CD):
s=0
for x,y in zip(AB,v):
if x[0]<y[0] and x[1]<y[1]:
s+=1
if s>ans:
ans=s
print(ans)
| n=int(eval(input()))
ab=list()
cd=list()
for i in range(n):
ab.append(list(map(int,input().split())))
for j in range(n):
cd.append(list(map(int,input().split())))
cd.sort(key=lambda x:x[0])
AB=[[-1,-1]]*n
for i in range(n):
S=[x for x in ab if x[0]<cd[i][0] and x[1]<cd[i][1]]
S.sort(key=lambda k:k[1])
if len(S)>0:
AB[i]=S[-1]
ab.remove(S[-1])
print((len(AB)-AB.count([-1,-1])))
| p03409 |
n = int(eval(input()))
red_point_list = [[int(j) for j in input().split()] for i in range(n)]
blue_point_list = [[int(j) for j in input().split()] for i in range(n)]
px = red_point_list[0][0]
py = red_point_list[0][1]
tmp = []
for i, p in enumerate(blue_point_list):
if px < p[0] and py < p[1]:
new_blue_points = blue_point_list.copy()
new_blue_points.pop(i)
tmp.append((1, new_blue_points))
if len(tmp) == 0:
tmp = [(0, blue_point_list)]
for a, b in red_point_list[1:]:
new_tmp = []
for count, blue_points in tmp:
for i, p in enumerate(blue_points):
if a < p[0] and b < p[1]:
new_blue_points = blue_points.copy()
new_blue_points.pop(i)
new_tmp.append((count+1, new_blue_points))
else:
new_tmp.append((count, blue_points))
tmp = new_tmp
print((max(tmp, key=lambda x: x[0])[0]))
| n = int(eval(input()))
red_point_list = [[int(j) for j in input().split()] for i in range(n)]
blue_point_list = [[int(j) for j in input().split()] for i in range(n)]
count = 0
for c, d in sorted(blue_point_list, key=lambda x: x[0]):
tmp_index = 0
tmp_y = -1
for i, p in enumerate(red_point_list):
if c > p[0] and d > p[1]:
if p[1] >= tmp_y:
tmp_index = i
tmp_y = p[1]
if tmp_y > -1:
count += 1
red_point_list.pop(tmp_index)
print(count) | p03409 |
#入力
N = int(eval(input()))
red_x = []
red_y = []
for i in range(N):
a = list(map(int, input().split()))
red_x += [a]
red_y += [a[::-1]]
red_x.sort(reverse = False)
red_y.sort(reverse = False)
#print (red_x, red_y)
blue_x = []
blue_y = []
for i in range(N):
a = list(map(int, input().split()))
blue_x += [a]
blue_y += [a[::-1]]
blue_x.sort(reverse = False)
blue_y.sort(reverse = False)
#print (blue_x, blue_y)
def judge_x(m): #blue[m]がペアを作れるかどうかをTrue or Falseで返す x優先
INF = 10 ** 9
count = 0
memo = -1
for i in range(N):
if blue_x[m][0] > red_x[i][0]: #x座標が条件を満たすか確認
#条件を満たす中で最大のy座標を探す
#y座標の確認をしてない！！！！ｓ
#
if memo < red_x[i][1] and blue_x[m][1] > red_x[i][1]:
count = 1
memo = max(memo, red_x[i][1]) #最も大きいy座標を記録
memo_i = i
if count == 0: #iのループを回してもカウントが増えない=x座標が条件を満たすことが一度もない
return False
else: #少なくとも一回は条件を満たした。
red_x[memo_i][0] = INF #使ったものをINFで書き換え
red_x[memo_i][1] = INF #使ったものをINFで書き換え
# print (red_x)
return True
return False
def judge_y(m): #blue[m]がペアを作れるかどうかをTrue or Falseで返す y優先
INF = 10 ** 9
for i in range(N):
if blue_y[m][1] > red_y[i][1]:
if blue_y[m][0] > red_y[i][0]:
red_y[i][1] = INF
return True
else:
pass
return False
count_x = 0
for s in range(N): #blue内のxが最も小さいののから着目
if judge_x(s):
count_x += 1
print (count_x)
#count_y = 0
#for t in range(N):
# if judge_y(t):
# count_y += 1
#print (count_y)
#print (max(count_x, count_y))
#print (judge(0))
#print (judge(1))
#print (judge(2))
#print (judge(3))
#print (judge(4))
| #入力
N = int(eval(input()))
#赤の座標を取得-->並び替えて左ほど小さくする
red = []
for i in range(N):
a = list(map(int, input().split()))
red += [a]
red.sort(reverse = False)
#青の座標を取得-->並び替えて左ほど小さくする
blue = []
for i in range(N):
a = list(map(int, input().split()))
blue += [a]
blue.sort(reverse = False)
#blue[m]がペアを作れるかどうかをTrue or Falseで返す
def judge(m):
INF = 10 ** 9
count = 0
memo = -1
for i in range(N): #redのリストを小さい順に探索
if blue[m][0] > red[i][0]: #x座標が条件を満たすか確認
#条件を満たす中で最大のy座標を探す
if memo < red[i][1] and blue[m][1] > red[i][1]:
#red[i][1]=赤のy座標が最も大きくかつ、blue[m][1]=青のy座標より小さい時
count = 1 #1つでも条件を満たすものがあれば、count = 1にする
memo = max(memo, red[i][1]) #最も大きいy座標を記録
memo_i = i #最も大きくなるときのiをメモ
if count == 0: #iのループを回してもカウントが増えない=x座標が条件を満たすことが一度もない
return False
else: #少なくとも一回は条件を満たした。
red[memo_i][0] = INF #使ったものをINFで書き換え
red[memo_i][1] = INF #使ったものをINFで書き換え
return True
count = 0
for s in range(N): #blue内のxが最も小さいののから着目
if judge(s):
count += 1
print (count)
| p03409 |
N = int(eval(input()))
red = [list(map(int, input().split())) for _ in range(N)]
blue = [list(map(int, input().split())) for _ in range(N)]
# x座標でソート
blue.sort(key=lambda x: x[1])
# y座標で降順ソート
red.sort(reverse=True)
# print(blue)
# print(red)
# blue_list = [0] * N
red_list = [0] * N
for b in range(N):
for r in range(N):
if red_list[r] == 1:
continue
if red[r][0] < blue[b][0] and red[r][1] < blue[b][1]:
# print(b, r)
# blue_list[b] = 1
red_list[r] = 1
break
print((sum(red_list)))
| N = int(eval(input()))
red = [list(map(int, input().split())) for _ in range(N)]
blue = [list(map(int, input().split())) for _ in range(N)]
# 青をx座標で昇順ソート
blue.sort(key=lambda x: x[1])
# 赤をy座標で降順ソート
red.sort(key=lambda x: x[0], reverse=True)
red_list = [0] * N
for b in range(N):
for r in range(N):
if red_list[r] == 1:
continue
if red[r][0] < blue[b][0] and red[r][1] < blue[b][1]:
red_list[r] = 1
break
print((sum(red_list)))
| p03409 |
def f(blue, red, ans):
c = 0
for i, b in enumerate(blue):
for j, r in enumerate(red):
if b[0] >= r[0] and b[1] >= r[1]:
blue.pop(i)
red.pop(j)
c = max(c, f(blue, red, ans + 1))
blue.insert(i, b)
red.insert(j, r)
return max(c, ans)
def main():
N = int(eval(input()))
red = [list(map(int, input().split())) for _ in range(N)]
blue = [list(map(int, input().split())) for _ in range(N)]
print((f(blue, red, 0)))
main()
| def main():
N = int(eval(input()))
red = sorted(
[list(map(int, input().split())) for _ in range(N)],
key=lambda x: x[1],
reverse=True
)
blue = sorted(
[list(map(int, input().split())) for _ in range(N)],
key=lambda x: x[0]
)
ans = 0
for b in blue:
for i, r in enumerate(red):
if b[0] > r[0] and b[1] > r[1]:
ans += 1
red.pop(i)
break
print(ans)
main()
| p03409 |
from collections import deque
class Dinic:
def __init__(self, N0, N1):
self.N0 = N0
self.N1 = N1
self.N = N = 2+N0+N1
self.G = [[] for i in range(N)]
for i in range(N0):
forward = [2+i, 1, None]
forward[2] = backward = [0, 0, forward]
self.G[0].append(forward)
self.G[2+i].append(backward)
self.backwards = bs = []
for i in range(N1):
forward = [1, 1, None]
forward[2] = backward = [2+N0+i, 0, forward]
bs.append(backward)
self.G[2+N0+i].append(forward)
self.G[1].append(backward)
def add_edge(self, fr, to):
#assert 0 <= fr < self.N0
#assert 0 <= to < self.N1
v0 = 2 + fr
v1 = 2 + self.N0 + to
forward = [v1, 1, None]
forward[2] = backward = [v0, 0, forward]
self.G[v0].append(forward)
self.G[v1].append(backward)
def bfs(self):
G = self.G
level = [None]*self.N
deq = deque([0])
level[0] = 0
while deq:
v = deq.popleft()
lv = level[v] + 1
for w, cap, _ in G[v]:
if cap and level[w] is None:
level[w] = lv
deq.append(w)
self.level = level
return level[1] is not None
def dfs(self, v, t):
if v == t:
return 1
level = self.level
for e in self.it[v]:
w, cap, rev = e
if cap and level[v] < level[w] and self.dfs(w, t):
e[1] = 0
rev[1] = 1
return 1
return 0
def flow(self):
flow = 0
while self.bfs():
*self.it, = list(map(iter, self.G))
while self.dfs(0, 1):
flow += 1
return flow
def matching(self):
return [cap for _, cap, _ in self.backwards]
#####################################################################################
N = int(eval(input()))
s = []
ss = []
for i in range(N):
s.append([int(i) for i in input().split()])
for i in range(N):
ss.append([int(i) for i in input().split()])
pair = []
for i in range(len(s)):
right = []
for j in range(N):
if s[j][0] < ss[i][0] and s[j][1] < ss[i][1]:
right.append(j)
pair.append(right)
# print(pair)
#####################################################################################
# 頂点の組u,vと辺の重みc（今回は1）からグラフ作って最大流で解くFOOOOOOOOOOOOOOOOO
V = len(pair) + N + 2 # (sとt追加)
dinic = Dinic(V, V)
for i in range(len(pair)): # 始点s（番号0）から青い点(1から最大len(pair))への辺
u, v, c = 0, i + 1, 1
dinic.add_edge(u, v)
for i in range(N): # 赤い点（len(pair)+1から最大len(pair)+n）から終点t（番号V-1）への辺
u, v, c = i + len(pair) + 1, V - 1, 1
dinic.add_edge(u, v)
for i in range(len(pair)): # 青い点（番号1から最大len(pair)に振り直し）から 赤い点（番号1～100に振り直し）への辺
for j in range(len(pair[i])):
node1, node2 = i + 1, pair[i][j] + len(pair) + 1
u, v, c = node1, node2, 1
dinic.add_edge(u, v)
print((dinic.flow() - 2)) | from collections import deque
class Dinic:
def __init__(self, N0, N1):
self.N0 = N0
self.N1 = N1
self.N = N = 2+N0+N1
self.G = [[] for i in range(N)]
for i in range(N0):
forward = [2+i, 1, None]
forward[2] = backward = [0, 0, forward]
self.G[0].append(forward)
self.G[2+i].append(backward)
self.backwards = bs = []
for i in range(N1):
forward = [1, 1, None]
forward[2] = backward = [2+N0+i, 0, forward]
bs.append(backward)
self.G[2+N0+i].append(forward)
self.G[1].append(backward)
def add_edge(self, fr, to):
#assert 0 <= fr < self.N0
#assert 0 <= to < self.N1
v0 = 2 + fr
v1 = 2 + self.N0 + to
forward = [v1, 1, None]
forward[2] = backward = [v0, 0, forward]
self.G[v0].append(forward)
self.G[v1].append(backward)
def bfs(self):
G = self.G
level = [None]*self.N
deq = deque([0])
level[0] = 0
while deq:
v = deq.popleft()
lv = level[v] + 1
for w, cap, _ in G[v]:
if cap and level[w] is None:
level[w] = lv
deq.append(w)
self.level = level
return level[1] is not None
def dfs(self, v, t):
if v == t:
return 1
level = self.level
for e in self.it[v]:
w, cap, rev = e
if cap and level[v] < level[w] and self.dfs(w, t):
e[1] = 0
rev[1] = 1
return 1
return 0
def flow(self):
flow = 0
while self.bfs():
*self.it, = list(map(iter, self.G))
while self.dfs(0, 1):
flow += 1
return flow
def matching(self):
return [cap for _, cap, _ in self.backwards]
#####################################################################################
N = int(eval(input()))
X = []
Y = []
for i in range(N):
X.append([int(i) for i in input().split()])
for i in range(N):
Y.append([int(i) for i in input().split()])
dinic = Dinic(len(X), len(Y))
for i in range(len(X)):
for j in range(N):
if X[i][0] < Y[j][0] and X[i][1] < Y[j][1]:
dinic.add_edge(i,j)
print((dinic.flow())) | p03409 |
# https://atcoder.jp/contests/abc091/tasks/arc092_a
import sys
input = sys.stdin.readline
from collections import deque
class MaxFlow:
class Edge:
def __init__(self, to, cap, rev):
"""
:param to: 終点ノード
:param cap: 残された容量
:param rev: 遂になる逆向きのエッジ（ノード to の rev 番目のエッジ）
"""
self.to, self.cap, self.rev = to, cap, rev
def __init__(self, node_size, inf):
self._node = node_size
self._inf = inf
self._level = [-1] * self._node
self._iter = [0] * self._node
self._graph = [[] for _ in range(self._node)]
def add_edge(self, from_, to, cap):
self._graph[from_].append(self.Edge(to, cap, len(self._graph[to])))
self._graph[to].append(self.Edge(from_, 0, len(self._graph[from_]) - 1))
def bfs(self, start):
"""
_level: 未訪問の場合は -1, 訪問済みの場合は start からの最短距離（正容量のエッジのみを使った経路の中での）
"""
self._level = [-1] * self._node
next_set = deque()
self._level[start] = 0
next_set.append(start)
while next_set:
cur_vertex = next_set.popleft()
for edge in self._graph[cur_vertex]:
if self._level[edge.to] < 0 < edge.cap:
self._level[edge.to] = self._level[cur_vertex] + 1
next_set.append(edge.to)
def dfs(self, cur_vertex, end_vertex, flow):
if cur_vertex == end_vertex:
return flow
while self._iter[cur_vertex] < len(self._graph[cur_vertex]):
edge = self._graph[cur_vertex][self._iter[cur_vertex]]
if edge.cap > 0 and self._level[cur_vertex] < self._level[edge.to]:
flowed = self.dfs(edge.to, end_vertex, min(flow, edge.cap))
if flowed > 0:
edge.cap -= flowed
self._graph[edge.to][edge.rev].cap += flowed
return flowed
self._iter[cur_vertex] += 1
return 0
def solve(self, source, sink):
flow = 0
while True:
self.bfs(source)
if self._level[sink] < 0:
""" sinkへの最短距離が -1 ⇒ sink にたどり着けない ⇒ 増加路が存在しないため探索終了"""
return flow
self._iter = [0] * self._node
while True:
f = self.dfs(source, sink, self._inf)
if f == 0:
break
flow += f
class Dinic:
def __init__(self, len_X, len_Y):
"""
soursの位置 = 0
sinkの位置 = len_X + len_Y + 1
capacity = 1
の最大フロー問題
"""
self.len_X, self.len_Y = len_X, len_Y
self.mf = MaxFlow(self.len_X + self.len_Y + 2, min(self.len_X, self.len_Y))
for i in range(self.len_X):
""" sours から部分集合Xへの各点に capacity=1 の流れを作る """
self.mf.add_edge(0, i + 1, 1)
for i in range(self.len_Y):
""" 部分集合Yへの各点からsinkへの capacity=1 の流れを作る """
self.mf.add_edge(self.len_X + i + 1, self.len_X + self.len_Y + 1, 1)
def add_edge(self, from_, to):
"""
:param from_: 部分集合Xの頂点 （1,...,len_X）
:param to: 部分集合Yの頂点 （len_X + 1,...,len_X + 1 + len_Y）
"""
self.mf.add_edge(from_ + 1, to + self.len_X + 1, 1)
def solve(self):
return self.mf.solve(0, self.len_X + self.len_Y + 1)
#####################################################################################
N = int(eval(input()))
X = []
Y = []
for i in range(N):
X.append([int(i) for i in input().split()])
for i in range(N):
Y.append([int(i) for i in input().split()])
dinic = Dinic(len(X), len(Y))
for i in range(len(X)):
for j in range(N):
if X[i][0] < Y[j][0] and X[i][1] < Y[j][1]:
dinic.add_edge(i,j)
print((dinic.solve())) | class Dinic:
def __init__(self, len_X, len_Y):
self.len_X, self.len_Y = len_X, len_Y
self.edges = [[] for _ in range(len_X)]
self.matched = [-1] * len_Y
self.visited = set()
def add_edge(self, x, y):
self.edges[x].append(y)
def dfs(self, x):
"""
:param x: X側の未マッチングの頂点の1つ
:param visited: 空のsetを渡す（外部からの呼び出し時）
:return: 増大路が見つかればTrue
"""
for next_x in self.edges[x]:
if next_x in self.visited:
continue
self.visited.add(next_x)
if self.matched[next_x] == -1 or self.dfs(self.matched[next_x]):
self.matched[next_x] = x
return True
return False
def solve(self):
res = 0
for x in range(self.len_X):
self.visited = set()
res += self.dfs(x)
return res
#################################################################################################
N = int(eval(input()))
X = []
Y = []
for i in range(N):
X.append([int(i) for i in input().split()])
for i in range(N):
Y.append([int(i) for i in input().split()])
dinic = Dinic(len(X), len(Y))
for i in range(len(X)):
for j in range(N):
if X[i][0] < Y[j][0] and X[i][1] < Y[j][1]:
dinic.add_edge(i, j)
print((dinic.solve()))
| p03409 |
import os
import sys
from collections import deque
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
N = int(sys.stdin.readline())
AB = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
CD = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
S = N * 2
T = N * 2 + 1
graph = [[] for _ in range(N * 2 + 2)]
for i, (a, b) in enumerate(AB):
for j, (c, d) in enumerate(CD):
if a < c and b < d:
rev = [i, 0]
edge = [j + N, 1, rev]
rev.append(edge)
graph[i].append(edge)
graph[j + N].append(rev)
for i in range(N):
rev = [S, 0]
edge = [i, 1, rev]
rev.append(edge)
graph[S].append(edge)
graph[i].append(rev)
for i in range(N):
rev = [i + N, 0]
edge = [T, 1, rev]
rev.append(edge)
graph[i + N].append(edge)
graph[T].append(rev)
def bfs(s):
# s からの距離
ret = [-1] * len(graph)
ret[s] = 0
que = deque([(s, 0)])
while que:
v, d = que.popleft()
for u, cap, _ in graph[v]:
if ret[u] < 0 and cap > 0:
ret[u] = d + 1
que.append((u, d + 1))
return ret
def dinic(v, t, f, dist, iter):
if v == t:
return f
while iter[v] < len(graph[v]):
edge = graph[v][iter[v]]
to, cap, rev = edge
if dist[v] < dist[to] and cap > 0:
d = dinic(to, t, min(f, cap), dist, iter)
if d > 0:
edge[1] -= d
rev[1] += d
return d
iter[v] += 1
return 0
flow = 0
while True:
dist = bfs(S)
if dist[T] < 0:
break
while True:
f = dinic(S, T, INF, dist, [0] * len(graph))
if f == 0:
break
flow += f
print(flow)
| import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
class Dinic:
def __init__(self, graph=None, residual=None):
"""
:param list of (list of (int, int)) graph: (to, cap) の隣接リスト
:param list of (list of (list of (int|list))) residual: (to, cap, rev) の残余グラフ
"""
assert (graph and not residual) or (not graph and residual)
if graph:
self.graph = self.residual_graph(graph)
else:
self.graph = residual
@staticmethod
def residual_graph(graph):
"""
残余グラフ構築
:param list of (list of (int, int)) graph: (to, cap) の隣接リスト
:rtype: list of (list of (list of (int|list)))
:return: (to, cap, rev) の残余グラフ
"""
ret = [[] for _ in range(len(graph))]
for v in range(len(graph)):
for u, cap in graph[v]:
rev = [v, 0]
edge = [u, cap, rev]
rev.append(edge)
ret[v].append(edge)
ret[u].append(rev)
return ret
def _dist(self, s):
"""
:param int s:
:rtype: list of int
:return: s からの距離。残余グラフ上で到達できない場合は -1
"""
ret = [-1] * len(self.graph)
ret[s] = 0
# PyPy で deque 遅いのでリストで
vd = [(s, 0)]
while vd:
next_vd = []
for v, d in vd:
for u, cap, _ in self.graph[v]:
if ret[u] < 0 < cap:
ret[u] = d + 1
next_vd.append((u, d + 1))
vd = next_vd
return ret
def _dfs(self, s, t, dist, iter, flow=float('inf')):
"""
:param int s:
:param int t:
:param list of int dist:
:param list of int iter:
:param int flow:
"""
if s == t:
return flow
while iter[s] < len(self.graph[s]):
edge = self.graph[s][iter[s]]
to, cap, rev = edge
if dist[s] < dist[to] and cap > 0:
f = self._dfs(to, t, dist, iter, min(flow, cap))
if f > 0:
edge[1] -= f
rev[1] += f
return f
iter[s] += 1
return 0
def maximum_flow(self, from_v, to_v):
"""
:param int from_v:
:param int to_v:
:return: from_v から to_v への最大流
"""
ret = 0
while True:
dist = self._dist(from_v)
if dist[to_v] < 0:
break
iter = [0] * len(self.graph)
while True:
f = self._dfs(from_v, to_v, dist, iter)
if f == 0:
break
ret += f
return ret
N = int(sys.stdin.readline())
AB = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
CD = [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
S = N * 2
T = N * 2 + 1
graph = [[] for _ in range(N * 2 + 2)]
for i, (a, b) in enumerate(AB):
for j, (c, d) in enumerate(CD):
if a < c and b < d:
graph[i].append((j + N, 1))
for i in range(N):
graph[S].append((i, 1))
for i in range(N):
graph[i + N].append((T, 1))
print((Dinic(graph=graph).maximum_flow(S, T)))
| p03409 |
N = int(eval(input()))
R = [tuple([int(x) for x in input().split()]) for _ in range(N)]
B = [tuple([int(x) for x in input().split()]) for _ in range(N)]
xl = [set() for _ in range(2 * N + 1)]
yl = [set() for _ in range(2 * N + 1)]
for b in B:
x, y = b
for i in range(x):
xl[i].add(b)
for j in range(y):
yl[j].add(b)
cands = []
for r in R:
x, y = r
s = xl[x].intersection(yl[y])
cands.append([r, len(s), s])
def f(cands, used, n):
if not cands:
return n
ret = 0
hd, tl = cands[0], cands[1:]
r, _, s = hd
for t in s - used:
u = used.union({t})
ret = max(ret, f(tl, u, n + 1))
ret = max(ret, f(tl, used, n))
return ret
import operator
cands.sort(key=operator.itemgetter(1))
print((f(cands, set(), 0))) | N = int(eval(input()))
R = [[int(x) for x in input().split()] for _ in range(N)]
B = [[int(x) for x in input().split()] for _ in range(N)]
import operator
R.sort(key=operator.itemgetter(1), reverse=True)
B.sort()
ans = 0
for b in B:
xb, yb = b
for r in R:
xr, yr = r
if xr < xb and yr < yb:
ans += 1
R.remove(r)
break
print(ans) | p03409 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
from collections import deque
class Dinic(object):
def __init__(self,n):
self.__n=n
self.__E=[[] for _ in range(n)]
self.__level=None
self.__iter=None
def add_link(self,u,v,w):
self.__E[u].append([v,w,len(self.__E[v])])
self.__E[v].append([u,0,len(self.__E[u])-1])
def __bfs(self,s):
level=[-1]*self.__n
level[s]=0
Q=deque([s])
while(Q):
v=Q.popleft()
for nv,w,rev in self.__E[v]:
if(w>0 and level[nv]<0):
level[nv]=level[v]+1
Q.append(nv)
self.__level=level
def __dfs(self,v,t,flow):
if(v==t): return flow
for i in range(self.__iter[v],len(self.__E[v])):
self.__iter[v]=i
nv,w,rev=self.__E[v][i]
if(w==0 or self.__level[v]>=self.__level[nv]): continue
d=self.__dfs(nv,t,min(flow,w))
if(d==0): continue
self.__E[v][i][1]-=d
self.__E[nv][rev][1]+=d
return d
return 0
def flow(self,s,t):
flow=0
while(True):
self.__bfs(s)
if(self.__level[t]<0): return flow
self.__iter=[0]*self.__n
current_flow=self.__dfs(s,t,INF)
while(current_flow):
flow+=current_flow
current_flow=self.__dfs(s,t,INF)
def resolve():
n=int(eval(input()))
AB=[tuple(map(int,input().split())) for _ in range(n)]
CD=[tuple(map(int,input().split())) for _ in range(n)]
# bipartite の maximum matching で解く
mf=Dinic(2*n+2)
for i in range(n):
mf.add_link(0,i+1,1)
mf.add_link(n+i+1,2*n+1,1)
for i in range(n):
a,b=AB[i]
for j in range(n):
c,d=CD[j]
if(a<c and b<d):
mf.add_link(i+1,n+j+1,1)
print((mf.flow(0,2*n+1)))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
from collections import deque
class HopcroftKarp:
def __init__(self, N0, N1):
self.N0 = N0
self.N1 = N1
self.N = N = 2+N0+N1
self.G = [[] for i in range(N)]
for i in range(N0):
forward = [2+i, 1, None]
forward[2] = backward = [0, 0, forward]
self.G[0].append(forward)
self.G[2+i].append(backward)
self.backwards = bs = []
for i in range(N1):
forward = [1, 1, None]
forward[2] = backward = [2+N0+i, 0, forward]
bs.append(backward)
self.G[2+N0+i].append(forward)
self.G[1].append(backward)
def add_edge(self, fr, to):
#assert 0 <= fr < self.N0
#assert 0 <= to < self.N1
v0 = 2 + fr
v1 = 2 + self.N0 + to
forward = [v1, 1, None]
forward[2] = backward = [v0, 0, forward]
self.G[v0].append(forward)
self.G[v1].append(backward)
def bfs(self):
G = self.G
level = [None]*self.N
deq = deque([0])
level[0] = 0
while deq:
v = deq.popleft()
lv = level[v] + 1
for w, cap, _ in G[v]:
if cap and level[w] is None:
level[w] = lv
deq.append(w)
self.level = level
return level[1] is not None
def dfs(self, v, t):
if v == t:
return 1
level = self.level
for e in self.it[v]:
w, cap, rev = e
if cap and level[v] < level[w] and self.dfs(w, t):
e[1] = 0
rev[1] = 1
return 1
return 0
def flow(self):
flow = 0
G = self.G
bfs = self.bfs; dfs = self.dfs
while bfs():
*self.it, = list(map(iter, G))
while dfs(0, 1):
flow += 1
return flow
def matching(self):
return [cap for _, cap, _ in self.backwards]
def resolve():
n=int(eval(input()))
AB=[tuple(map(int,input().split())) for _ in range(n)]
CD=[tuple(map(int,input().split())) for _ in range(n)]
mm=HopcroftKarp(n,n)
for i in range(n):
a,b=AB[i]
for j in range(n):
c,d=CD[j]
if(a<c and b<d):
mm.add_edge(i,j)
print((mm.flow()))
resolve() | p03409 |
from operator import itemgetter
n = int(eval(input()))
r = [tuple(map(int, input().split())) for i in range(n)]
b = [tuple(map(int, input().split())) for i in range(n)]
r = sorted(r, key=itemgetter(1), reverse=True)
b.sort()
ans = 0
pair = [False]*n
for i in range(n):
for j in range(n):
if b[i][0] > r[j][0] and b[i][1] > r[j][1] and pair[j] == False:
pair[j] = True
ans += 1
break
print(ans)
| from operator import itemgetter
n = int(eval(input()))
r = [tuple(map(int, input().split())) for i in range(n)]
b = [tuple(map(int, input().split())) for i in range(n)]
r = sorted(r, key=itemgetter(1), reverse=True)
b.sort()
pair = [False]*n
for i in range(n):
for j in range(n):
if b[i][0] > r[j][0] and b[i][1] > r[j][1] and pair[j] == False:
pair[j] = True
break
print((sum(pair))) | p03409 |
N = int(eval(input()))
R = [(-1, -1)] * N
for n in range(N):
x, y = list(map(int, input().split()))
R[n] = (x, y)
B = [(-1, -1)] * N
for n in range(N):
x, y = list(map(int, input().split()))
B[n] = (x, y)
B = sorted(B)
R = sorted(R, reverse=True)
ans = 0
for i, b in enumerate(B):
tmp = []
for j, r in enumerate(R):
if r[0] == -1:
continue
if r[0] < b[0] and r[1] < b[1]:
tmp.append((j, r))
if tmp:
tmp = sorted(tmp, key=lambda x: x[1][1], reverse=True)
R[tmp[0][0]] = (-1, -1)
ans += 1
print(ans) | N = int(eval(input()))
R = [tuple(map(int, input().split())) for _ in range(N)]
B = [tuple(map(int, input().split())) for _ in range(N)]
R = sorted(R)
B = sorted(B)
res = 0
for bx, by in B:
idx = -1
tmp = -1
for i, (rx, ry) in enumerate(R):
if rx < bx and ry < by:
if ry >= tmp:
tmp = ry
idx = i
if idx != -1:
R.pop(idx)
res += 1
print(res) | p03409 |
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
from collections import defaultdict
from collections import deque
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n):
return kaijo_memo[n]
if(len(kaijo_memo) == 0):
kaijo_memo.append(1)
while(len(kaijo_memo) <= n):
kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n):
return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0):
gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n):
gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if(n == r):
return 1
if(n < r or r < 0):
return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b:
a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n -1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n:
return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N = I()
R = ILL(N)
B = ILL(N)
class Dinic:
"""Implementation of Dinic's Alogorithm"""
def __init__(self, N):
self.N = N
self.G = [[] for _ in range(N)]
self.level = [0 for _ in range(N)]
self.iter = [0 for _ in range(N)]
def add(self, from_, to, cap):
# to: 行き先, cap: 容量, rev: 反対側の辺
self.G[from_].append({'to':to, 'cap':cap, 'rev':len(self.G[to])})
self.G[to].append({'to':from_, 'cap':0, 'rev':len(self.G[from_])-1})
# sからの最短距離をbfsで計算
def bfs(self, s):
self.level = [-1 for _ in range(self.N)]
self.level[s] = 0;
q = deque([s])
while q:
v = q.popleft()
for i in range(len(self.G[v])):
e = self.G[v][i]
if e['cap'] > 0 and self.level[e['to']] < 0:
self.level[e['to']] = self.level[v] + 1
q.append(e['to'])
# 増加バスをdfsで探す
def dfs(self, v, t, f):
if v == t: return f
for i in range(self.iter[v], len(self.G[v])):
self.iter[v] = i
e = self.G[v][i]
if e['cap'] > 0 and self.level[v] < self.level[e['to']]:
d = self.dfs(e['to'], t, min(INF, e['cap']))
if d > 0:
e['cap'] -= d
self.G[e['to']][e['rev']]['cap'] += d
return d
return 0
def max_flow(self, s, t):
flow = 0
while True:
self.bfs(s)
# bfsで到達不可
if self.level[t] < 0 : return flow
self.iter = [0 for _ in range(self.N)]
f = self.dfs(s,t,INF)
while f > 0:
flow += f
f = self.dfs(s,t,INF)
graph = Dinic(N*2+2)
for i in range(N):
for j in range(N):
if R[i][0] < B[j][0] and R[i][1] < B[j][1]:
graph.add(i,j+N,1)
for i in range(N):
graph.add(2*N,i,1)
graph.add(i+N,2*N+1,1)
print((graph.max_flow(2*N,2*N+1))) | # -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
from collections import defaultdict
from collections import deque
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n):
return kaijo_memo[n]
if(len(kaijo_memo) == 0):
kaijo_memo.append(1)
while(len(kaijo_memo) <= n):
kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n):
return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0):
gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n):
gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if(n == r):
return 1
if(n < r or r < 0):
return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b:
a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n -1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n:
return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N = I()
R = ILL(N)
B = ILL(N)
class Dinic:
def __init__(self, N):
self.N = N
self.G = [[] for _ in range(N)]
self.level = [0 for _ in range(N)]
self.iter = [0 for _ in range(N)]
def add(self, from_, to, cap):
self.G[from_].append({'to':to, 'cap':cap, 'rev':len(self.G[to])})
self.G[to].append({'to':from_, 'cap':0, 'rev':len(self.G[from_])-1})
def bfs(self, s):
self.level = [-1 for _ in range(self.N)]
self.level[s] = 0;
q = deque([s])
while q:
v = q.popleft()
for i in range(len(self.G[v])):
e = self.G[v][i]
if e['cap'] > 0 and self.level[e['to']] < 0:
self.level[e['to']] = self.level[v] + 1
q.append(e['to'])
def dfs(self, v, t, f):
if v == t:
return f
for i in range(self.iter[v], len(self.G[v])):
self.iter[v] = i
e = self.G[v][i]
if e['cap'] > 0 and self.level[v] < self.level[e['to']]:
d = self.dfs(e['to'], t, min(INF, e['cap']))
if d > 0:
e['cap'] -= d
self.G[e['to']][e['rev']]['cap'] += d
return d
return 0
def max_flow(self, s, t):
flow = 0
while True:
self.bfs(s)
if self.level[t] < 0:
return flow
self.iter = [0 for _ in range(self.N)]
f = self.dfs(s,t,INF)
while f > 0:
flow += f
f = self.dfs(s,t,INF)
graph = Dinic(N*2+2)
for i in range(N):
for j in range(N):
if R[i][0] < B[j][0] and R[i][1] < B[j][1]:
graph.add(i,j+N,1)
for i in range(N):
graph.add(2*N,i,1)
graph.add(i+N,2*N+1,1)
print((graph.max_flow(2*N,2*N+1))) | p03409 |
n = int(eval(input()))
AB = list(list(map(int,input().split())) for _ in range(n))
CD = list(list(map(int,input().split())) for _ in range(n))
CD.sort() # sort x in ascending order
AB.sort(key=lambda z: z[1], reverse=True) # sort x in descending order
dim_b = [[] for _ in range(n)]
for b in range(n):
for r in range(n):
if AB[r][0] < CD[b][0] and AB[r][1] < CD[b][1]:
dim_b[b] += [r]
vis_r = [False]*(n)
for b in range(n): # ascending order of x
max_ry = max_r = -1
for r in dim_b[b]: # descending order of y
if vis_r[r]: continue
if max_ry < AB[r][1]: max_ry = AB[r][1]; max_r = r
if max_r >= 0: vis_r[max_r] = True
print((sum(vis_r)))
| n = int(eval(input()))
AB = list(list(map(int,input().split())) for _ in range(n))
CD = list(list(map(int,input().split())) for _ in range(n))
CD.sort() # sort x in ascending order
AB.sort(key=lambda z: z[1], reverse=True) # sort x in descending order
dim_b = [[] for _ in range(n)]
for b in range(n):
for r in range(n):
if AB[r][0] < CD[b][0] and AB[r][1] < CD[b][1]:
dim_b[b] += [r]
vis_r = [False]*(n)
for b in range(n): # ascending order of x
for r in dim_b[b]: # descending order of y
if not vis_r[r]: vis_r[r] = True; break
print((sum(vis_r)))
| p03409 |
N=int(eval(input()))
ab=[list(map(int,input().split())) for _ in range(N)]
cd=[list(map(int,input().split())) for _ in range(N)]
ab=[x[0]+x[1]*1j for x in ab]
cd=[x[0]+x[1]*1j for x in cd]
def comp(a,b):
if a.real<b.real and a.imag<b.imag:
return True
else:
return False
abd=dict()
cdd=dict()
for i in range(len(ab)):
temp=[]
for j in range(len(cd)):
if comp(ab[i],cd[j]):
temp.append(cd[j])
if temp!=[]:
abd[ab[i]]=temp
for i in range(len(cd)):
temp=[]
for j in range(len(ab)):
if comp(ab[j],cd[i]):
temp.append(ab[j])
if temp!=[]:
cdd[cd[i]]=temp
ans=0
while(len(list(abd.keys()))+len(list(cdd.keys()))):
m=10**5
for i in list(abd.keys()):
for j in abd[i]:
cnt=len(abd[i])+len(cdd[j])
if cnt<m:
m=cnt
abm=i
cdm=j
cdl=abd[abm]
abl=cdd[cdm]
for i in abl:
abd[i].remove(cdm)
for i in cdl:
cdd[i].remove(abm)
del abd[abm]
del cdd[cdm]
abk=[i for i in list(abd.keys())]
cdk=[i for i in list(cdd.keys())]
for i in abk:
if abd[i]==[]:
del abd[i]
for i in cdk:
if cdd[i]==[]:
del cdd[i]
ans+=1
print(ans) | N=int(eval(input()))
ab=sorted([list(map(int,input().split())) for _ in [0]*N],key=lambda x:x[1],reverse=True)
cd=sorted([list(map(int,input().split())) for _ in [0]*N],key=lambda x:x[0])
cnt=0
for i in range(N):
for a in ab:
if a[0]<cd[i][0] and a[1]<cd[i][1]:
ab.remove(a)
cnt+=1
break
print(cnt) | p03409 |
def sort_x(a):
min = 100000
min_num = 0
n = len(a)
A=[[0, 0] for i in range(n)]
left_list = [1 for i in range(n)]
for j in range(n):
for i in range(n):
if left_list[i]==1 and int(a[i][0]) < min:
min = int(a[i][0])
min_num = i
left_list[min_num] = 0
A[j] = a[min_num]
min=100000
return A
def sort_y(a):
min = 100000
min_num = 0
n = len(a)
A=[[0, 0] for i in range(n)]
left_list = [1 for i in range(n)]
for j in range(n):
for i in range(n):
if left_list[i]==1 and int(a[i][1]) < min:
min = int(a[i][1])
min_num = i
left_list[min_num] = 0
A[j] = a[min_num]
min=100000
return A
if __name__ == '__main__':
n = int(eval(input()))
a_ = [input().split() for i in range(n)]
c_ = [input().split() for i in range(n)]
a = [[0,0] for i in range(n)]
c = [[0,0] for i in range(n)]
c = sort_x(c_)
a = sort_y(a_)
frend_num = 0
#print(a)
#print(c)
#min = 100000
#min_index = 0
filter_a = [1 for i in range(n)]
for j in range(n):
for i in reversed(list(range(n))):
#print("---")
#print("{} vs {}={}".format(a[i][0], c[j][0], a[i][0]<c[j][0]))
#print("{} vs {}={}".format(a[i][1], c[j][1], a[i][1]<c[j][1]))
if filter_a[i]==1:
if int(a[i][0])<int(c[j][0]):
if int(a[i][1])<int(c[j][1]):
filter_a[i]=0
frend_num += 1
#print("{},{}".format(a,c))
#print("{}".format(filter_a))
#print("friend is detected")
break
print(frend_num)
| def sort_x(a):
min = 100000
min_num = 0
n = len(a)
A=[[0, 0] for i in range(n)]
left_list = [1 for i in range(n)]
for j in range(n):
for i in range(n):
if left_list[i]==1 and int(a[i][0]) < min:
min = int(a[i][0])
min_num = i
left_list[min_num] = 0
A[j] = a[min_num]
min=100000
return A
def sort_y(a):
min = 100000
min_num = 0
n = len(a)
A=[[0, 0] for i in range(n)]
left_list = [1 for i in range(n)]
for j in range(n):
for i in range(n):
if left_list[i]==1 and int(a[i][1]) < min:
min = int(a[i][1])
min_num = i
left_list[min_num] = 0
A[j] = a[min_num]
min=100000
return A
if __name__ == '__main__':
n = int(eval(input()))
a_ = [input().split() for i in range(n)]
c_ = [input().split() for i in range(n)]
a = [[0,0] for i in range(n)]
c = [[0,0] for i in range(n)]
c = sort_x(c_)
a = sort_y(a_)
frend_num = 0
#print(a)
#print(c)
#min = 100000
#min_index = 0
filter_a = [1 for i in range(n)]
for j in range(n):
for i in reversed(list(range(n))):
if filter_a[i]==1:
if int(a[i][0])<int(c[j][0]) and int(a[i][1])<int(c[j][1]):
filter_a[i]=0
frend_num += 1
#print("{},{}".format(a,c))
#print("{}".format(filter_a))
#print("friend is detected")
break
print(frend_num)
| p03409 |
casen=0
if casen==0:
a=[]
c=[]
n=int(eval(input()))
for i in range(n):
ai,bi=list(map(int,input().split()))
a.append([ai,bi])
for i in range(n):
ci,di=list(map(int,input().split()))
c.append([ci,di])
elif casen==1:
n=3
a=[[2,0],[3,1],[1,3]]
c=[[4,2],[0,4],[5,5]]
elif casen==2:
n=3
a=[[0,0],[1,1],[5,2]]
c=[[2,3],[3,4],[4,5]]
elif casen==3:
n=2
a=[[2,2],[3,3]]
c=[[0,0],[1,1]]
elif casen==4:
n=5
a=[[0,0],[7,3],[2,2],[4,8],[1,6]]
c=[[8,5],[6,9],[5,4],[9,1],[3,7]]
elif casen==5:
n=5
a=[[0,0],[1,1],[5,5],[6,6],[7,7]]
c=[[2,2],[3,3],[4,4],[8,8],[9,9]]
t=[]
for ia in range(n):
s=set()
for ic in range(n):
if a[ia][0]<c[ic][0] and a[ia][1]<c[ic][1]:
s.add(ic)
t.append(s)
icnt=0
from collections import deque
tyn3 = deque()
def pcnt(icnt,ia,t,n,tyn3,icntmax,r,t2,it):
ia1=ia
if ia>=n-1:
icnt2=len(r)
icntmax=max(icnt2,icntmax)
if len(tyn3)>0:
it2=tyn3.pop()
r.remove(it2)
ia=ia-1
return icntmax,ia
t3=t[ia]-r
r1=r.copy()
for it in t3:
ia=ia1+1
t2=t[ia]
r1.add(it)
tyn3.append(it)
icntmax,ia=pcnt(icnt,ia,t,n,tyn3,icntmax,r1,t2,it)
ia=ia+1
t2=t[ia]
icntmax,ia=pcnt(icnt,ia,t,n,tyn3,icntmax,r,t2,it)
return icntmax,ia
ia=-1
icntmax=0
r=set()
t2=t[0]
it=0
icntmax,ia=pcnt(icnt,ia,t,n,tyn3,icntmax,r,t2,it)
print(icntmax)
| casen=0
if casen==0:
a=[]
c=[]
n=int(eval(input()))
for i in range(n):
ai,bi=list(map(int,input().split()))
a.append([ai,bi])
for i in range(n):
ci,di=list(map(int,input().split()))
c.append([ci,di])
elif casen==1:
n=3
a=[[2,0],[3,1],[1,3]]
c=[[4,2],[0,4],[5,5]]
elif casen==2:
n=3
a=[[0,0],[1,1],[5,2]]
c=[[2,3],[3,4],[4,5]]
elif casen==3:
n=2
a=[[2,2],[3,3]]
c=[[0,0],[1,1]]
elif casen==4:
n=5
a=[[0,0],[7,3],[2,2],[4,8],[1,6]]
c=[[8,5],[6,9],[5,4],[9,1],[3,7]]
elif casen==5:
n=5
a=[[0,0],[1,1],[5,5],[6,6],[7,7]]
c=[[2,2],[3,3],[4,4],[8,8],[9,9]]
c.sort()
a.sort(key=lambda x:x[1])
#a.reverse()
icnt=0
ic2=0
for ic in range(len(c)):
for ia in range(len(a)-1,-1,-1):
if a[ia][0]<c[ic][0] and a[ia][1]<c[ic][1]:
icnt=icnt+1
del a[ia]
break
else:
continue
break
print(icnt) | p03409 |
casen=0
if casen==0:
a=[]
c=[]
n=int(eval(input()))
for i in range(n):
ai,bi=list(map(int,input().split()))
a.append([ai,bi])
for i in range(n):
ci,di=list(map(int,input().split()))
c.append([ci,di])
elif casen==1:
n=3
a=[[2,0],[3,1],[1,3]]
c=[[4,2],[0,4],[5,5]]
elif casen==2:
n=3
a=[[0,0],[1,1],[5,2]]
c=[[2,3],[3,4],[4,5]]
elif casen==3:
n=2
a=[[2,2],[3,3]]
c=[[0,0],[1,1]]
elif casen==4:
n=5
a=[[0,0],[7,3],[2,2],[4,8],[1,6]]
c=[[8,5],[6,9],[5,4],[9,1],[3,7]]
elif casen==5:
n=5
a=[[0,0],[1,1],[5,5],[6,6],[7,7]]
c=[[2,2],[3,3],[4,4],[8,8],[9,9]]
c.sort()
a.sort(key=lambda x:x[1])
#a.reverse()
icnt=0
ic2=0
for ic in range(len(c)):
for ia in range(len(a)-1,-1,-1):
if a[ia][0]<c[ic][0] and a[ia][1]<c[ic][1]:
icnt=icnt+1
del a[ia]
break
else:
continue
break
print(icnt) |
n=int(eval(input()))
r=[[0]*3 for i in range(n)]
b=[[0]*2 for i in range(n)]
for i in range(n):
r[i]=list(map(int,input().split()))+[0]
for i in range(n):
b[i]=list(map(int,input().split()))
r.sort(key=lambda x:x[1],reverse=True)
b.sort()
psum=0
for i in range(n):
for ii in range(n):
# print("b:",i,b[i][0],b[i][1],"r:",ii,r[ii][0],r[ii][1])
if b[i][0]>r[ii][0] and b[i][1]>r[ii][1] and r[ii][2]==0:
r[ii][2]=1
psum+=1
break
print(psum)
| p03409 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
def A():
return
#B
def B():
return
#C
def C():
def bfs(s,g,n):
bfs_map = [-1 for i in range(n)]
bfs_map[s] = 0
q = deque()
q.append(s)
fin = False
while q:
x = q.popleft()
for y in range(n):
if c[x][y] > 0 and bfs_map[y] < 0:
bfs_map[y] = bfs_map[x]+1
if y == g:
fin = True
break
q.append(y)
if fin:
break
if bfs_map[g] == -1:
return [None,0]
path = [None for i in range(bfs_map[g]+1)]
m = float("inf")
path[bfs_map[g]] = g
y = g
for i in range(bfs_map[g])[::-1]:
for x in range(n+1):
if c[x][y] > 0 and bfs_map[x] == bfs_map[y]-1:
path[i] = x
if c[x][y] < m:
m = c[x][y]
y = x
break
return [path,m]
def ford_fulkerson(s,g,c,n):
while 1:
p,m = bfs(s,g,n)
if not m:break
for i in range(len(p)-1):
c[p[i]][p[i+1]] -= m
c[p[i+1]][p[i]] += m
return sum(c[g])
n = I()
r = LIR(n)
b = LIR(n)
c = [[0 for i in range(2*n+2)] for i in range(2*n+2)]
for i in range(n):
c[0][i+1] = 1
for j in range(n):
if r[i][0] < b[j][0] and r[i][1] < b[j][1]:
c[i+1][n+j+1] = 1
for j in range(n):
c[n+j+1][2*n+1] = 1
print((ford_fulkerson(0,2*n+1,c,2*n+2)))
#D
def D():
n = I()
a = LI()
b = LI()
ans = 0
p = 1
for k in range(30):
s = 0
c = [b[i]%(p*2) for i in range(n)]
a_ = [a[i]%(p*2) for i in range(n)]
c.sort()
a_.sort()
l1,l2,l3 = 0,0,0
y = float("inf")
for x in a_[::-1]:
if x != y:
while l1 < n and c[l1] < p-x:l1 += 1
while l2 < n and c[l2] < 2*p-x:l2 += 1
while l3 < n and c[l3] < 3*p-x:l3 += 1
s += n-l2-l1-l3
y = x
ans += (s%2)*p
p *= 2
print(ans)
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
C()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
p = LIR(n)
q = LIR(n)
s = [(p[i][0],p[i][1],0) for i in range(n)]+[(q[i][0],q[i][1],1) for i in range(n)]
s.sort()
q = []
ans = 0
for x,y,i in s:
if not i:
q.append(y)
q.sort()
else:
j = bisect.bisect_left(q,y)-1
if j >= 0:
q.pop(j)
ans += 1
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| p03409 |
# -*- coding: utf-8 -*-
"""
参考：https://www.hamayanhamayan.com/entry/2018/03/18/085108
http://vartkw.hatenablog.com/entry/2016/12/02/002703
https://ikatakos.com/pot/programming_algorithm/graph_theory/maximum_flow
・二部最大マッチング
・最大流アルゴリズム(Dinic法)
・まだ理解不十分な点はあると思うけど、初めて見た時よりは見慣れた。
"""
from collections import deque
class BipartiteMatching:
def __init__(self, n, m):
self.n = n
self.m = m
# ペアとして有りうる相手を格納する
self.E = [[] * (n+m+2) for i in range(n+m+2)]
# 決まったペアを格納する
self.match = [0] * (n+m+2)
# 距離(付け替え候補を決める時の深さみたいなものが入ってる)
self.dist = [0] * (n+m+2)
def bfs(self):
que = deque()
for i in range(1, self.n+1):
# マッチングの決まっていないノードをキューに詰める
if not self.match[i]:
self.dist[i] = 0
que.append(i)
else:
self.dist[i] = float('inf')
self.dist[0] = float('inf')
while len(que) != 0:
u = que.popleft()
if u != 0:
for v in self.E[u]:
if self.dist[self.match[v]] == float('inf'):
self.dist[self.match[v]] = self.dist[u] + 1
# 付け替えの候補になりうるノードがここで追加されていく
que.append(self.match[v])
# フローを流せるエッジが存在しなければ、dist[0]がINFのまま(Falseを返して終了)
return self.dist[0] != float('inf')
def dfs(self, u):
if u != 0:
for v in self.E[u]:
if self.dist[self.match[v]] == self.dist[u] + 1:
if self.dfs(self.match[v]):
# ペア確定(あとで変わることもある)
self.match[v] = u
self.match[u] = v
return True
# 今回決められなかったノード
self.dist[u] = float('inf')
return False
return True
def add(self, a, b):
b += self.n
self.E[a+1].append(b+1)
self.E[b+1].append(a+1)
def whois(self, x):
return self.match[x+1]-1
def solve(self):
for i in range(self.n+self.m+1):
self.match[i] = 0
res = 0
while self.bfs():
for i in range(1, self.n+1):
# 前から順に繋げる所は繋いでいって、
# もっといいのがあれば後から付け替える
if not self.match[i] and self.dfs(i):
res += 1
return res
N = int(eval(input()))
aN, bN, cN, dN = [0] * N, [0] * N, [0] * N, [0] * N
# 赤い点
for i in range(N):
aN[i], bN[i] = list(map(int, input().split()))
# 青い点
for i in range(N):
cN[i], dN[i] = list(map(int, input().split()))
# (赤い点の数, 青い点の数)
bm = BipartiteMatching(N, N)
for i in range(N):
for j in range(N):
if aN[i] < cN[j] and bN[i] < dN[j]:
# ペア候補として適切な組を追加していく(0-indexed)
bm.add(i, j)
print((bm.solve()))
| # -*- coding: utf-8 -*-
"""
参考：https://ikatakos.com/pot/programming_algorithm/graph_theory/bipartite_matching
・二部最大マッチング
"""
class BipartiteMatching:
"""
XとYの二部グラフの最大マッチング X={0,1,2,...|X|-1} Y={0,1,2,...,|Y|-1}
edges[x]: xとつながるYの頂点のset
match1[x]: xとマッチングされたYの頂点
match2[y]: yとマッチングされたXの頂点
"""
def __init__(self, n, m):
self.n = n
self.m = m
self.edges = [set() for _ in range(n)]
self.match1 = [-1] * n
self.match2 = [-1] * m
def dfs(self, v, visited):
"""
:param v: X側の未マッチングの頂点の1つ
:param visited: 空のsetを渡す（外部からの呼び出し時）
:return: 増大路が見つかればTrue
"""
for u in self.edges[v]:
if u in visited:
continue
visited.add(u)
if self.match2[u] == -1 or self.dfs(self.match2[u], visited):
self.match2[u] = v
self.match1[v] = u
return True
return False
def add(self, a, b):
self.edges[a].add(b)
def whois1(self, a):
""" :param: グループ1の頂点 :return: ペアになるグループ2の頂点 """
return self.match1[a]
def whois2(self, a):
""" :param: グループ2の頂点 :return: ペアになるグループ1の頂点 """
return self.match2[a]
def solve(self):
# 増大路発見に成功したらTrue(=1)。合計することでマッチング数となる
return sum(self.dfs(i, set()) for i in range(self.n))
N = int(eval(input()))
aN, bN, cN, dN = [0] * N, [0] * N, [0] * N, [0] * N
# 赤い点
for i in range(N):
aN[i], bN[i] = list(map(int, input().split()))
# 青い点
for i in range(N):
cN[i], dN[i] = list(map(int, input().split()))
# (赤い点の数, 青い点の数)
bm = BipartiteMatching(N, N)
for i in range(N):
for j in range(N):
if aN[i] < cN[j] and bN[i] < dN[j]:
# ペア候補として適切な組を追加していく(0-indexed)
bm.add(i, j)
print((bm.solve()))
| p03409 |
from collections import defaultdict
n=int(eval(input()))
ab=[[int(i) for i in input().split()] for j in range(n)]
cd=[[int(i) for i in input().split()] for j in range(n)]
ab.sort()
cd.sort()
ans=0
for i in cd:
check=-1
pair=[-1,-1]
for j in ab:
if j[0]>i[0]:
break
if check<j[1]<i[1]:
check=j[1]
pair=j
if pair != [-1,-1]:
ans+=1
ab.remove(pair)
print(ans)
| import bisect
n=int(eval(input()))
ab=[[int(i) for i in input().split()] for j in range(n)]
cd=[[int(i) for i in input().split()] for j in range(n)]
ab.sort()
cd.sort()
ans=0
for c,d in cd:
now_y=-1
check=False
for a,b in ab:
if a>=c:
break
if b<d and b>now_y:
now_id=bisect.bisect_left(ab,[a,b])
now_y=b
check=True
if check:
ans+=1
ab.pop(now_id)
print(ans)
| p03409 |
n = int(eval(input()))
red_list = []
blue_list = []
for i in range(n):
x, y = list(map(int, input().split()))
red_list.append([x, y])
for i in range(n):
x, y = list(map(int, input().split()))
blue_list.append([x, y])
#2. search
#2.1 red:descending order in y
red_list.sort(key=lambda x:(x[1], x[0]), reverse=True)
#2.2 blue: ascending order
blue_list.sort(key=lambda x:(x[0], x[1]), reverse=False)
#2.3 search a blue point such as [x_r, y_r] < [x_b, y_b]
ans = 0
for red in red_list:
for blue in blue_list:
if (red[0]<blue[0]) and (red[1]<blue[1]):
blue_list.remove(blue)
ans += 1
break
#3. print the result
print(ans) | N = int(eval(input()))
R = []
B = []
for i in range(N):
R.append(list(map(int, input().split())))
for i in range(N):
B.append(list(map(int, input().split())))
R.sort(key=lambda x:x[0], reverse=True)
B.sort(key=lambda x:x[1], reverse=False)
ans = 0
for r in R:
for b in B:
if r[0]<b[0] and r[1]<b[1]:
ans += 1
B.remove(b)
break
print(ans) | p03409 |
from itertools import permutations
N = int(eval(input()))
rn = [list(map(int,input().split())) for _ in range(N)]
bn = [list(map(int,input().split())) for _ in range(N)]
ans = 0
for p in permutations(list(range(N))):
ans = max(ans, sum([1 if rn[i][0] < bn[p[i]][0] and rn[i][1] < bn[p[i]][1] else 0 for i in range(N)]))
print(ans)
| N = int(eval(input()))
rn = [[True]+list(map(int,input().split())) for _ in range(N)]
bn = sorted([list(map(int,input().split())) for _ in range(N)])
rn.sort(key=lambda x: -x[2])
for bp in bn:
bx,by = bp
for rp in rn:
f,rx,ry = rp
if f and rx<bx and ry<by:
rp[0] = False
break
print((sum([0 if rp[0] else 1 for rp in rn])))
| p03409 |
n = int(eval(input()))
red = []
for i in range(n):
red.append(list(map(int, input().split())))
blue = []
for i in range(n):
blue.append(list(map(int, input().split())))
red_sort = sorted(red, key=lambda x: x[1], reverse=True)
blue_sort = sorted(blue)
count = 0
flag = [0]*n
for b in blue_sort:
for i,r in enumerate(red_sort):
if r[0] < b[0] and r[1] < b[1] and flag[i] == 0:
count += 1
flag[i] = 1
break
print(count) | n = int(eval(input()))
red = []
blue = []
for i in range(n):
a,b = list(map(int,input().split()))
red.append((a,b))
for i in range(n):
c,d = list(map(int,input().split()))
blue.append((c,d))
red_sorted = sorted(red,reverse=True)
blue_sorted = sorted(blue,key=lambda x: x[1])
count = 0
check = []
for i in red_sorted:
for j,k in enumerate(blue_sorted):
if (i[0] < k[0]) and (i[1] < k[1]):
blue_sorted.pop(j)
count += 1
break
print(count) | p03409 |
N = int(eval(input()))
X = []
Y = []
for i in range(N):
a, b = list(map(int, input().split()))
X.append((a, b))
for i in range(N):
c, d = list(map(int, input().split()))
Y.append((c, d))
X.sort(key=lambda x: -x[1])
Y.sort(key=lambda x: x[0])
B = []
result = 0
for x in range(N):
red = list(map(int, X[x]))
for y in range(N):
blue = list(map(int, Y[y]))
if y in B:
continue
if red[0] < blue[0] and red[1] < blue[1]:
result += 1
B.append(y)
break
print(result) |
N = int(eval(input()))
RED = []
BLUE = []
for i in range(N):
a, b = list(map(int, input().split()))
RED.append((a, b))
for i in range(N):
a, b = list(map(int, input().split()))
BLUE.append((a, b))
BLUE.sort(key=lambda x: x[0])
RED.sort(key=lambda x: -x[1])
red_selected = set()
blue_selected = set()
for i in range(N):
c, d = BLUE[i]
for j in range(N):
a, b = RED[j]
if a < c and b < d and j not in red_selected and i not in blue_selected:
red_selected.add(j)
blue_selected.add(i)
print((len(red_selected))) | p03409 |
n = int(eval(input()))
red_li = [list(map(int, input().split())) for _ in range(n)]
blue_li = [list(map(int, input().split())) for _ in range(n)]
ans = 0
red_li.sort(reverse = True, key = lambda x : (x[0], x[1]))
blue_li.sort( key = lambda x : (x[0], x[1]))
def count(red, blue):
used_red = []
used_blue = []
for i in red:
if i in used_red:
continue
for j in blue:
if j in used_blue:
continue
if i[0] < j[0] and i[1] < j[1]:
used_red.append(i)
used_blue.append(j)
break
return len(used_red)
ans = count(red_li, blue_li)
red_li.sort(reverse = True,key = lambda x : (x[1], x[0]))
blue_li.sort( key = lambda x : (x[1], x[0]))
ans = max(ans, count(red_li, blue_li))
red_li.sort(reverse = True,key = lambda x : (x[1], x[0]))
blue_li.sort( key = lambda x : (x[0], x[1]))
ans = max(ans, count(red_li, blue_li))
red_li.sort(reverse = True,key = lambda x : (x[0], x[1]))
blue_li.sort( key = lambda x : (x[1], x[0]))
ans = max(ans, count(red_li, blue_li))
print(ans) | n = int(eval(input()))
red_li = [list(map(int, input().split())) for _ in range(n)]
blue_li = [list(map(int, input().split())) for _ in range(n)]
ans = 0
red_li.sort(reverse = True, key = lambda x : (x[0], x[1]))
blue_li.sort( key = lambda x : (x[0], x[1]))
def count(red, blue):
used_red = []
used_blue = []
for i in red:
if i in used_red:
continue
for j in blue:
if j in used_blue:
continue
if i[0] < j[0] and i[1] < j[1]:
used_red.append(i)
used_blue.append(j)
break
return len(used_red)
red_li.sort(reverse = True,key = lambda x : (x[0], x[1]))
blue_li.sort( key = lambda x : (x[1], x[0]))
ans = max(ans, count(red_li, blue_li))
print(ans) | p03409 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))
'''
N = ii()
A = li2(N)
B = li2(N)
A = sorted(A, key=lambda x:x[0])
B = sorted(B, key=lambda x:x[0])
a_ind = 0
b_ind = 0
cnt = 0
while b_ind < N:
if A[a_ind][0] < B[b_ind][0] and A[a_ind][1] < B[b_ind][1]:
cnt += 1
a_ind += 1
b_ind += 1
else:
b_ind += 1
print(cnt)
'''
'''
#global ans
ans = 0
def dfs(a_ind, b_ind, cnt):
if a_ind >= N or b_ind >= N:
global ans
ans = max(ans, cnt)
return
if A[a_ind][0] < B[b_ind][0] and A[a_ind][1] < B[b_ind][1]:
dfs(a_ind+1, b_ind+1, cnt+1)
else:
dfs(a_ind+1, b_ind, cnt)
dfs(a_ind, b_ind+1, cnt)
dfs(a_ind+1, b_ind+1, cnt)
dfs(0, 0, 0)
print(ans)
'''
# XとYの二部グラフの最大マッチング X={0,1,2,...|X|-1} Y={0,1,2,...,|Y|-1}
# edges[x]: xとつながるYの頂点のset
# matched[y]: yとマッチングされたXの頂点(暫定)
def dfs(v, visited):
"""
:param v: X側の未マッチングの頂点の1つ
:param visited: 空のsetを渡す（外部からの呼び出し時）
:return: 増大路が見つかればTrue
"""
for u in edges[v]:
if u in visited:
continue
visited.add(u)
if matched[u] == -1 or dfs(matched[u], visited):
matched[u] = v
return True
return False
# 標準入力からのグラフ読み取り
#xn, yn, e = map(int, input().split())
N = ii()
xn = N
yn = N
edges = [set() for _ in range(xn)]
matched = [-1] * yn
#for _ in range(e):
#x, y = map(int, input().split())
#edges[x].add(y)
A = li2(N)
B = li2(N)
for i in range(N):
for j in range(N):
if A[i][0] < B[j][0] and A[i][1] < B[j][1]:
edges[i].add(j)
# 増大路発見に成功したらTrue(=1)。合計することでマッチング数となる
print((sum(dfs(s, set()) for s in range(xn)))) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))
N = ii()
A = li2(N)
B = li2(N)
A = sorted(A, key=lambda x:x[1])
B = sorted(B, key=lambda x:x[0])
flag = [0] * N
for i in range(N):
ind = -1
for j in range(N):
if A[j][1] < B[i][1]:
ind = j
while ind >= 0:
if not flag[ind] and A[ind][0] < B[i][0]:
flag[ind] = 1
break
ind -= 1
#print(flag)
print((sum(flag))) | p03409 |
# coding:utf-8
import sys
import random
# from collections import Counter, defaultdict
INF = float('inf')
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return eval(input())
def main():
n = II()
red = [[a + b, a, b] for a, b in (LI() for _ in range(n))]
blue = [[a + b, a, b] for a, b in (LI() for _ in range(n))]
ans = 0
red.sort()
for _ in range(n):
red = red[-1:] + red[:-1]
used = [0] * n
res = 0
for s, a, b in red:
near = -1
d = INF
for i, (ss, x, y) in enumerate(blue):
if a < x and b < y:
tmp = x - a + y - b
if tmp < d and not used[i]:
near = i
d = tmp
if near != -1:
used[near] = 1
res += 1
ans = max(ans, res)
red.reverse()
for _ in range(n):
red = red[-1:] + red[:-1]
used = [0] * n
res = 0
for s, a, b in red:
near = -1
d = INF
for i, (ss, x, y) in enumerate(blue):
if a < x and b < y:
tmp = x - a + y - b
if tmp < d and not used[i]:
near = i
d = tmp
if near != -1:
used[near] = 1
res += 1
ans = max(ans, res)
for _ in range(20):
random.shuffle(red)
for _ in range(n):
red = red[-1:] + red[:-1]
used = [0] * n
res = 0
for s, a, b in red:
near = -1
d = INF
for i, (ss, x, y) in enumerate(blue):
if a < x and b < y:
tmp = x - a + y - b
if tmp < d and not used[i]:
near = i
d = tmp
if near != -1:
used[near] = 1
res += 1
ans = max(ans, res)
return ans
print((main()))
| # coding:utf-8
import sys
import random
# from collections import Counter, defaultdict
INF = float('inf')
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return eval(input())
def main():
n = II()
red = [LI() for _ in range(n)]
blue = [LI() for _ in range(n)]
blue.sort()
used = [0] * n
res = 0
for a, b in blue:
t = -1
k = -1
for i, (x, y) in enumerate(red):
if used[i]:
continue
if x < a and b > y > t:
t = y
k = i
if k != -1:
used[k] = 1
res += 1
return res
print((main()))
| p03409 |
N = int(eval(input()))
AB = [list(map(int,input().split())) for i in range(N)]
CD = [list(map(int,input().split())) for i in range(N)]
AB.sort()
CD.sort()
#print(AB)
#print(CD)
ans = 0
for i in range(N-1,-1,-1):
ab = AB[i]
li = []
for cd in CD:
if ab[0] < cd[0] and ab[1] < cd[1]:
li.append(cd)
li.sort(key=lambda x: x[1])
if len(li) != 0:
CD.remove(li[0])
ans += 1
print(ans)
| N = int(eval(input()))
AB = [tuple(map(int,input().split())) for i in range(N)]
CD = [tuple(map(int,input().split())) for i in range(N)]
AB.sort(key=lambda x: x[0])
CD.sort(key=lambda x: x[0])
ans = 0
for c,d in CD:
idx = 10000
for i in range(N):
if AB[i] == -1:
continue
if c < AB[i][0]:
break
if AB[i][1] < d:
if idx == 10000:
idx = i
elif AB[idx][1] < AB[i][1]:
idx = i
if idx != 10000:
ans += 1
AB[idx] = -1
print(ans) | p03409 |
N = int(eval(input()))
ps = [tuple(map(int,input().split())) for i in range(2*N)]
es = [[] for i in range(2*N)]
for ri,(rx,ry) in enumerate(ps[:N]):
for bi,(bx,by) in enumerate(ps[N:]):
bi += N
if rx < bx and ry < by:
es[ri].append(bi)
es[bi].append(ri)
used = [False] * (2*N)
match = [-1] * (2*N)
def _dfs(v):
global used, match
used[v] = True
for u in es[v]:
w = match[u]
if w < 0 or not used[w] and _dfs(w):
match[v] = u
match[u] = v
return True
return False
def bipartite_matching():
global used, match
ret = 0
for v in range(2*N):
if match[v] < 0:
used = [False] * (2*N)
if _dfs(v):
ret += 1
return ret
print((bipartite_matching()))
| N = int(eval(input()))
src = [tuple(map(int,input().split())) for i in range(2*N)]
es = [[] for i in range(2*N)]
for i,(x1,y1) in enumerate(src[:N]):
for j,(x2,y2) in enumerate(src[N:]):
if x1 < x2 and y1 < y2:
es[i].append(j+N)
es[j+N].append(i)
used = [False] * (2*N)
match = [-1] * (2*N)
def _dfs(v):
global used, match
used[v] = True
for u in es[v]:
w = match[u]
if w < 0 or not used[w] and _dfs(w):
match[v] = u
match[u] = v
return True
return False
def bipartite_matching():
global used, match
ret = 0
for v in range(2*N):
if match[v] < 0:
used = [False] * (2*N)
if _dfs(v):
ret += 1
return ret
print((bipartite_matching())) | p03409 |
from operator import itemgetter
def main():
N = int(eval(input()))
ab = [tuple(int(j) for j in input().split()) for i in range(N)]
cd = [tuple(int(j) for j in input().split()) for i in range(N)]
# y 降順
ab.sort(key=itemgetter(1), reverse=True)
# x 昇順
cd.sort(key=itemgetter(0))
ans = 0
for bx, by in cd:
for rx, ry in ab:
if rx < bx and ry < by:
ab.remove((rx, ry))
ans += 1
break
print(ans)
return
main()
| from operator import itemgetter
def main():
N = int(eval(input()))
ab = [tuple(int(j) for j in input().split()) for i in range(N)]
cd = [tuple(int(j) for j in input().split()) for i in range(N)]
# y 降順
ab.sort(key=itemgetter(1), reverse=True)
# x 昇順
cd.sort()
# ペアになった赤
done = [False] * N
for bx, by in cd:
for k, ((rx, ry), d) in enumerate(zip(ab, done)):
if not d and rx < bx and ry < by:
done[k] = True
break
print((sum(done)))
return
main()
| p03409 |
def main():
N = int(eval(input()))
ab = [tuple(int(j) for j in input().split()) for i in range(N)]
cd = [tuple(int(j) for j in input().split()) for i in range(N)]
# y 降順
ab.sort(key=lambda x:x[1], reverse=True)
# x 昇順
cd.sort()
# ペアになった赤
done = [False] * N
for bx, by in cd:
for k, ((rx, ry), d) in enumerate(zip(ab, done)):
if not d and rx < bx and ry < by:
done[k] = True
break
print((sum(done)))
return
main()
| def main():
N = int(eval(input()))
ab = [tuple(int(j) for j in input().split()) for i in range(N)]
cd = [tuple(int(j) for j in input().split()) for i in range(N)]
# y 降順
ab.sort(key=lambda x:x[1], reverse=True)
# x 昇順
cd.sort()
ans = 0
for bx, by in cd:
for rx, ry in ab:
if rx < bx and ry < by:
ab.remove((rx, ry))
ans += 1
break
print(ans)
return
main()
| p03409 |
from operator import itemgetter
def main():
N = int(eval(input()))
ab = [tuple(int(j) for j in input().split()) for i in range(N)]
cd = [tuple(int(j) for j in input().split()) for i in range(N)]
# y 降順
ab.sort(key=itemgetter(1), reverse=True)
# x 昇順
cd.sort()
ans = 0
for bx, by in cd:
for rx, ry in ab:
if rx < bx and ry < by:
ab.remove((rx, ry))
ans += 1
break
print(ans)
return
main()
| def main():
N = int(eval(input()))
ab = [tuple(int(j) for j in input().split()) for i in range(N)]
cd = [tuple(int(j) for j in input().split()) for i in range(N)]
# x 降順
ab.sort(key=lambda x: x[0], reverse=True)
# y 昇順
cd.sort(key=lambda x: x[1])
ans = 0
for bx, by in cd:
for rx, ry in ab:
if rx < bx and ry < by:
ab.remove((rx, ry))
ans += 1
break
print(ans)
return
main()
| p03409 |
n = int(eval(input()))
a = [list(map(int, input().split())) for i in range(n)]
b = [list(map(int, input().split())) for i in range(n)]
a.sort(reverse=True)
b.sort()
idxb = list()
for i in range(n):
idx = -1
maxy = -1
for j in range(n):
if not j in idxb:
if a[j][0] < b[i][0] and maxy < a[j][1] < b[i][1] :
maxy = a[j][1]
idx = j
if idx != -1:
idxb.append(idx)
print((len(idxb)))
| n = int(eval(input()))
a = [list(map(int, input().split())) for i in range(n)]
b = [list(map(int, input().split())) for i in range(n)]
a.sort(reverse=True)
b.sort()
idxb = list()
for i in range(n):
idx = -1
miny = 1e+9
for j in range(n):
if not j in idxb:
if a[i][0] < b[j][0] and a[i][1] < b[j][1] < miny:
miny = b[j][1]
idx = j
if idx != -1:
idxb.append(idx)
print((len(idxb)))
| p03409 |
n = int(eval(input()))
reds = []
for i in range(n):
reds.append(tuple(map(int, input().split())))
reds = sorted(reds, key=lambda tup: tup[1], reverse=True)
#print(reds)
blues = []
for i in range(n):
blues.append(tuple(map(int, input().split())))
#print(blues)
blues = sorted(blues, key=lambda tup: tup[0])
#print(blues)
count = 0
for b in blues:
tmp = []
# print(len(reds))
for i in range(len(reds)):
r = reds[i]
if b[0] > r[0] and b[1] > r[1]:
tmp.append(i)
break
if len(tmp) > 0:
del reds[tmp[0]]
count += 1
print(count)
| n = int(eval(input()))
reds = []
for i in range(n):
reds.append(tuple(map(int, input().split())))
reds = sorted(reds, key=lambda tup: tup[1], reverse=True)
blues = []
for i in range(n):
blues.append(tuple(map(int, input().split())))
blues = sorted(blues, key=lambda tup: tup[0])
count = 0
for b in blues:
paired = None
for i in range(len(reds)):
r = reds[i]
if b[0] > r[0] and b[1] > r[1]:
paired = i
break
if paired is not None:
del reds[paired]
count += 1
print(count)
| p03409 |
aa=[]
a=int(eval(input()))
for i in range(0,a):
aa.append(input().split(" "))
bb=[]
for j in range(0,a):
bb.append(input().split(" "))
pattern=[]
zentai=[]
chouhuku=0
for m in range(0,a**a):
for n in range(0,a):
pattern.append(m//(a**n)%a)
for w in range(0,a):
if pattern.count(pattern[w])>=2:
chouhuku=1
if chouhuku==0:
zentai.append(pattern)
pattern=[]
chouhuku=0
score=0
max=0
for ww in zentai:
for z in range(0,a):
if aa[z][0]<bb[int(ww[z])][0] and aa[z][1]<bb[int(ww[z])][1]:
score=score+1
if max<=score:
max=score
score=0
print(max)
| #解答確認後
n=int(eval(input()))
aa=[[int(i) for i in input().split()] for i in range(n)]
bb=[[int(i) for i in input().split()] for i in range(n)]
#print(aa)
#print(bb)
import operator
aa.sort(key=operator.itemgetter(1),reverse=True)
bb.sort()
#print(aa)
#print(bb)
answer=0
for b in bb:
xb,yb=b
for a in aa:
xa,ya=a
if xa<xb and ya<yb:
answer=answer+1
aa. remove (a)
#print(aa)
#print(bb)
#print(answer)
break
print(answer)
| p03409 |
N = int(eval(input()))
Blue = []
Red = []
for i in range(N) :
a,b = list(map(int,input().split()))
Red.append([a,b])
for i in range(N) :
c,d = list(map(int,input().split()))
Blue.append([c,d])
Blue = sorted(Blue)
Red = list(reversed(sorted(Red,key=lambda x: x[1])))
ans = 0
for i in range(N) :
for j in range(N) :
if j >= len(Red) :
break
if (Blue[i][0] > Red[j][0]) and (Blue[i][1] > Red[j][1]) :
ans += 1
Red.pop(j)
break
print(ans)
| N = int(eval(input()))
red = [list(map(int,input().split())) for i in range(N)]
blue = [list(map(int,input().split())) for i in range(N)]
red = sorted(red, key=lambda x: x[1], reverse=True)
blue = sorted(blue, key=lambda x: x[0], reverse=False)
flg = [0 for i in range(N)]
ans = 0
for i in range(N) :
c,d = blue[i]
for j in range(N) :
if flg[j] :
continue
a,b = red[j]
if (a < c) and (b < d) :
ans += 1
flg[j] = 1
break
print(ans)
| p03409 |
N = int(eval(input()))
red = []
blue = []
for i in range(N):
in1, in2 = list(map(int,input().split()))
red.append([in1, in2])
for i in range(N):
in1, in2 = list(map(int,input().split()))
blue.append([in1, in2])
red = sorted(red, key=lambda x: x[0])[::-1]
ans = 0
INF = 10 ** 9 + 7
for i in range(N):
min_ = INF
ind = -1
for j in range(N):
if red[i][0] <= blue[j][0] and red[i][1] <= blue[j][1] and blue[j][1] < min_:
ind = j
min_ = blue[j][1]
if ind != -1:
blue[ind][0] = -1
ans += 1
print(ans) | N = int(eval(input()))
red = sorted([list(map(int,input().split())) for i in range(N)], key=lambda x: x[0])[::-1]
blue = [list(map(int,input().split())) for i in range(N)]
ans = 0
for i in range(N):
min_ = 10 ** 9 + 7
ind = -1
for j in range(N):
if red[i][0] <= blue[j][0] and red[i][1] <= blue[j][1] and blue[j][1] < min_:
ind = j
min_ = blue[j][1]
if ind != -1:
blue[ind][0] = -1
ans += 1
print(ans) | p03409 |
N = int(eval(input()))
red = sorted([list(map(int,input().split())) for _ in range(N)], key = lambda x:-x[1])
blue = sorted([list(map(int,input().split())) for _ in range(N)])
ans = 0
for b in blue:
for r in red:
if(r[0] < b[0] and r[1] < b[1]):
ans += 1
red.remove(r)
break
print(ans) | N = int(eval(input()))
AB = sorted([list(map(int,input().split())) for _ in range(N)], key = lambda x: -x[1])
CD = sorted([list(map(int,input().split())) for _ in range(N)])
cnt = 0
for c, d in CD:
for a, b in AB:
if(a < c and b < d):
cnt += 1
AB.remove([a,b])
break
print(cnt) | p03409 |
def ans():
N = int(eval(input()))
AB = sorted([list(map(int,input().split())) for _ in range(N)], key = lambda x: -x[1])
CD = sorted([list(map(int,input().split())) for _ in range(N)])
cnt = 0
for c, d in CD:
for a, b in AB:
if(a < c and b < d):
cnt += 1
AB.remove([a,b])
break
print(cnt)
ans() | N = int(eval(input()))
AB = sorted([list(map(int,input().split())) for _ in range(N)], key = lambda x: -x[1])
CD = sorted([list(map(int,input().split())) for _ in range(N)])
cnt = 0
for c, d in CD:
for a, b in AB:
if(a < c and b < d):
cnt += 1
AB.remove([a, b])
break
print(cnt) | p03409 |
from operator import itemgetter
n=int(eval(input()))
A=[tuple(map(int,input().split())) for i in range(n)]
B=[tuple(map(int,input().split())) for j in range(n)]
A.sort()
B.sort()
count=0
for i in range(n):
box=[A[j] for j in range(len(A)) if (A[j][0]<B[i][0]) and (A[j][1]<B[i][1])]
#条件を満たす一番大きいものから消していく
if any(box):
box=sorted(box, key=itemgetter(1))
A.remove(box[-1])
count +=1
print(count) | N=int(eval(input()))
AB=sorted([list(map(int,input().split())) for _ in range(N)])
CD=sorted([list(map(int,input().split())) for _ in range(N)], key=lambda x:x[1])
cnt=0
for a,b in AB[::-1]:
for i,j in enumerate(CD):
c,d=j
if a<c and b<d:
cnt +=1
del CD[i]
break
print(cnt) | p03409 |
#https://abc010.contest.atcoder.jp/tasks/abc010_4
#http://kmjp.hatenablog.jp/entry/2014/06/08/0900
#よくわからない最大フロー用のdfs---------------------------------
num=201 #今回のnの最大値100*2+1
def dfs(cur):
global vis
global EE
vis[cur] = 1
if cur==num:
return 1
for i in range(num+1):
if vis[i]==0 and EE[cur][i]>0 and dfs(i) > 0:
EE[cur][i] -= 1
EE[i][cur] += 1
return 1
return 0
#------------------------------------------------------------------------------------
#今回の問題分（インプット～隣接リストの作成）------------------
n=int(eval(input()))
s=[]
ss=[]
for i in range(n):
s.append([int(i) for i in input().split()])
for i in range(n):
ss.append([int(i) for i in input().split()])
s.sort(key=lambda x:(x[0],x[1]))
ss.sort(key=lambda x:(x[0],x[1]))
pair=[]
for i in range(len(s)):
right=[]
for j in range(n):
if s[j][0]<ss[i][0] and s[j][1]<ss[i][1]:
right.append(j)
pair.append(right)
pair.sort(key=lambda x:len(x))
#print(pair)
#------------------------------------------------------------------------------------
#BFSにぶち込む用のグラフ作成------------------------------------------
EE = [[0 for x in range(num+1)] for y in range(num+11)]
vis = [0] * (num+1)
for i in range(len(pair)): #1から最大100 始点s（番号0）から青い点への辺
EE[0][i+1] = 1
EE[i+1][0] = 1
for i in range(n): #101から最大200 赤い点から終点t（番号201）への辺
EE[i+101][num] = 1
for i in range(len(pair)): #青い点（番号1～100に振り直し）から 赤い点（番号101～200）への辺
for j in range(len(pair[i])):
node1, node2 = i+1,pair[i][j]+101
# EE[node1][node2] = EE[node2][node1] = 1 なんでこれダメなんだろう
EE[node1][node2] = 1
#風呂～～-----------------------------------------------------------------------
flow=0
while 1:
for i in range(0, num+1):
vis[i] = 0
if dfs(0) == 0:
break
flow += 1
print (flow)
#------------------------------------------------------------------------------------
| #https://abc010.contest.atcoder.jp/tasks/abc010_4
#http://kmjp.hatenablog.jp/entry/2014/06/08/0900
#よくわからない最大フロー用のdfs---------------------------------
num=201 #今回のnの最大値100*2+1
def dfs(cur):
global vis
global EE
vis[cur] = 1
if cur==num:
return 1
for i in range(num+1):
if vis[i]==0 and EE[cur][i]>0 and dfs(i) > 0:
EE[cur][i] -= 1
EE[i][cur] += 1
return 1
return 0
#--------------------------------------------------------------
#今回の問題分（インプット～隣接リストの作成）------------------
n=int(eval(input()))
s=[]
ss=[]
for i in range(n):
s.append([int(i) for i in input().split()])
for i in range(n):
ss.append([int(i) for i in input().split()])
#s.sort(key=lambda x:(x[0],x[1]))
#ss.sort(key=lambda x:(x[0],x[1]))
pair=[]
for i in range(len(s)):
right=[]
for j in range(n):
if s[j][0]<ss[i][0] and s[j][1]<ss[i][1]:
right.append(j)
pair.append(right)
#pair.sort(key=lambda x:len(x))
#print(pair)
#------------------------------------------------------------
#BFSにぶち込む用のグラフ作成---------------------------------
EE = [[0 for x in range(num+1)] for y in range(num+11)]
vis = [0] * (num+1)
for i in range(len(pair)): #1から最大100 始点s（番号0）から青い点への辺
EE[0][i+1] = 1
EE[i+1][0] = 1
for i in range(n): #101から最大200 赤い点から終点t（番号201）への辺
EE[i+101][num] = 1
for i in range(len(pair)): #青い点（番号1～100に振り直し）から 赤い点（番号101～200）への辺
for j in range(len(pair[i])):
node1, node2 = i+1,pair[i][j]+101
# EE[node1][node2] = EE[node2][node1] = 1 なんでこれダメなんだろう
EE[node1][node2] = 1
#風呂～～--------------------------------------------------
flow=0
while 1:
for i in range(0, num+1):
vis[i] = 0
if dfs(0) == 0:
break
flow += 1
print (flow)
#----------------------------------------------------------
| p03409 |
import itertools
n = int(eval(input()))
red = [tuple(map(int, input().split())) for _ in range(n)]
blue = [tuple(map(int, input().split())) for _ in range(n)]
agg = [list() for _ in range(n)]
for i in range(n):
c, d = blue[i]
for j in range(n):
a, b = red[j]
if c > a and d > b:
agg[i].append(j)
prod = itertools.product(*[x for x in agg if len(x) > 0])
res = 0
for p in prod:
res = max(res, len(set(p)))
print(res) | n = int(eval(input()))
red = sorted([tuple(map(int, input().split())) for _ in range(n)])
blue = sorted([tuple(map(int, input().split())) for _ in range(n)])
res = 0
for bx, by in blue:
tmp_max = -1
tmp_cnt = None
for i, (rx, ry) in enumerate(red):
if bx <= rx:
break
if tmp_max <= ry < by:
tmp_max = ry
tmp_cnt = i
if tmp_cnt is not None:
res += 1
red.pop(tmp_cnt)
print(res) | p03409 |
def c_2D_plane_2N_points(N, R, B):
red = sorted(R) # 赤い点の座標(x座標で昇順ソート)
blue = sorted(B) # 青い点の座標(x座標で昇順ソート)
ans = 0
for c, d in blue:
# 注目している青い点より"左下"にある赤い点の座標のリスト
r = [z for z in red if z[0] < c and z[1] < d]
if r: # 左下に赤い点があれば
r.sort(key=lambda x: x[1]) # y座標で昇順ソート
# 後の青い点のことを考えると、"より左下"にある赤い点を残したほうがよい。
# x座標でソートしていることを考えると、なるべくy座標が小さな赤い点を
# あとに残すほうがよい。(y座標が大きな赤い点を先にペアにする)
red.remove(r[-1]) # r[-1]が指す赤い点とペアにする。もう選べないので削除
ans += 1
return ans
N = int(eval(input()))
R = [[int(i) for i in input().split()] for j in range(N)]
B = [[int(i) for i in input().split()] for j in range(N)]
print((c_2D_plane_2N_points(N, R, B))) | def c_2d_plane_2n_points():
N = int(eval(input()))
R = [tuple([int(i) for i in input().split()]) for j in range(N)]
B = [tuple([int(i) for i in input().split()]) for j in range(N)]
red = sorted(R, key=lambda x: x[1], reverse=True) # 赤い点の座標 (y 座標で降順ソート)
blue = sorted(B) # 青い点の座標 (x 座標で昇順ソート)
ans = 0
for x_b, y_b in blue:
for x_r, y_r in red:
# 注目している青い点より xy 平面で左下にある赤い点のうち、
# 最も右上にある点とマッチさせるのが最適
if x_b > x_r and y_b > y_r:
ans += 1
red.remove((x_r, y_r)) # もう選べないので削除
break # この青い点ももう選べないので終了
return ans
print((c_2d_plane_2n_points())) | p03409 |
n = int(eval(input()))
ab = sorted([[int(i) for i in input().split()] for i in range(n)], reverse = True, key = lambda x: x[1])
cd = sorted([[int(i) for i in input().split()] for i in range(n)])
count = 0
for i in range(n):
for j in range(len(cd)):
if ab[i][0] < cd[j][0] and ab[i][1] < cd[j][1]:
count += 1
del cd[j]
break
print(count) | n = int(eval(input()))
AB = sorted([[int(i) for i in input().split()] for i in range(n)], reverse = True)
CD = sorted([[int(i) for i in input().split()] for i in range(n)], key = lambda x: x[1])
cnt = 0
for a, b in AB:
for cd in CD:
if a < cd[0] and b < cd[1]:
cnt += 1
CD.remove(cd)
break
print((n - len(CD))) | p03409 |
n = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
q = int(eval(input()))
m = list(map(int, input().split()))
def f(A, s, res):
if res[0]:
return
if s == 0:
res[0] = True
return
for i, a in enumerate(A):
if a > s:
break
f(A[i+1:], s-a, res)
for mi in m:
res = [False]
f(A, mi, res)
if res[0]:
print("yes")
else:
print("no") | n = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
sumA = sum(A)
q = int(eval(input()))
m = list(map(int, input().split()))
def f(A, s, res):
if res[0]:
return
if s == 0:
res[0] = True
return
for i, a in enumerate(A):
if a > s:
break
f(A[i+1:], s-a, res)
for mi in m:
res = [False]
if mi <= sumA:
f(A, mi, res)
if res[0]:
print("yes")
else:
print("no") | p02271 |
n = int(eval(input()))
a = list(map(int,input().split()))
q = int(eval(input()))
m = list(map(int,input().split()))
def solve(i, m_i):
if m_i == 0:
return True
if i >= n:
return False
res = solve(i + 1, m_i) or solve(i + 1, m_i - a[i])
return res
for m_tmp in m:
if solve(0, m_tmp):
print("yes")
else:
print("no") | n = int(eval(input()))
a = list(map(int,input().split()))
q = int(eval(input()))
m = list(map(int,input().split()))
def solve(i, m_i):
if m_i == 0:
return True
if i >= n:
return False
res = solve(i + 1, m_i) or solve(i + 1, m_i - a[i])
return res
for m_tmp in m:
if sum(a) < m_tmp:
print("no")
elif solve(0, m_tmp):
print("yes")
else:
print("no") | p02271 |
# -*- coding: utf_8 -*-
from itertools import repeat
from itertools import combinations
def rec(s, i, total, m):
if total == m:
return 1
if len(s) == i or total > m:
return 0
return rec(s, i + 1, total, m) + rec(s, i + 1, total + s[i], m)
def loop(s, m):
for i in range(len(s)):
comb = list(combinations(s, i))
for c in comb:
if sum(c) == m:
return 1
return 0
if __name__ == "__main__":
n = int(input())
a = [int (x) for x in input().split()]
q = int(input())
m = [int (x) for x in input().split()]
for i in m:
#print("yes") if rec(a, 0, 0, i) > 0 else print("no")
print("yes") if loop(a, i) > 0 else print("no")
| # -*- coding: utf_8 -*-
from itertools import repeat
from itertools import combinations
def rec(s, i, total, m):
if total == m:
return 1
if len(s) == i or total > m:
return 0
return rec(s, i + 1, total, m) + rec(s, i + 1, total + s[i], m)
def makeCache(s):
cache = {}
for i in range(len(s)):
comb = list(combinations(s, i))
for c in comb:
cache[sum(c)] = 1
return cache
def loop(s, m):
for i in range(len(s)):
comb = list(combinations(s, i))
for c in comb:
if sum(c) == m:
return 1
return 0
if __name__ == "__main__":
n = int(input())
a = [int (x) for x in input().split()]
q = int(input())
m = [int (x) for x in input().split()]
s = makeCache(a)
for i in m:
#print("yes") if rec(a, 0, 0, i) > 0 else print("no")
#print("yes") if loop(a, i) > 0 else print("no")
print("yes") if i in s else print("no")
| p02271 |
n = eval(input())
A = list(map( int , input().split() ))
q = eval(input())
mi = list(map( int , input().split() ))
def solve(i, m):
if m == 0:
return True
elif i >= n:
return False
else:
res = solve( i+1 , m ) | solve( i+1 , m-A[i] )
return res
for m in mi:
if solve( 0 , m ): print("yes")
else: print("no")
| n = eval(input())
A = list(map( int , input().split() ))
q = eval(input())
mi = list(map( int , input().split() ))
def solve(i, m):
if m == 0:
return True
elif i >= n or m > sum(A):
return False
res = solve( i+1 , m ) or solve( i+1 , m-A[i] )
return res
for m in mi:
if solve( 0 , m ): print("yes")
else: print("no") | p02271 |
# coding=utf-8
def solve_recursively(candidate_numbers, target_number):
"""classify if the target number is represented a summation of elements of candidate_numbers
Args:
candidate_numbers: candidate_numbers
target_number: target_number
Returns:
if target number is represented a summation of elements of candidate_numbers(book)
"""
if target_number == 0:
return True
elif len(candidate_numbers) == 0:
return False
solution = solve_recursively(candidate_numbers[1:], target_number - candidate_numbers[0]) or solve_recursively(
candidate_numbers[1:], target_number)
return solution
def main():
input() # pass length
candidate_numbers = [int(x) for x in input().strip().split(' ')]
input() # pass length
target_numbers = [int(x) for x in input().strip().split(' ')]
for target_number in target_numbers:
if solve_recursively(candidate_numbers, target_number):
print("yes")
else:
print("no")
if __name__ == "__main__":
main() | # -*- coding: utf-8 -*-
def check_solvable_recursively(number, is_solvable, candidate_numbers):
"""exhaustively search representable as summation of numbers in candidate_numbers
Args:
number: representable number
is_solvable: is solvable list
candidate_numbers: candidate numbers to be used
Returns:
None
"""
is_solvable[number] = True
if candidate_numbers:
check_solvable_recursively(number + candidate_numbers[0], is_solvable, candidate_numbers[1:])
check_solvable_recursively(number, is_solvable, candidate_numbers[1:])
else:
pass
def main():
input() # pass length
candidate_numbers = [int(x) for x in input().strip().split(' ')]
input() # pass length
target_number_list = [int(x) for x in input().strip().split(' ')]
is_solvable_list = [False] * 2001
check_solvable_recursively(0, is_solvable_list, candidate_numbers)
for target_number in target_number_list:
if is_solvable_list[target_number]:
print("yes")
else:
print("no")
if __name__ == "__main__":
main() | p02271 |
# -*- coding: utf-8 -*-
def check_solvable_recursively(number, is_solvable, candidate_numbers):
"""exhaustively search representable as summation of numbers in candidate_numbers
Args:
number: representable number
is_solvable: is solvable list
candidate_numbers: candidate numbers to be used
Returns:
None
"""
is_solvable[number] = True
if candidate_numbers:
check_solvable_recursively(number + candidate_numbers[0], is_solvable, candidate_numbers[1:])
check_solvable_recursively(number, is_solvable, candidate_numbers[1:])
else:
pass
def main():
input() # pass length
candidate_numbers = [int(x) for x in input().strip().split(' ')]
input() # pass length
target_number_list = [int(x) for x in input().strip().split(' ')]
is_solvable_list = [False] * 2001
check_solvable_recursively(0, is_solvable_list, candidate_numbers)
for target_number in target_number_list:
if is_solvable_list[target_number]:
print("yes")
else:
print("no")
if __name__ == "__main__":
main() | # -*- coding: utf-8 -*-
def check_solvable_recursively(number, is_solvable, candidate_numbers):
"""exhaustively search representable as summation of numbers in candidate_numbers
Args:
number: representable number
is_solvable: is solvable list
candidate_numbers: candidate numbers to be used
Returns:
None
"""
if not is_solvable[number]:
is_solvable[number] = True
if candidate_numbers:
check_solvable_recursively(number + candidate_numbers[0], is_solvable, candidate_numbers[1:])
check_solvable_recursively(number, is_solvable, candidate_numbers[1:])
def main():
input() # pass length
candidate_numbers = [int(x) for x in input().strip().split(' ')]
input() # pass length
target_number_list = [int(x) for x in input().strip().split(' ')]
is_solvable_list = [False] * 2001
check_solvable_recursively(0, is_solvable_list, candidate_numbers)
for target_number in target_number_list:
if is_solvable_list[target_number]:
print("yes")
else:
print("no")
if __name__ == "__main__":
main() | p02271 |
def solve(p, t):
if p >= len(A): return False
if t == A[p]: return True
if t <= 0: return False
#print("({}, {})".format(p, t))
if solve(p + 1, t):
return True
else:
return solve(p + 1, t - A[p])
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
M = list(map(int, input().split()))
for t in M:
if solve(0, t): print("yes")
else: print("no") | memo = {}
def solve(p, t):
key = "{}:{}".format(p, t)
if key in memo: return memo[key]
if p >= len(A): return False
if t == A[p]: return True
if t <= 0: return False
#print("({}, {})".format(p, t))
if solve(p + 1, t):
memo["{}:{}".format(p + 1, t)] = True
return True
else:
memo["{}:{}".format(p + 1, t)] = False
return solve(p + 1, t - A[p])
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
M = list(map(int, input().split()))
for t in M:
if solve(0, t): print("yes")
else: print("no") | p02271 |
def solve(i, m):
if m == 0:
return True
if i == n:
return False
return solve(i+1, m) or solve(i+1, m-A[i])
if __name__ == "__main__":
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
M = list(map(int, input().split()))
for m in M:
if solve(0, m):
print("yes")
else:
print("no") | import itertools
def rev(x):
return sumA - x
if __name__ == "__main__":
n = int(eval(input()))
A = list(map(int, input().split()))
q = int(eval(input()))
M = list(map(int, input().split()))
sumA = sum(A)
all_sum = set()
for i in range((n+1)//2):
com = set(itertools.combinations(A, i+1))
com_sum = set(map(sum, com))
com_sum_rev = set(map(rev, com_sum))
all_sum = all_sum.union(com_sum)
all_sum = all_sum.union(com_sum_rev)
for m in M:
if m in all_sum:
print("yes")
else:
print("no") | p02271 |
n1 = int(input())
A = list(map(int, input().split()))
n2 = int(input())
q = list(map(int, input().split()))
B = []
n = n1
ans = list("no" for i in range(n2))
for i in range(2 ** n):
C0 = []
B = list(map(int, format(i, "b").zfill(n)))[::-1]
C0 = [ x*y for x, y in zip(A, B)]
C = sum(C0)
for j, r in enumerate(q):
if C == r:
ans[j] = "yes"
print(*ans, sep="\n")
| n1 = int(input())
A = list(map(int, input().split()))
n2 = int(input())
q = list(map(int, input().split()))
B = []
C = []
n = n1
ans = list("no" for i in range(n2))
for i in range(2 ** n):
C0 = []
B = list(map(int, format(i, "b").zfill(n)))[::-1]
C0 = [ x*y for x, y in zip(A, B)]
C.append(sum(C0))
for j, r in enumerate(q):
if r in C:
ans[j] = "yes"
print(*ans, sep="\n")
| p02271 |
n = int(eval(input()))
A = list(map(int, input().split() ))
q = int(eval(input()))
m = list(map(int, input().split()))
def solve(i, m):
if m == 0:
return True
elif i >= n:
return False
else:
return solve(i+1, m) or solve(i+1, m - A[i])
for num in m:
print(('yes' if solve(0, num) else 'no'))
| # used DP
n = int(eval(input()))
A = list(map(int, input().split() ))
q = int(eval(input()))
M = list(map(int, input().split()))
dp = [[None]*(max(M)+1) for i in range(n)]
# we refer to the list dp only when i = 0, 1, ... , n-1 and m >= 0.
def solve(i, m):
if i >= n:
return m == 0
elif m < 0:
return False
elif dp[i][m] is not None:
return dp[i][m]
else:
if m == 0:
dp[i][m] = True
elif solve(i+1, m):
dp[i][m] = True
elif solve(i+1, m - A[i]):
dp[i][m] = True
else:
dp[i][m] = False
return dp[i][m]
for num in M:
print(('yes' if solve(0, num) else 'no'))
| p02271 |
n = int(input())
A = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
def solve(i, m):
if m == 0:
return 1
if i >= n:
return 0
res = solve(i + 1, m) or solve(i + 1, m - A[i])
return res
for j in range(0, q):
if solve(0, m[j]):
print("yes")
else:
print("no") | n = int(input())
A = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
def solve(i, m):
if m == 0:
return 1
if i >= n or m > sum(A):
return 0
res = solve(i + 1, m) or solve(i + 1, m - A[i])
return res
for j in range(0, q):
if solve(0, m[j]):
print("yes")
else:
print("no") | p02271 |
# -*- coding: utf-8 -*-
def func(i, m):
if m == 0:
return True
elif m < 0 or i >= len(A):
return False
else:
if func(i+1, m-A[i]):
return True
if func(i+1, m):
return True
return False
n = int(input())
A = list(map(int, input().split()))
q = int(input())
M = list(map(int, input().split()))
for i in range(q):
if func(0, M[i]):
print("yes")
else:
print("no") | # -*- coding: utf-8 -*-
n = int(input())
A = {0}
for c in input().split():
for i in A.copy():
A.add(i+int(c))
q = int(input())
M = list(map(int, input().split()))
for m in M:
if m in A:
print("yes")
else:
print("no") | p02271 |
class Tree:
class Node:
def __init__(self, n, left, right):
self.left = left
self.right = right
self.n = n
if left is not None:
lt = {t + n for t in left.totals}
else:
lt = set()
if right is not None:
rt = right.totals
else:
rt = set()
self.totals = lt | rt | {n}
def find(self, total):
return total in self.totals
def __str__(self):
cs = []
if self.left is not None:
cs.append(str(self.left))
if self.right is not None:
cs.append(str(self.right))
return "{} -> ({})".format(self.n, ",".join(cs))
def __init__(self, ns):
self.top = self.build_nodes(sorted(ns))
def has_subset(self, total):
return self.top.find(total)
def build_nodes(self, ns):
if len(ns) == 0:
return None
left = self.build_nodes(ns[:-1])
right = self.build_nodes(ns[:-1])
node = self.Node(ns[-1], left, right)
return node
def run_tree():
_ = int(eval(input())) # flake8: noqa
ns = [int(i) for i in input().split()]
tree = Tree(ns)
_ = int(eval(input())) # flake8: noqa
for q in (int(j) for j in input().split()):
if tree.has_subset(q):
print("yes")
else:
print("no")
if __name__ == '__main__':
run_tree()
| def create_sums(ns):
if len(ns) == 0:
return set()
s = create_sums(ns[1:])
return {e + ns[0] for e in s} | s | {ns[0]}
def run_set():
_ = int(eval(input())) # flake8: noqa
ns = [int(i) for i in input().split()]
sums = create_sums(ns)
_ = int(eval(input())) # flake8: noqa
for q in (int(j) for j in input().split()):
if q in sums:
print("yes")
else:
print("no")
if __name__ == '__main__':
run_set()
| p02271 |
def solve(i, m):
if m == 0: return True
if i == n or m < 0:
return False
r1 = solve(i + 1, m)
r2 = solve(i + 1, m - A[i])
return r1 or r2
n = int(input())
A = list(map(int, input().split()))
q = int(input())
M = list(map(int, input().split()))
for i in M:
print("yes" if solve(0, i) else "no") | def solve(i, m):
if m == 0: return True
if i < n and min(A[i:]) <= m <= sum(A[i:]):
r1 = solve(i + 1, m-A[i])
if r1: return r1
r2 = solve(i + 1, m)
if r2: return r2
n = int(input())
A = list(map(int, input().split()))
q = int(input())
M = list(map(int, input().split()))
for i in M:
print("yes" if solve(0, i) else "no") | p02271 |
import sys
import itertools
def can_be_composed(n, m, A):
for i in range(1, n + 1):
combination_list = list(itertools.combinations(A, i))
for l in combination_list:
if m == sum(l):
return True
return False
#fin = open("test.txt", "r")
fin = sys.stdin
n = int(fin.readline())
A = list(map(int, fin.readline().split()))
q = int(fin.readline())
m_list = list(map(int, fin.readline().split()))
for m in m_list:
if can_be_composed(n, m, A):
print("yes")
else:
print("no") | import sys
import itertools
def can_be_composed(n, min_list, max_list, m, A):
for i in range(1, n + 1):
if m < min_list[i - 1]:
continue
if m > max_list[i - 1]:
continue
combination_list = list(itertools.combinations(A, i))
for l in combination_list:
if m == sum(l):
return True
return False
#fin = open("test.txt", "r")
fin = sys.stdin
n = int(fin.readline())
A = list(map(int, fin.readline().split()))
A.sort()
q = int(fin.readline())
m_list = list(map(int, fin.readline().split()))
min_list = [0]
min_list[0] += A[0]
for i in range(1, n):
min_list.append(min_list[i - 1] + A[i])
max_list = [0]
max_list[0] += A[n - 1]
for i in range(1, n):
max_list.append(max_list[i - 1] + A[n - i - 1])
for m in m_list:
if can_be_composed(n, min_list, max_list, m, A):
print("yes")
else:
print("no") | p02271 |
n=int(eval(input()))
A=list(map(int,input().split()))
r=set()
def f(s,k):
if k>=0:
global r
r.add(s)
f(s+A[k-1],k-1)
f(s,k-1)
f(0,n)
eval(input())
for e in map(int,input().split()):print((['no','yes'][e in r]))
| eval(input())
s = {0}
for a in map(int,input().split()):
for b in list(s):
s.add(a+b)
eval(input())
for e in map(int,input().split()):
print(('yes' if e in s else 'no'))
| p02271 |
# -*- coding: utf-8 -*-
"""
全探索
・再帰で作る
"""
N = int(eval(input()))
aN = list(map(int, input().split()))
Q = int(eval(input()))
mQ = list(map(int, input().split()))
def dfs(cur, depth, ans):
# 終了条件
if cur == ans:
return True
# 全探索
for i in range(depth, N):
if dfs(cur+aN[i], i+1, ans):
return True
# 見つからなかった
return False
for i in range(Q):
if dfs(0, 0, mQ[i]):
print('yes')
else:
print('no')
| # -*- coding: utf-8 -*-
"""
全探索
・再帰で作る
・2^20でTLEするからメモ化した
"""
N = int(eval(input()))
aN = list(map(int, input().split()))
Q = int(eval(input()))
mQ = list(map(int, input().split()))
def dfs(cur, depth, ans):
# 終了条件
if cur == ans:
return True
# memo[現在位置]に数値curがあれば、そこから先はやっても同じだからやらない
if cur in memo[depth]:
return False
memo[depth].add(cur)
# 全探索
for i in range(depth, N):
if dfs(cur+aN[i], i+1, ans):
return True
# 見つからなかった
return False
for i in range(Q):
memo = [set() for j in range(N+1)]
if dfs(0, 0, mQ[i]):
print('yes')
else:
print('no')
| p02271 |
num_n = eval(input())
N = list(map(int, input().split()))
num_m = eval(input())
M = list(map(int, input().split()))
def solve(i, m):
if m == 0:
return True
if i >= num_n or m > sum(M):
return False
res = solve(i + 1, m) or solve(i + 1,m - N[i])
return res
for m in M:
if solve(0, m):
print("yes")
else:
print("no") | num_n = int(eval(input()))
n = list(map(int, input().split()))
num_m = int(eval(input()))
m = list(map(int, input().split()))
def solve(i, m):
if m == 0:
return True
if i >= num_n or m > sum(n):
return False
res = solve(i + 1, m) or solve(i + 1,m - n[i])
return res
for k in range(num_m):
if solve(0, m[k]):
print("yes")
else:
print("no") | p02271 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
????????????
?????? n ?????°??? A ??¨??´??° m ???????????????A ???????´?????????????????????????????´?????¶????????????????
m ???????????????????????????????????????????????°????????????????????????????????????
AA ??????????´???????????????????????????¨?????§????????????
??°??? A ??????????????????????????§???????????¨?????? q ?????? mi ????????????????????§???
???????????????????????? "yes" ????????? "no" ??¨???????????????????????????
n ??? 20 ; q ??? 200 ; 1 ??? A???????´? ??? 2000 ; 1 ??? Mi ??? 2000
"""
def kenzan(m, n, A):
if m < A[0]:
return -1
# ?????????????????§????????°???????????£????????????
total = 0
nA = []
for i in range(n):
if A[i] == m:
return 0
# print("{} m:{} x:{} total:{}".format(nA,m,A[i], total))
if A[i] > m:
break
nA.append(A[i])
total += A[i]
if m > total:
return -1
n =len(nA)
l = 2 ** n
for i in range(1,l):
c = 0
bi = "{0:0<{width}b}".format(i,width=n)
bi = bi[::-1]
# print("{0:2}[{1}] m[{2:4}] {3}".format(i, bi,m, n))
for j in range(n):
# print("\tj:{} bi:{} Aj[{:4}]".format(j, bi[j], A[j]))
if bi[j] == "1":
x = c + nA[j]
# print("\tm[{:4}] c+Aj[{:4}] c[{:4}] j:{} Aj[{:4}]".format(m, x, c, j, A[j]))
if x == m:
return 0
elif x > m:
# print("BAD")
break
else:
c = x
return -1
def main():
""" ????????? """
n = int(eval(input()))
A = sorted(map(int,input().split()))
q = int(eval(input()))
M = list(map(int,input().split()))
for i in range(q):
if kenzan(M[i], n, A) == 0:
print("yes")
else:
print("no")
if __name__ == '__main__':
main() | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
????????????
?????? n ?????°??? A ??¨??´??° m ???????????????A ???????´?????????????????????????????´?????¶????????????????
m ???????????????????????????????????????????????°????????????????????????????????????
AA ??????????´???????????????????????????¨?????§????????????
??°??? A ??????????????????????????§???????????¨?????? q ?????? mi ????????????????????§???
???????????????????????? "yes" ????????? "no" ??¨???????????????????????????
n ??? 20 ; q ??? 200 ; 1 ??? A???????´? ??? 2000 ; 1 ??? Mi ??? 2000
"""
def main():
""" ????????? """
n = int(eval(input()))
A = sorted(map(int,input().split()))
q = int(eval(input()))
M = list(map(int,input().split()))
g = 0
tA = []
l = 2 ** n
for i in range(1,l):
c = 0
bi = "{0:0{width}b}".format(i,width=n)
bi = bi[::-1]
for j in range(n):
if bi[j] == "1":
c += A[j]
tA.append(c)
# tA.sort()
for mi in M:
if mi in tA:
print("yes")
else:
print("no")
if __name__ == '__main__':
main() | p02271 |
# -*- coding: utf-8 -*-
"""
Created on Wed May 2 21:28:06 2018
ALDS1_5a
@author: maezawa
"""
import itertools as itr
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
m = list(map(int, input().split()))
sum_array = []
for r in range(1,n+1):
for comb in itr.combinations(a, r):
sum_array.append(sum(comb))
for i in m:
yesorno = 'no'
for j in sum_array:
#print(i, j)
if i == j:
yesorno = 'yes'
break
print(yesorno)
| # -*- coding: utf-8 -*-
"""
Created on Wed May 2 21:28:06 2018
ALDS1_5a_r1
@author: maezawa
"""
import itertools as itr
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
m = list(map(int, input().split()))
sum_array = []
for r in range(1,n+1):
for comb in itr.combinations(a, r):
sum_array.append(sum(comb))
sum_array.sort()
for i in m:
left = 0
right = len(sum_array)
yesorno = 'no'
while(left < right):
#print(left, right)
mid = (left+right)//2
if sum_array[mid] == i:
yesorno = 'yes'
break
elif sum_array[mid] > i:
right = mid
else:
left = mid+1
print(yesorno)
| p02271 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.