input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from collections import deque
n = int(eval(input()))
list = [list(map(int,input().split())) for i in range(n)]
p = deque()
for i in list:
p.append([i[0] - i[1],i[0] + i[1]])
p = sorted(p,key = lambda x: x[1])
ex = []
ex.append(p.pop(0))
for i in range(len(p)):
if(ex[-1][1] <= p[0][0]):
ex.append(p.pop(0))
else:
p.pop(0)
print((len(ex))) | from collections import deque
n = int(eval(input()))
list = [list(map(int,input().split())) for i in range(n)]
p = []
for i in list:
p.append([i[0] - i[1],i[0] + i[1]])
p = sorted(p,key = lambda x: x[1])
p = deque(p)
ex = []
ex.append(p.popleft())
for i in range(len(p)):
if(ex[-1][1] <= p[0][0]):
ex.append(p.popleft())
else:
p.popleft()
print((len(ex))) | p02796 |
import sys
from collections import deque, Counter, defaultdict
from itertools import permutations
import heapq
def resolve():
N = int(sys.stdin.readline().strip())
pq = []
for _ in range(N):
X, L = list(map(int, sys.stdin.readline().strip().split()))
heapq.heappush(pq, (X + L, X - L))
ans = 0
while pq:
ans += 1
right, _ = heapq.heappop(pq)
if pq:
_, next_left = min(pq)
while next_left < right:
heapq.heappop(pq)
if not pq:
break
_, next_left = min(pq)
print(ans)
if __name__ == "__main__":
resolve()
| import sys
from collections import deque, Counter, defaultdict
from itertools import permutations
import heapq
def resolve():
N = int(sys.stdin.readline().strip())
pq = []
for _ in range(N):
X, L = list(map(int, sys.stdin.readline().strip().split()))
heapq.heappush(pq, (X + L, X - L))
ans = 0
while pq:
ans += 1
right, _ = heapq.heappop(pq)
if pq:
_, next_left = pq[0]
while next_left < right:
heapq.heappop(pq)
if not pq:
break
_, next_left = pq[0]
print(ans)
if __name__ == "__main__":
resolve()
| p02796 |
N = int(eval(input()))
XL = [list(map(int, input().split())) for _ in range(N)]
t = [(x + l, x - l) for x, l in XL]
t.sort()
max_r = -float('inf')
result = 0
for i in range(N):
r, l = t[i]
if max_r <= l:
result += 1
max_r = r
print(result) | from operator import itemgetter
def solve():
N = int(eval(input()))
X = []
for i in range(N):
xx, ll = list(map(int, input().split()))
X.append((xx-ll, xx+ll))
X.sort(key=itemgetter(1))
count = 0
cur = -float('inf')
for i in range(N):
c, d = X[i]
if cur <= c:
count += 1
cur = d
return count
print((solve()))
| p02796 |
n = int(eval(input()))
l = []
for _ in range(n):
x,y = list(map(int, input().split()))
l.append([x+y,x-y])
l.sort()
temp = l[0][0]
count = n
i = 1
for i in range(1,n):
if temp <= l[i][1]:
temp = l[i][0]
else:
temp = min(temp,l[i][0])
count -= 1
print(count) | n = int(eval(input()))
l = []
for _ in range(n):
x,y = list(map(int, input().split()))
l.append([x+y,x-y])
l=sorted(l)
tmp = l[0][0]
count = n
for p in l[1:]:
if tmp <= p[1]:
tmp = p[0]
else:
tmp = min(tmp,p[0])
count -= 1
print(count) | p02796 |
def main():
N = int(eval(input()))
L = []
for i in range(N):
xi, li = list(map(int, input().split()))
s = xi - li
f = xi + li
L.append((s, f))
L.sort(key=lambda x: x[1])
ans = 0
while L:
e = L[0]
L = [i for i in L if i[0] >= e[1]]
ans += 1
print(ans)
if __name__ == "__main__":
main()
| def main():
N = int(eval(input()))
L = []
for i in range(N):
xi, li = list(map(int, input().split()))
s = xi - li
f = xi + li
L.append((f, s))
L.sort()
ans = 0
finish = -float("inf")
for i in L:
if finish <= i[1]:
ans += 1
finish = i[0]
print(ans)
if __name__ == "__main__":
main()
| p02796 |
N = int(eval(input()))
L = []
R = []
for i in range(N):
x,l = list(map(int,input().split()))
L.append( x-l )
R.append( x+l )
R,L = list(zip(*sorted(zip(R,L))))
cnt = 1
maxR = R[0]
for i in range(1,N):
if maxR <= L[i]:
cnt += 1
if maxR < R[i]:
maxR = R[i]
print(cnt) | N = int(eval(input()))
L = []
R = []
for i in range(N):
x,l = list(map(int,input().split()))
L.append( x-l )
R.append( x+l )
R,L = list(zip(*sorted(zip(R,L))))
cnt = 1
maxR = R[0]
for i in range(1,N):
if maxR <= L[i]:
cnt += 1
maxR = R[i]
print(cnt) | p02796 |
n = int(eval(input()))
ll = [[0]*i for i in range(n)]
for i in range(n):
x, l =list(map(int, input().split()))
ll[i] = [x-l, x+l]
ll = sorted(ll)
l = ll[0]
ans = n
for i in range(n-1):
li = ll[i+1]
if l[1] > li[0]:
ans -= 1
else:
l = li
print(ans) | n = int(eval(input()))
ll = []
for i in range(n):
x, l = list(map(int, input().split()))
ll.append([x-l, x+l])
ll = sorted(ll)
ans = n
r = ll.pop()[0]
while ll:
while ll and ll[-1][1] > r:
ans -= 1
ll.pop()
if ll:
r = ll.pop()[0]
print(ans) | p02796 |
n = int(eval(input()))
ll = []
for i in range(n):
x, l = list(map(int, input().split()))
ll.append([x-l, x+l])
ll.sort(key=lambda x:x[1])
ans = 0
tmp = -10**9
for l in ll:
if l[0] >= tmp:
ans += 1
tmp = l[1]
print(ans) | import sys
input = sys.stdin.readline
n = int(eval(input()))
ll = []
for i in range(n):
x, l = list(map(int, input().split()))
ll.append([x-l, x+l])
ll.sort(key=lambda x:x[1])
ans = 0
tmp = -10**9
for l in ll:
if l[0] >= tmp:
ans += 1
tmp = l[1]
print(ans) | p02796 |
n = int(eval(input()))
L = []
for _ in range(n):
x, l = list(map(int, input().split()))
L.append([x - l, x + l])
L = sorted(L, key=lambda x: x[1])
ans = 0
r = -float('inf')
for i in range(n):
if L[i][0] >= r:
ans += 1
r = L[i][1]
print(ans)
| n = int(eval(input()))
L = []
for _ in range(n):
x, l = list(map(int, input().split()))
left = x - l
right = x + l
L.append((left, right))
L = sorted(L, key=lambda x: x[1])
ans = 0
prev = -float('inf')
for r in L:
if r[0] >= prev:
ans += 1
prev = r[1]
print(ans)
| p02796 |
from operator import itemgetter
N= int(eval(input()))
ans = 1
a = []
for i in range(N):
tmpa, tmpb = list(map(int,input().split()))
if tmpa-tmpb in a:
a[tmpa-tmpb].append(tmpa+tmpb)
else:
a.append([tmpa-tmpb,tmpa+tmpb])
b = sorted(a, key=itemgetter(1))
tmp = b[0][1]
for i in range(1, N):
if b[i][0] >= tmp:
ans += 1
tmp = b[i][1]
print(ans) | from operator import itemgetter
N= int(eval(input()))
ans = 1
a = []
for i in range(N):
tmpa, tmpb = list(map(int,input().split()))
a.append([tmpa+tmpb, tmpa-tmpb])
a.sort()
tmp = a[0][0]
for i in range(1, N):
if a[i][1] >= tmp:
ans += 1
tmp = a[i][0]
print(ans)
| p02796 |
import heapq
n = int(eval(input()))
XL = [tuple(map(int, input().split())) for _ in range(n)]
blocked = [0] * n
total = 0
for i in range(n):
ax, al = XL[i]
for j in range(i + 1, n):
bx, bl = XL[j]
if ax - al < bx - bl < ax + al or ax - al < bx + bl < ax + al:
blocked[i] -= 1
blocked[j] -= 1
total += 1
count = 0
heapq.heapify(blocked)
while total > 0:
total += heapq.heappop(blocked)
count += 1
print((n - count))
| n = int(eval(input()))
LR = [None] * n
for i in range(n):
x, l = list(map(int, input().split()))
LR[i] = (x - l, x + l)
LR.sort(key=lambda lr: lr[1])
count = 1
cur = LR[0][1]
for l, r in LR[1:]:
if cur <= l:
count += 1
cur = r
print(count)
| p02796 |
n = int(eval(input()))
X = []
L = []
for _ in range(n):
x, l = list(map(int, input().split()))
X.append(x)
L.append(l)
X = sorted(set(X), key=X.index)
areas = [(x - l, x + l)for x, l in zip(X, L)]
for i, (m0, M0) in enumerate(areas):
for m, M in (areas[:i] + areas[i+1:]):
if (m0 <= m) and (M <= M0):
areas.pop(i)
# print(areas)
areas = sorted(areas, key=lambda x:x[0])
areas2 = []
for area in areas:
if not areas2:
areas2.append(area)
elif areas2[-1][-1] <= area[0]:
areas2.append(area)
# print(areas)
# print(areas2)
print((len(areas2))) | # https://atcoder.jp/contests/keyence2020/tasks/keyence2020_b
n = int(eval(input()))
X = []
L = []
for _ in range(n):
x, l = list(map(int, input().split()))
X.append(x)
L.append(l)
areas = [(x - l, x + l) for x, l in zip(X, L)]
areas = sorted(areas, key=lambda x:x[-1])
# print(areas)
ok = [areas[0]]
for area in areas[1:]:
if ok[-1][-1] <= area[0]:
ok.append(area)
# print(ok)
print((len(ok))) | p02796 |
from operator import itemgetter
N = int(eval(input()))
l = []
for i in range(N):
a, b = list(map(int, input().split()))
s = [a-b, a+b]
l.append(s)
l.sort(key = itemgetter(1))
cnt = 0
for i in range(1, N):
for j in range(i, -N, -1):
if l[j-1][0] == - 10 ** 9:
continue
if l[i][0] < l[j-1][1]:
l[i][0] = - 10 ** 9
l[i][1] = - 10 ** 9
cnt += 1
break
print((N-cnt)) | from operator import itemgetter
N = int(eval(input()))
l = []
for i in range(N):
a, b = list(map(int, input().split()))
s = [a-b, a+b]
l.append(s)
l.sort(key = itemgetter(1))
cnt = 0
s = - 10 ** 10
for i in range(N):
if l[i][0] >= s:
s = l[i][1]
else:
cnt += 1
print((N-cnt)) | p02796 |
N = int(eval(input()))
ST = []
for _ in range(N):
x, l = list(map(int, input().split()))
ST.append((x-l, x+l))
ST.sort(key=lambda x: x[1])
ans = 0
cur = -1e9
for i in range(N):
s, t = ST[i]
if cur <= s:
ans += 1
cur = t
print(ans)
| import sys
def input():
return sys.stdin.readline()[:-1]
N = int(eval(input()))
XL = []
for _ in range(N):
x, l = list(map(int, input().split()))
XL.append((x-l, x+l))
XL.sort(key=lambda x: x[1])
ans = 0
cur = -1e9
for i in range(N):
if cur <= XL[i][0]:
ans += 1
cur = XL[i][1]
print(ans)
| p02796 |
import bisect
N=int(eval(input()))
rllist=[]
for _ in range(N):
X,L=list(map(int,input().split()))
rllist.append((X+L,X-L))
rllist.sort()
#print(rllist)
dp=[0]*N
for i in range(N):
r,l=rllist[i]
pos=bisect.bisect(rllist,(l,float("inf")))
#print(i,pos)
dp[i]=max(dp[i-1],dp[pos-1]+1)
#print(dp)
print((dp[-1])) | N=int(eval(input()))
rllist=[]
for _ in range(N):
X,L=list(map(int,input().split()))
rllist.append((X+L,X-L))
rllist.sort()
#print(rllist)
answer=0
max_r=-float("inf")
for r,l in rllist:
#print(max_r,l)
if max_r<=l:
answer+=1
max_r=max(max_r,r)
print(answer) | p02796 |
N=int(eval(input()))
rllist=[]
for _ in range(N):
X,L=list(map(int,input().split()))
rllist.append((X+L,X-L))
rllist.sort()
#print(rllist)
answer=0
max_r=-float("inf")
for r,l in rllist:
#print(max_r,l)
if max_r<=l:
answer+=1
max_r=max(max_r,r)
print(answer) | N=int(eval(input()))
rllist=[]
for _ in range(N):
X,L=list(map(int,input().split()))
rllist.append((X+L,X-L))
rllist.sort()
#print(rllist)
answer=0
max_r=-float("inf")
for r,l in rllist:
#print(max_r,l)
if max_r<=l:
answer+=1
max_r=r
print(answer) | p02796 |
n = int(eval(input()))
lst = []
for i in range(n):
x,l = list(map(int,input().split()))
if x-l < 0:
# [右端の位置,左端の位置]
lst.append([x+l,0])
else:
lst.append([x+l,x-l])
lst.sort()
# [[6, 0], [7, 1], [12, 6], [105, 95]]
# 最初のロボットの選択
now = lst[0][0]
cnt = 1
idx = 1
for i in range(idx,n):
if now <= lst[i][1]:
now = lst[i][0]
cnt += 1
idx = i + 1
print(cnt) | n = int(eval(input()))
lst = []
for i in range(n):
x,l = list(map(int,input().split()))
if x-l < 0:
# [右端の位置,左端の位置]
lst.append([x+l,0])
else:
lst.append([x+l,x-l])
lst.sort()
# 最初のロボットの選択
now = lst[0][0]
cnt = 1
for i in range(1,n):
if now <= lst[i][1]:
now = lst[i][0]
cnt += 1
print(cnt) | p02796 |
n = int(eval(input()))
s = [list(map(int,input().split())) for i in range(n)]
s.sort()
stop = s[0][0] + s[0][1]
ans = 1
for i in range(1,n):
num = s[i][0]
l = s[i][1]
if num - l >= stop:
ans += 1
stop = num + l
if num + l < stop:
stop = num + l
print(ans)
| n = int(eval(input()))
a = []
for i in range(n):
x,l = list(map(int,input().split()))
s = x-l
g = x+l
a.append((s,g))
a = sorted(a, reverse=False, key=lambda x: x[1])
tmp = a[0][1]
ans = 1
for i in range(1,len(a)):
if tmp <= a[i][0]:
tmp = a[i][1]
ans += 1
print(ans) | p02796 |
a = int(eval(input()))
fanwei = []
for i in range(a):
one = input().split()
one = [int(i) for i in one]
two = [one[0] - one[1], one[0] + one[1]]
fanwei.append(two)
fanwei = sorted(fanwei, key=lambda student: student[0] + 100000000000000000000 * student[1])
maxer = 0
for i in range(len(fanwei)):
now = -100000000000000000000
ans = 0
for i in fanwei[i:]:
down = i[0]
if down >= now:
ans += 1
now = i[1]
maxer = max(ans, maxer)
print(maxer)
| a = int(eval(input()))
fanwei = []
for i in range(a):
one = input().split()
one = [int(i) for i in one]
two = [one[0] - one[1], one[0] + one[1]]
fanwei.append(two)
fanwei = sorted(fanwei, key=lambda student: student[0] + 100000000000000000000 * student[1])
now = -100000000000000000000
ans = 0
for i in fanwei[:]:
down = i[0]
if down >= now:
ans += 1
now = i[1]
print(ans)
| p02796 |
from collections import defaultdict
n = int(eval(input()))
r = []
for i in range(n):
x, l = list(map(int, input().split()))
r.append((x - l + 1, x + l - 1))
r.sort()
am = [[] for _ in range(n)]
for i in range(n):
for j in range(i + 1, n):
if r[i][1] >= r[j][0]:
am[i].append(j)
am[j].append(i)
while sum(len(mi) for mi in am):
maxi, maxd = 0, 0
for i, mi in enumerate(am):
li = len(mi)
if li > maxd:
maxi, maxd = i, li
for pi in am[maxi]:
am[pi].remove(maxi)
am.pop(maxi)
n -= 1
print(n) | n = int(eval(input()))
r = []
for i in range(n):
x, l = list(map(int, input().split()))
r.append((x - l, x + l))
r.sort(key=lambda _x: _x[1])
cnt = 1
limit = r[0][1]
for ri in r[1:]:
if ri[0] >= limit:
cnt += 1
limit = ri[1]
print(cnt) | p02796 |
N = int(eval(input()))
# X = []
# L = []
# for _ in range(N):
# x, l = map(int, input().split()))
# X.append(x)
# L.append(l)
# XL = [list(map(int, input().split()))) for _ in range(N)]
A = []
B = []
for _ in range(N):
x, l = list(map(int, input().split()))
A.append(x - l)
B.append(x + l - 1)
l = []
ans = 0
for i in range(N):
count = 0
for j in range(N):
if i == j:
continue
else:
if A[i] <= A[j] <= B[i] or A[i] <= B[j] <= B[i]:
count += 1
l.append(count)
print((N - l.count(max(l)) if max(l) != 0 else N)) | N = int(eval(input()))
robot = []
for _ in range(N):
r = []
x, l = list(map(int, input().split()))
a = x + l - 1
b = x - l
r += [a, b]
robot.append(r)
Robot = sorted(robot)
robot_count = [Robot[0]]
for i in range(1, N):
if Robot[i][1] > robot_count[-1][0]:
robot_count.append(Robot[i])
print((len(robot_count))) | p02796 |
n = int(eval(input()))
robot = []
for _ in range(n):
x, l = list(map(int, input().split()))
arm_left = x - l
arm_right = x + l
robot.append([arm_left, arm_right])
robot.sort(key=lambda x: x[1])
count = 0
while True:
if len(robot) == 0:
break
count += 1
current_right = robot[0][1]
robot = [i for i in robot if i[0] >= current_right]
print(count) | n = int(eval(input()))
robot = []
for _ in range(n):
x, l = list(map(int, input().split()))
arm_left = x - l
arm_right = x + l
robot.append([arm_left, arm_right])
robot.sort(key=lambda x: x[1])
count = 0
current_right = -1000000000
for i in range(n):
if robot[i][0] >= current_right:
count += 1
current_right = robot[i][1]
print(count) | p02796 |
N = int(eval(input()))
s = [tuple(map(int, input().split())) for i in range(N)]
s.sort(key=lambda x: x[1])
t = list([(j[0]-j[1]+1, j[0]+j[1]-1) for j in s])
NN = len(t)
dobon = []
for k in range(NN):
for l in range(k+1, NN):
if l not in dobon:
if int(t[k][1]) <= int(t[l][1]):
if (t[l][0] <= t[k][1]) and (t[k][1] <= t[l][1]):
N -= 1
dobon.append(l)
break
else:
if (t[l][0] <= t[k][0]) and (t[k][0] <= t[l][1]):
N -= 1
dobon.append(l)
break
print(N) | N = int(eval(input()))
S = [tuple(map(int, input().split())) for i in range(N)]
T = list([(j[0]-j[1], j[0]+j[1]) for j in S])
T.sort(key=lambda x: x[1])
for i, t in enumerate(T):
if i>0:
if end <= t[0]:
res += 1
start = t[0]
end = t[1]
else:
start = t[0]
end = t[1]
res = 1
print(res) | p02796 |
n = int(eval(input()))
robot = []
for _ in range(n):
x, l = list(map(int, input().split()))
robot.append([x - l, x + l])
# startが被らないendが小さいもの
ans = 0
robot.sort(key=lambda x: x[1])
last = - float('inf')
for start, end in robot:
if start >= last:
ans += 1
last = end
print(ans)
| import sys
input = sys.stdin.readline
n = int(eval(input()))
robot = []
for _ in range(n):
x, l = list(map(int, input().split()))
robot.append([x - l, x + l])
# startが被らないendが小さいもの
ans = 0
robot.sort(key=lambda x: x[1])
last = - float('inf')
for start, end in robot:
if start >= last:
ans += 1
last = end
print(ans)
| p02796 |
N = int(eval(input()))
XL = [tuple(map(int,input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0]+x[1])
right = -float('inf')
ans = 0
for x,l in XL:
s,t = x-l, x+l
if s >= right:
right = t
ans += 1
print(ans)
| N = int(eval(input()))
table = []
for i in range(N):
X,L = list(map(int,input().split()))
table.append((X-L,X+L))
table = sorted(table, key=lambda x:x[1])
cur = 0
l_cur, r_cur = table[0]
ans = N
for i in range(1,N):
l,r = table[i]
if r_cur > l:
ans -= 1
else:
l_cur, r_cur = l,r
print(ans) | p02796 |
import copy
n = int(eval(input()))
xl = []
for i in range(n):
xl.append([int(i) for i in input().split()])
xl[i].append(xl[i][0] - xl[i][1])
xl[i].append(xl[i][0] + xl[i][1])
xl.sort(key=lambda x: x[3])
ng = []
ans = 0
for i in range(n):
tmp = list(range(xl[i][2] + 1, xl[i][3]))
a = copy.deepcopy(tmp) #動く範囲
a.extend(ng)
if len(set(a)) == len(a):
ng.extend(tmp)
ans += 1
print(ans)
| n = int(eval(input()))
robot = []
for i in range(n):
x, l = list(map(int,input().split()))
robot.append([x + l, x - l]) #left, right
robot.sort()
preright = robot[0][1]
ans = 0
for i in range(n):
left = robot[i][1]
#print(preright, left)
if preright <= left:
ans += 1
preright = robot[i][0]
print(ans)
| p02796 |
# coding: utf-8
import math
import collections
def main():
n = int(eval(input()))
inputs = [input().split() for i in range(n)]
inputs_list = []
for tmp in inputs:
if int(tmp[0]) - int(tmp[1]) < 0:
for i in range(0, int(tmp[0]) + int(tmp[1])):
inputs_list.append(i)
else:
for i in range(int(tmp[0]) - int(tmp[1]), int(tmp[0]) + int(tmp[1])):
inputs_list.append(i)
c = collections.Counter(inputs_list)
print((n - (c.most_common()[0][1] - 1)))
if __name__ == '__main__':
main()
| # coding: utf-8
def main():
n = int(eval(input()))
inputs = [input().split() for i in range(n)]
inputs_list = []
for i in inputs:
if int(i[0]) - int(i[1]) < 0:
inputs_list.append([0, int(i[0]) + int(i[1])])
else:
inputs_list.append([int(i[0]) - int(i[1]), int(i[0]) + int(i[1])])
sorted_data = sorted(inputs_list, key=lambda x: (x[1]))
ans = [sorted_data[0]]
cur = ans[0][1]
for i in range(len(sorted_data) - 1):
if cur <= sorted_data[i + 1][0]:
ans.append(sorted_data[i + 1])
cur = sorted_data[i + 1][1]
print((len(ans)))
if __name__ == '__main__':
main()
| p02796 |
n = int(eval(input()))
a = []
for _ in range(n):
c0, c1 = list(map(int, input().split()))
a.append([c0-c1, c0+c1])
a.sort(key=lambda x: x[1])
ans = 1
b = [a[0]]
for i in a[1:]:
for j, k in enumerate(b):
if not (k[1] <= i[0]):
break
if j == len(b)-1:
ans += 1
b.append(i)
print(ans)
| n = int(eval(input()))
a = []
for _ in range(n):
c0, c1 = list(map(int, input().split()))
a.append([c0-c1, c0+c1])
a.sort(key=lambda x: x[1])
ans, b = 1, a[0][1]
for i in a[1:]:
if b <= i[0]:
b = i[1]
ans += 1
print(ans)
| p02796 |
import sys
n = int(eval(input()))
xl = []
for _ in range(n):
x, l = list(map(int, input().split()))
xl.append((x, l))
xl.sort(key=lambda x:x[0])
i = 0
if n==1:
print((1))
sys.exit(0)
while i<len(xl)-1:
if xl[i][0]+xl[i][1] <= xl[i+1][0]-xl[i+1][1]:
i += 1
else:
if xl[i][0]+xl[i][1] < xl[i+1][0]+xl[i+1][1]:
del xl[i+1]
else:
del xl[i]
print((len(xl))) | import sys
n = int(eval(input()))
xl = []
for _ in range(n):
x, l = list(map(int, input().split()))
xl.append((x, l))
xl.sort(key=lambda x:x[0])
if n==1:
print((1))
sys.exit(0)
i=0
j=1
ans=n
while j<len(xl):
if xl[i][0]+xl[i][1] <= xl[j][0]-xl[j][1]:
i = j
j = i+1
else:
ans -= 1
if xl[i][0]+xl[i][1] < xl[j][0]+xl[j][1]:
j += 1
else:
i = j
j = i+1
print(ans)
| p02796 |
n=int(eval(input()))
Y=[list(map(int,input().split())) for i in range(n)]
range=[]
ans,end=0,-1*(10**9+1)
for X in Y:
range.append([X[0]-X[1],X[0]+X[1]])
range.sort(key=lambda X: X[1])
for R in range:
if end <= R[0]:
ans += 1
end=R[1]
else:
continue
print(ans) | n=int(eval(input()))
Range=[]
ans,end=0,-1*(10**9+1)
for i in range(n):
x,y=list(map(int,input().split()))
Range.append([x-y,x+y])
Range.sort(key=lambda X: X[1])
for R in Range:
if end <= R[0]:
ans += 1
end=R[1]
else:
continue
print(ans) | p02796 |
def main():
n = int(eval(input()))
x = []
xl = {}
tmp = []
tmp2 = []
maxtmp = 0
for i in range(n):
xx, ll = list(map(int,input().split()))
if maxtmp < xx:
maxtmp = xx
low = max(xx-ll+1,0)
high = xx+ll-1
lmh = [low,xx,high]
tmp.append(lmh)
tmp2.append(lmh)
x.append(xx)
tmp.sort()
# for i in range()
flg = 0
for i, a in enumerate(tmp):
if flg == 0:
low = a[0]
high = a[2]
flg = 1
else:
if low <= a[0] and high >= a[0]:
aa= tmp2.pop(tmp2.index(a))
if i+1 < len(tmp) and high < tmp[i+1][0]:
flg = 0
print((len(tmp2)))
return
if __name__=='__main__':
main()
| def main():
n = int(eval(input()))
x = []
xl = {}
tmp = []
ans = 0
maxtmp = 0
for i in range(n):
xx, ll = list(map(int,input().split()))
if maxtmp < xx:
maxtmp = xx
low = xx-ll
high = xx+ll
lmh = [high,xx,low]
tmp.append(lmh)
tmp.sort()
high = tmp[0][0]
ans = 1
for i in range(1,len(tmp)):
a = tmp[i]
if a[2] >= high:
high = a[0]
ans += 1
else:
continue
print(ans)
return
if __name__=='__main__':
main()
| p02796 |
N = int(eval(input()))
r = [list(map(int, input().split())) for _ in range(N)]
a = []
for i in r:
a.append((i[0]+i[1],i[0]-i[1]))
a.sort()
ans = 0
cur = -float('inf')
for i in a:
if i[1] < cur:
continue
ans += 1
cur = i[0]
print(ans) | N = int(eval(input()))
r = [list(map(int, input().split())) for _ in range(N)]
a = []
for i in r:
a.append((i[0]-i[1],i[0]+i[1]))
a.sort(key=lambda x:x[1])
ans = 0
cur = -float('inf')
for i in a:
if i[0] < cur:
continue
ans += 1
cur = i[1]
print(ans) | p02796 |
n = int(eval(input()))
Robo = []
for i in range(n):
x, leng = list(map(int, input().split()))
Robo.append([x - leng + 1, x + leng - 1])
Robo.sort(key=lambda x: x[1])
#print(Robo)
Robo_r = []
for robo_cand in Robo:
l, r = robo_cand
for robo_r in Robo_r:
if l <= robo_r[1]:
break
else:
Robo_r.append(robo_cand)
print((len(Robo_r))) | n = int(eval(input()))
Robo = []
for i in range(n):
x, l = list(map(int, input().split()))
Robo.append([x-l, x+l])
Robo.sort(key=lambda x: x[1])
#print(Robo)
biggest_right = 2 * -10**9 - 1
counter = 0
for left, right in Robo:
if biggest_right <= left:
counter += 1
biggest_right = max(right, biggest_right)
print(counter) | p02796 |
import sys
from bisect import bisect
from operator import itemgetter
n = int(eval(input()))
robots = []
for line in sys.stdin:
X, L = list(map(int, line.split()))
l, r = X - L, X + L
robots.append((l, r))
robots.sort(key=itemgetter(1))
dp = [-(10 ** 18)]
for l, r in robots:
i = bisect(dp, l)
if len(dp) == i:
dp.append(r)
else:
dp[i] = min(dp[i], r)
print((len(dp) - 1))
| import sys
from operator import itemgetter
n = int(eval(input()))
robots = []
for line in sys.stdin:
X, L = list(map(int, line.split()))
l, r = X - L, X + L
robots.append((l, r))
robots.sort(key=itemgetter(1))
curr = -(10 ** 10)
ans = 0
for l, r in robots:
if curr > l:
continue
ans += 1
curr = r
print(ans)
| p02796 |
N = int(eval(input()))
r = [list(map(int, input().split())) for _ in range(N)]
r.sort()
l = [r[0]]
r = r[1:]
while len(r) > 0:
x1, l1 = l[-1]
x2, l2 = r[0]
if (x1+l1) > (x2-l2):
if (x1+l1) > (x2+l2):
l.pop()
l.append(r[0])
r.pop(0)
else:
r.pop(0)
else:
l.append(r[0])
r.pop(0)
print((len(l)))
| N = int(eval(input()))
r = [list(map(int, input().split())) for _ in range(N)]
r.sort()
l = r[0]
ri = 1
ans = N
while ri < N:
x1, l1 = l
x2, l2 = r[ri]
if (x1+l1) > (x2-l2):
if (x1+l1) > (x2+l2):
l = r[ri]
ri += 1
else:
ri += 1
ans -= 1
else:
l = r[ri]
ri += 1
print(ans)
| p02796 |
n = int(eval(input()))
robo = [0] * n
for i in range(n):
x, l = list(map(int, input().split()))
robo[i] = (x - l, x + l)
robo.sort(key=lambda x: x[1])
max_r, cnt = -float('inf'), 0
for l, r in robo:
if max_r <= l:
cnt += 1
max_r = max(max_r, r)
print(cnt) | n = int(eval(input()))
robo = [0] * n
for i in range(n):
x, l = list(map(int, input().split()))
robo[i] = (x - l, x + l)
robo.sort(key=lambda x: x[1])
max_r, cnt = -float('inf'), 0
for l, r in robo:
if max_r <= l:
cnt += 1
max_r = r
print(cnt) | p02796 |
#!python3
iim = lambda: list(map(int, input().rstrip().split()))
from bisect import bisect_left
def resolve():
N = int(eval(input()))
#S = [list(iim()) for i in range(N)]
MX = 10**9
S = []
for i in range(N):
x, l = iim()
i = x - l
if i < 0:
i = 0
j = x + l
if j > MX:
j = MX
a = [i, j]
S.append(a)
S.sort()
d = dict()
x, y = S[0]
d = {-1: 0}
dk = [-1]
ans = 0
for x, y in S:
for xx in dk:
if xx <= x:
n = d[xx] + 1
if y in d:
if d[y] < n:
d[y] = n
if ans < n:
ans = n
else:
d[y] = n
dk.append(y)
if ans < n:
ans = n
#print(x, y, d)
print(n)
if __name__ == "__main__":
resolve()
| #!python3
iim = lambda: list(map(int, input().rstrip().split()))
from bisect import bisect_left
def resolve():
N = int(eval(input()))
#S = [list(iim()) for i in range(N)]
MX = 10**9
S = []
for i in range(N):
x, l = iim()
i = x - l
if i < 0:
i = 0
j = x + l
if j > MX:
j = MX
a = [i, j]
S.append(a)
S.sort()
ans = 0
last = MX+1
n = 1
for x, y in S:
if y < last:
last = y
elif last <= x:
n += 1
last = y
print(n)
if __name__ == "__main__":
resolve()
| p02796 |
import sys
sys.setrecursionlimit(4100000)
import math
import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
from functools import lru_cache
def resolve():
global N, grid
# S = [x for x in sys.stdin.readline().split()][0] # 文字列 一つ
N = [int(x) for x in sys.stdin.readline().split()][0] # int 一つ
# N, D = [int(x) for x in sys.stdin.readline().split()] # 複数int
# grid = [list(sys.stdin.readline().split()[0]) for _ in range(N)] # 文字列grid
grid = [[int(x) for x in sys.stdin.readline().split()]
for _ in range(N)] # int grid
logger.debug('{}'.format([]))
print((dp((), 0)))
def canPut(filled, x, l):
if filled == ():
return True
return all([right <= x - l or x + l <= left for (left, right) in filled])
@lru_cache(maxsize=None)
def dp(filled, i):
if i == N - 1:
if canPut(filled, *grid[i]):
return 1
else:
return 0
n_ex = dp(filled, i + 1)
n_in = 0
if canPut(filled, *grid[i]):
x, l = grid[i]
lf = list(filled)
n_in = dp(tuple(lf + [(x - l, x + l)]), i + 1) + 1
return max([n_ex, n_in])
if __name__ == "__main__":
resolve()
# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py で実行できる
# pypy3 -m unittest template/template.py で実行できる
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """4
2 4
4 3
9 3
100 5"""
output = """3"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2
8 20
1 10"""
output = """1"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """5
10 1
2 1
4 1
6 1
8 1"""
output = """5"""
self.assertIO(input, output)
| import sys
sys.setrecursionlimit(4100000)
import math
import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
from functools import lru_cache
def resolve():
global N, grid
# S = [x for x in sys.stdin.readline().split()][0] # 文字列 一つ
N = [int(x) for x in sys.stdin.readline().split()][0] # int 一つ
# N, D = [int(x) for x in sys.stdin.readline().split()] # 複数int
# grid = [list(sys.stdin.readline().split()[0]) for _ in range(N)] # 文字列grid
grid = [[int(x) for x in sys.stdin.readline().split()]
for _ in range(N)] # int grid
logger.debug('{}'.format([]))
grid = [(x + l, x - l) for x, l in grid]
grid = sorted(grid)
ans = 0
t = - 10**10
for right, left, in grid:
if t <= left:
ans += 1
t = right
print(ans)
if __name__ == "__main__":
resolve()
# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py で実行できる
# pypy3 -m unittest template/template.py で実行できる
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """4
2 4
4 3
9 3
100 5"""
output = """3"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """2
8 20
1 10"""
output = """1"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """5
10 1
2 1
4 1
6 1
8 1"""
output = """5"""
self.assertIO(input, output)
| p02796 |
def main():
n = int(eval(input()))
s = []
e = []
tls = []
buff = {}
for i in range(n):
tmp = list(map(int, input().split()))
s.append(tmp[0] - tmp[1])
e.append(tmp[0] + tmp[1])
for i in range(n):
buff[s[i]] = e[i]
maxcount = 0
sorted_s = sorted(s)
preve = 0
while len(sorted_s) > 0:
tmps = sorted_s[0]
tmpe = buff[tmps]
if preve == 0:
maxcount += 1
preve = tmpe
sorted_s = sorted_s[1:]
elif tmps >= preve:
maxcount += 1
preve = tmpe
sorted_s = sorted_s[1:]
elif tmpe < preve:
preve = tmpe
sorted_s = sorted_s[1:]
else:
sorted_s = sorted_s[1:]
print(maxcount)
return
if __name__ == "__main__":
main() | def main():
n = int(eval(input()))
x = []
l = []
for i in range(n):
tmp = list(map(int, input().split()))
x.append(tmp[0] - tmp[1])
l.append(tmp[0] + tmp[1])
x, l = list(zip(*sorted(zip(x, l))))
maxcount = 0
preve = 0
idx = 0
while idx < n:
tmps = x[idx]
tmpe = l[idx]
if preve == 0:
maxcount += 1
preve = tmpe
elif tmps >= preve:
maxcount += 1
preve = tmpe
elif tmpe < preve:
preve = tmpe
idx += 1
print(maxcount)
return
if __name__ == "__main__":
main() | p02796 |
import itertools
N = int(eval(input()))
alllist = []
remain = 0
for i in range(N):
X, L = list(map(int,input().split()))
alllist.append([i for i in range(X-L,X+L)])
d = 0
l = alllist
for i in range(N):
kumiawase = N-i
c_list = list(itertools.combinations(l, kumiawase))
for j in range(len(c_list)):
first = c_list[j][0]
c= 1
for k in range(len(c_list[j])-1):
if len(set(c_list[j][k+1]) & set(first)) == 0:
c += 1
else:
break
if c == kumiawase:
print(kumiawase)
d = 1
break
else:
pass
if d == 1:
break
else:
pass | import itertools
N = int(eval(input()))
alllist = []
remain = 0
for i in range(N):
X, L = list(map(int,input().split()))
alllist.append([X-L,X+L])
d = 0
l = alllist
for i in range(N):
kumiawase = N-i
c_list = list(itertools.combinations(l, kumiawase))
for j in range(len(c_list)):
first = [q for q in range(c_list[j][0][0],c_list[j][0][1])]
c= 1
for k in range(len(c_list[j])-1):
if len(set(r for r in range(c_list[j][k+1][0],c_list[j][k+1][1])) & set(first)) == 0:
c += 1
else:
break
if c == kumiawase:
print(kumiawase)
d = 1
break
else:
pass
if d == 1:
break
else:
pass | p02796 |
# https://atcoder.jp/contests/keyence2020/tasks/keyence2020_b
'''
区間スケジューリング問題：終点でソートして貪欲法
'''
import sys
input = sys.stdin.readline
N = int(eval(input()))
schedule = []
for i in range(N):
x, l = list(map(int, input().split()))
schedule.append((x - l, l + x)) # schedule = (始点、終点)
schedule = sorted(schedule, key=lambda x: x[1])
ans = 0
end = -10**12 # 始点の最小値
for i in range(N):
if end <= schedule[i][0]:
end = schedule[i][1] # 終点でソートされているので、自動的に可能な中で最速の終点が選ばれている
ans += 1
print(ans) | def Schedule(schedule):
"""
:return: 複数の区間が与えられた時の重複の無い区間の選び方の最大数
"""
schedule = sorted(schedule, key=lambda x: x[1])
N = len(schedule)
res = 0
end = -float("inf")
for i in range(N):
if end <= schedule[i][0]: # 重複がダメならば等号を消す
end = schedule[i][1] # 終点でソートされているので、自動的に可能な中で最速の終点が選ばれている
res += 1
return res
################################################################################
import sys
input = sys.stdin.readline
N = int(eval(input()))
schedule = []
for i in range(N):
x, l = list(map(int, input().split()))
schedule.append((x - l, l + x)) # schedule = (始点、終点)
print((Schedule(schedule))) | p02796 |
n = int(eval(input()))
l = [list(map(int,input().split())) for i in range(n)]
left = []
for i in range(n):
left.append((l[i][0]-l[i][1],l[i][0]+l[i][1]))
left.sort()
count = 1
right = 10**10
for i in range(n):
right = min(right,left[i][1])
while True:
right2 = 10**10
for i in range(n):
if left[i][0] >= right:
right2 = min(right2,left[i][1])
if right2 == 10**10:
print(count)
exit()
else:
right = right2
count += 1
| n = int(eval(input()))
l = [list(map(int,input().split())) for i in range(n)]
left = []
for i in range(n):
left.append((l[i][0]+l[i][1],l[i][0]-l[i][1]))
left.sort()
count = 1
right = 10**10
right = left[0][0]
c = 0
while True:
for i in range(c,n+1):
if i == n:
print(count)
exit()
if left[i][1] >= right:
count += 1
right = left[i][0]
c = i
if c == n-1:
print(count)
exit()
| p02796 |
#!/usr/bin/env python3
INF = float("inf")
n, *d = list(map(int, open(0).read().split()))
p = sorted(zip(*[iter(d)]*2), key=sum)
M, a = -INF, 0
for X, L in p:
l, r = X-L, X+L
if M <= l:
a += 1
M = r
print(a) | M,a =-float("inf"),0
for X,L in sorted(zip(*[iter(map(int,open(0).read().split()[1:]))]*2),key=sum):
l,r=X-L,X+L
if M<=l:a+=1;M=r
print(a) | p02796 |
n = int(eval(input()))
a = [list(map(int,input().split())) for i in range(n)]
d = list(range(0))
for i in range(n):
b = a[i][0] - a[i][1]
c = a[i][0] + a[i][1]
d.append([b,c])
def aaa():
#print(d)
e = list(range(0))
mcnt = 0
f = 0
for i in range(len(d)):
cnt = 0
#print(i)
for j in range(len(d)):
if i != j :
if (d[i][0] < d[j][0] and d[i][1] > d[j][0]) or (d[i][0] < d[j][1] and d[i][1] > d[j][1]):
cnt = cnt + 1
#print(cnt)
if cnt > 0 and mcnt < cnt:
mcnt = cnt
f = i
#print(mcnt)
if mcnt > 0 :
d.pop(f)
#print('pop')
return mcnt
x = 1
while x > 0 :
x = aaa()
#print(x)
print((len(d)))
| n = int(eval(input()))
robots = []
for i in range(n):
x, l = [int(item) for item in input().split()]
robots.append((x+l, x-l))
robots.sort()
#print(robots)
cnt = 0
node = -float("inf")
for end, start in robots:
if start >= node:
node = end
cnt += 1
print(cnt) | p02796 |
N=int(eval(input()))
xl=[list(map(int,input().split()))for _ in range(N)]
arms={}
for x,l in xl:
arms[x-l]=0
arms[x+l]=0
for x,l in xl:
arms[x-l]+=1
arms[x+l]-=1
point={}
for x,l in xl:
point[x-l]=[]
point[x+l]=[]
for x,l in xl:
point[x-l].append(x+l)
ans=N
K=sorted(arms.keys())
now=0
count=[]
for k in K:
now+=arms[k]
for kk in point[k]:
count.append(kk)
for i in range(count.count(k)):
count.remove(k)
if now>=2:
ans-=now-1
now=1
C=sorted(count)[::-1]
for c in C[:-1]:
arms[c]+=1
count.remove(c)
print(ans) | N=int(eval(input()))
xl=[list(map(int,input().split()))for _ in range(N)]
rl=[[x+l,x-l]for x,l in xl]
rl.sort()
now=-10**9
ans=0
for r,l in rl:
if l>=now:
ans+=1
now=r
print(ans) | p02796 |
N=int(eval(input()))
T=[]
for i in range(N):
X,L=list(map(int,list(input().split(" "))))
T.append([X+L,X-L])
T.sort()
sum=1
def check(T,v,w):
if T[v][0]<=T[w][1] or T[v][1]>=T[w][0]:
return True
else:
return False
checks=[0]
for i in range(1,N):
count=0
for j in checks:
if not check(T,i,j):
break
count+=1
if count==len(checks):
sum+=1
checks.append(i)
print(sum) | N=int(eval(input()))
X=[]
for i in range(N):
a,b=list(map(int,list(input().split(" "))))
X.append([a+b,a-b])
X.sort()
D={}
D[0]=1
exe=[0]
for i in range(1,N):
k=X[i][0]
if X[i][1]<X[exe[-1]][0]:
D[i]=D[exe[-1]]
else:
D[i]=D[exe[-1]]+1
exe.append(i)
print((len(exe))) | p02796 |
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
from decimal import Decimal
from operator import mul
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)
# UnionFind
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
# ダイクストラ
def dijkstra_heap(s, edge, n):
#始点sから各頂点への最短距離
d = [10**20] * n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for a,b in edge[s]:
heapq.heappush(edgelist,a*(10**6)+b)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge%(10**6)]:
continue
v = minedge%(10**6)
d[v] = minedge//(10**6)
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
return d
# 素因数分解
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
# 組合せnCr
def combinations_count(n, r):
if n < r:
return 0
r = min(r, n - r)
numer = reduce(mul, list(range(n, n - r, -1)), 1)
denom = reduce(mul, list(range(1, r + 1)), 1)
return numer // denom
# 2数の最小公倍数
def lcm(x, y):
return (x * y) // gcd(x, y)
# リストの要素の最小公倍数
def lcm_list(numbers):
return reduce(lcm, numbers, 1)
# リストの要素の最大公約数
def gcd_list(numbers):
return reduce(gcd, numbers)
# 素数判定
def is_prime(n):
if n <= 1:
return False
p = 2
while True:
if p ** 2 > n:
break
if n % p == 0:
return False
p += 1
return True
# limit以下の素数を列挙
def eratosthenes(limit):
A = [i for i in range(2, limit+1)]
P = []
while True:
prime = min(A)
if prime > sqrt(limit):
break
P.append(prime)
i = 0
while i < len(A):
if A[i] % prime == 0:
A.pop(i)
continue
i += 1
for a in A:
P.append(a)
return P
# 同じものを含む順列
def permutation_with_duplicates(L):
if L == []:
return [[]]
else:
ret = []
# set（集合）型で重複を削除、ソート
S = sorted(set(L))
for i in S:
data = L[:]
data.remove(i)
for j in permutation_with_duplicates(data):
ret.append([i] + j)
return ret
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
# ここから書き始める
n = int(eval(input()))
x = [0 for i in range(n)]
l = [0 for i in range(n)]
for i in range(n):
x[i], l[i] = list(map(int, input().split()))
ans = 0
p = [[x[i] - l[i], x[i] + l[i]] for i in range(n)]
p.sort(key=lambda a : a[1])
# print(p)
y = -INF
for i in p:
if i[0] >= y:
ans += 1
y = i[1]
print(ans) | INF = 1 << 60
n = int(eval(input()))
x = [0 for i in range(n)]
l = [0 for i in range(n)]
for i in range(n):
x[i], l[i] = list(map(int, input().split()))
itv = [[x[i] - l[i], x[i] + l[i]] for i in range(n)]
itv.sort(key=lambda x:x[1])
# print("itv =", itv)
ans = 0
t = -INF
for i in range(n):
if t <= itv[i][0]:
ans += 1
t = itv[i][1]
print(ans)
| p02796 |
N = int(eval(input()))
move = []
for i in range(N):
X,L = list(map(int,input().split()))
move.append([X-L,X+L])
move = sorted(move, key=lambda x:(x[0],x[1]))
if N == 1:
print((1))
else:
i = 1
while(len(move) > i):
if move[i-1][0] == move[i][0]:
del move[i-1]
else:
if move[i][1] <= move[i-1][1]:
del move[i]
else:
i += 1
if len(move) <= 2:
print((len(move)))
else:
i = 1
while(len(move) > i+1):
if move[i-1][1] >= move[i+1][0]:
del move[i]
else:
i += 1
print((len(move))) | N = int(eval(input()))
K = []
for i in range(N):
X,L = list(map(int,input().split()))
K.append([X-L,X+L])
T = sorted(K,key=lambda x:x[1])
a = T[0][1]
c = 1
for i in range(1,N):
if T[i][0] >= a:
c += 1
a = T[i][1]
print(c) | p02796 |
from operator import itemgetter
N = int(eval(input()))
X=[]
ans=0
for i in range(N):
H = list(map(int, input().split()))
O=[]
O.append(H[0]-H[1])
O.append(H[0]+H[1])
X.append(O)
#print(X)
X=sorted(X, key=itemgetter(1))
while(len(X)>0):
#print(X)
ans+=1
S=X[0][1]
X.remove(X[0])
I = []
for i in range(len(X)):
if(X[i][0]>=S):
I.append(X[i])
X=I
#print(I)
print(ans)
| from operator import itemgetter
N = int(eval(input()))
X=[]
ans=0
for i in range(N):
H = list(map(int, input().split()))
O=[]
O.append(H[0]-H[1])
O.append(H[0]+H[1])
X.append(O)
#print(X)
X=sorted(X, key=itemgetter(1))
S=X[0][1]
ans+=1
for i in range(len(X)):
if(X[i][0]>=S):
ans+=1
S=X[i][1]
"""
while(len(X)>0):
#print(X)
ans+=1
S=X[0][1]
X.remove(X[0])
I = []
for i in range(len(X)):
if(X[i][0]>=S):
I.append(X[i])
X=I
#print(I)
"""
print(ans)
| p02796 |
N = int(eval(input()))
xl = []
for i in range(N):
xl.append(list(map(int,input().split())))
itv = []
for i in range(N):
right = xl[i][0] + xl[i][1] - 0.01 ##right
left = xl[i][0] - xl[i][1] + 0.01 ##left
itv.append([right,left])
itv.sort()
ass = 0
tt = -1e10
for i in range(N):
if tt < itv[i][1]:
ass += 1
tt = itv[i][0]
print(ass) | N = int(eval(input()))
xl = []
for i in range(N):
xl.append(list(map(int,input().split())))
itv = []
for i in range(N):
right = xl[i][0] + xl[i][1] ##right
left = xl[i][0] - xl[i][1] ##left
itv.append([right,left])
itv.sort()
ass = 0
tt = -1e10
for i in range(N):
if tt <= itv[i][1]:
ass += 1
tt = itv[i][0]
print(ass)
| p02796 |
n = int(eval(input()))
m_list = []
for i in range(n):
X, L = list(map(int, input().split()))
m_list.append([X-L,X+L])
m_list = sorted(m_list, key=lambda x:x[1])
def MachineArrangementCheck():
length = len(m_list)
# 配列の上限エラー対策
for i in range(length):
if i != length - 1:
# m1の上限とm２の下限が接するかを確認
if (m_list[i+1][0] - m_list[i][1]) < 0:
del m_list[i+1]
return False
return True
while MachineArrangementCheck() == False:
continue
print((len(m_list))) | n = int(eval(input()))
m_list = []
for i in range(n):
x,l = list(map(int, input().split()))
m_list.append([x-l, x+l])
m_list = sorted(m_list,key= lambda x:x[1])
result = 0
cur_pos = -1000000000
for min,max in m_list:
if cur_pos <= min:
result += 1
cur_pos = max
print(result) | p02796 |
# https://atcoder.jp/contests/keyence2020/tasks/keyence2020_b
N = int(eval(input()))
X, L = [], []
for i in range(N):
x, l = list(map(int, input().split()))
X.append([x, l])
X.sort(key=lambda x: x[0], reverse=False)
L = [x[1] for x in X]
X = [x[0] for x in X]
ans = 0
cur = -float('inf')
for i in range(N):
if (cur <= X[i] - L[i]):
ans += 1
cur = X[i] + L[i]
print(ans) | import sys
N = int(eval(input()))
a = sorted([(x + l, x - l) for x, l in (list(map(int, l.split())) for l in sys.stdin)])
last = a[0][0]
ans = 1
for r, l in a[1:]:
if last <= l:
ans += 1
last = r
print(ans) | p02796 |
N = int(eval(input()))
XL = [tuple(map(int, input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0])
hold = [XL[0]]
ans = 1
for i in range(1, N):
if hold[-1][0] + hold[-1][1] > XL[i][0] - XL[i][1]:
if hold[-1][0] + hold[-1][1] < XL[i][0] + XL[i][1]:
continue
else:
hold.append(XL[i])
else:
ans += 1
hold.append(XL[i])
print(ans) | N = int(eval(input()))
XL = [tuple(map(int,input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0] + x[1])
right = -float('inf')
ans = 0
for x, l in XL:
s, t = x-l, x+l
if s >= right:
right = t
ans += 1
print(ans) | p02796 |
import math , sys
N = int( eval(input()) )
X = []
for i in range(N):
A , B = list(map(int, input().split()))
X.append([i , A-B , A , A+B])
X.sort(key=lambda x: x[3])
Y = X.pop(0)
Ri = Y[-1]
ans = 1
j=0
while len(X)>0:
Y = X.pop(0)
if Y[1]>=Ri:
ans+=1
Ri = Y[-1]
print(ans)
| import math , sys
N = int( eval(input()) )
X = []
for i in range(N):
A , B = list(map(int, input().split()))
X.append([i , A-B , A , A+B])
X.sort(key=lambda x: x[3])
Y = X[0]
Ri = Y[-1]
ans = 1
j=0
for i in range(1,N):
Y = X[i]
if Y[1] >= Ri:
ans+=1
Ri = Y[-1]
print(ans)
| p02796 |
N = int(eval(input()))
LR = [[int(i) for i in input().split()] for _ in range(N)]
# 区間を右端の小さい順にソート
LR = sorted([(x-l, x+l) for x,l in LR],key=lambda x: x[1])
ans = 0
# 現在選んでいる区間の内、最も右にある区間の右端
cur_R = -float("inf")
for i in range(N):
# 区間が被るとき
if cur_R > LR[i][0]:
continue
ans += 1
cur_R = LR[i][1]
print(ans) | import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
LR = [[int(i) for i in input().split()] for _ in range(N)]
# 区間を右端の小さい順にソート
LR = sorted([(x-l, x+l) for x,l in LR],key=lambda x: x[1])
ans = 0
# 現在選んでいる区間の内、最も右にある区間の右端
cur_R = -float("inf")
for i in range(N):
# 区間が被るとき
if cur_R > LR[i][0]:
continue
ans += 1
cur_R = LR[i][1]
print(ans)
if __name__ == "__main__":
main() | p02796 |
def trush(XL):
pt,output = 1,len(XL)
while pt < len(XL)-1:
if XL[pt-1][2] > XL[pt][1] and XL[pt][2] > XL[pt+1][1]:
XL = XL[:pt] + XL[pt+1:]
output -= 1
else:
pt += 1
pt = 0
while pt < len(XL)-1:
if XL[pt][2] > XL[pt+1][1]:
if XL[pt][0]-XL[pt][1] > XL[pt+1][0]-XL[pt+1][1]:
XL = XL[:pt] + XL[pt+1:]
else:
XL = XL[:pt+1] + XL[pt+2:]
output -= 1
else:
pt += 1
return output
def main():
N = int(eval(input()))
XL = [list(map(int,input().split())) for _ in range(N)]
for i in range(N):
XL[i] = [XL[i][0],XL[i][0]-XL[i][1],XL[i][0]+XL[i][1]]
XL.sort(key = lambda x:x[0])
ans = trush(XL)
print(ans)
if __name__ == "__main__":
main()
| def cal(XL):
N = len(XL)
XL.sort(key = lambda x:x[0])
for i in range(N):
XL[i] = [XL[i][0],XL[i][0]-XL[i][1],XL[i][0]+XL[i][1]]
OP = [XL[0]]
for i in range(1,N):
if OP[len(OP)-1][2] > XL[i][1]:
if OP[len(OP)-1][2] < XL[i][2]:
#右方向により腕が伸びている方がより邪魔
pass
else:
OP.pop()
OP.append(XL[i])
else:
OP.append(XL[i])
return len(OP)
def main():
N = int(eval(input()))
XL = [list(map(int,input().split())) for _ in range(N)]
ans = cal(XL)
print(ans)
if __name__ == "__main__":
main()
| p02796 |
n=int(eval(input()))
L=[]
for i in range(n):
x,l=list(map(int,input().split()))
L.append([x-l,x+l])
L.sort(key=lambda x:x[1])
ans=1
border=L[0][1]
for i,j in enumerate(L[1:]):
if border<=j[0]:
ans+=1
border=j[1]
print(ans)
| n=int(eval(input()))
L=[]
for i in range(n):
x,l=list(map(int,input().split()))
L.append([x-l,x+l])
L.sort(key=lambda x:x[1])
ans=1
bef=L[0][1]
for i in range(1,n):
if bef<=L[i][0]:
bef=L[i][1]
ans+=1
print(ans) | p02796 |
n=int(eval(input()))
robotLEFT=[]
robotRIGHT={}
for _ in range(n):
x,l=list(map(int,input().split()))
if x-l not in robotLEFT:
robotLEFT.extend([x-l])
robotRIGHT[x-l]=x+l
else:
robotRIGHT[x-l]=min(robotRIGHT[x-l],x+l)
robotLEFT.sort()
#print(robotRIGHT)
#print(robotLEFT)
temp=robotLEFT[0]
LL=temp-2
RR=temp-1
cnt=0
for item in robotLEFT:
#print(LL,RR,cnt)
if RR<=item:
cnt+=1
LL=item
RR=robotRIGHT[LL]
else:
if RR>=robotRIGHT[item]:
RR=robotRIGHT[item]
LL=item
print(cnt)
| n=int(eval(input()))
robot=[]
for _ in range(n):
x,l=list(map(int,input().split()))
robot.append([x-l,x+l])
robot.sort()
RR=robot[0][0]-1
cnt=0
for item in robot:
if RR<=item[0]:
cnt+=1
RR=item[1]
elif RR>=item[1]:
RR=item[1]
print(cnt)
| p02796 |
n = int(eval(input()))
a = []
for _ in range(n):
a.append(list(map(int,input().split())))
d = [[a[i][0]-a[i][1],a[i][0]+a[i][1]] for i in range(n)]
d = sorted(d, key = lambda x: x[1])
#print(d)
b = [-100000000000000000]
c = [0]
for i in range(n):
for j in range(len(b)):
if d[i][0] >= b[j]:
if d[i][1] in b:
c[b.index(d[i][1])] = c[j] + 1
else:
b.append(d[i][1])
c.append(c[j]+1)
#print(b)
#print(c)
print((max(c)))
| n = int(eval(input()))
a = []
for _ in range(n):
a.append(list(map(int,input().split())))
d = [[a[i][0]-a[i][1],a[i][0]+a[i][1]] for i in range(n)]
d = sorted(d, key = lambda x: x[1])
#print(d)
b = [-100000000000000000]
c = [0]
for i in range(n):
for j in range(len(b)):
if d[i][0] >= b[j]:
b = [d[i][1]]
c = [c[j] + 1]
break
#print(b)
#print(c)
print((max(c)))
| p02796 |
N=int(eval(input()))
XL=sorted([list(map(int,input().split())) for i in range(N)],key=sum)
count=0
left=-10**9
for x,l in XL:
if left<=x-l:
count+=1
left=x+l
print(count) | N=int(eval(input()))
XL=sorted([list(map(int,input().split())) for i in range(N)],key=lambda x:x[0]+x[1])
count=0
left=-10**9
for x,l in XL:
if left<=x-l:
count+=1
left=x+l
print(count) | p02796 |
n = int(eval(input()))
ls = []
for i in range(n):
x,l = list(map(int,input().split()))
ls.append([x-l,l+x])
r = n
ls = sorted(ls, key=lambda item: item[1])
for i in range(1,n):
if ls[i][0] < ls[i-1][1]:
ls[i][1] = ls[i-1][1]
r -=1
print(r) | n = int(eval(input()))
ls = []
for i in range(n):
x,l = list(map(int,input().split()))
ls.append([x-l,l+x])
ls = sorted(ls, key=lambda item: item[1])
ans = n
for i in range(1,n):
if ls[i][0] < ls[i-1][1]:
ls[i][1] = ls[i-1][1]
ans -=1
print(ans) | p02796 |
n = int(eval(input()))
ls = []
for i in range(n):
x,l = list(map(int,input().split()))
ls.append([x-l,l+x])
ls = sorted(ls, key=lambda item: item[1])
ans = n
for i in range(1,n):
if ls[i][0] < ls[i-1][1]:
ls[i][1] = ls[i-1][1]
ans -=1
print(ans) | n = int(eval(input()))
ls = []
for i in range(n):
x,l = list(map(int,input().split()))
ls.append([x-l,l+x])
ls = sorted(ls, key=lambda x: x[1])
ans = n
for i in range(1,n):
if ls[i][0] < ls[i-1][1]:
ls[i][1] = ls[i-1][1]
ans -=1
print(ans) | p02796 |
from functools import reduce
N = int(eval(input()))
XL = [list(map(int,input().split())) for _ in range(N)]
area = sorted([[x-l,x+l] for x,l in XL], key=lambda x: x[1])
area_ = [area[0]]
for i in range(1,N):
if reduce(lambda x,y: x and (area[i][0]>=y[1]), area_, True):
area_.append(area[i])
print((len(area_))) | N = int(eval(input()))
XL = sorted([list(map(int,input().split())) for _ in range(N)], key=lambda x: x[0]+x[1])
n = 1
S_,T_ = XL[0][0]-XL[0][1], XL[0][0]+XL[0][1]
for i in range(1,N):
S,T = XL[i][0]-XL[i][1], XL[i][0]+XL[i][1]
if not (S < T_):
n += 1
S_,T_ = S,T
print(n) | p02796 |
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(eval(input()))
def MAP() : return list(map(int,input().split()))
def LIST() : return list(MAP())
n = INT()
x = [[0]*2 for i in range(n)]
for i in range(n):
x[i][0], x[i][1] = MAP()
x.sort()
tmp = -inf
ans = n
for i in range(n):
if tmp > x[i][0] - x[i][1]:
ans -= 1
tmp = min(tmp, x[i][0] + x[i][1])
else:
tmp = x[i][0] + x[i][1]
print(ans) | from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(eval(input()))
def MAP() : return list(map(int,input().split()))
def LIST() : return list(MAP())
n = INT()
ls = []
for i in range(n):
x, l = MAP()
ls.append([x-l, x+l])
ls = sorted(ls, key=itemgetter(1))
ans = n
for i in range(1, n):
if ls[i][0] < ls[i-1][1]:
ls[i][1] = ls[i-1][1]
ans -= 1
print(ans) | p02796 |
N, *XL = list(map(int, open(0).read().split()))
A = sorted(((x + l, x - l) for x, l in zip(*[iter(XL)] * 2)), key=lambda x: x[0])
ans = 0
cur = -10 ** 9
for t, s in A:
if cur <= s:
cur = t
ans += 1
print(ans) | INF = float("inf")
def interval_scheduling(A):
A.sort(key=lambda x: x[1])
res = []
cur = -INF
for s, t in A:
if cur <= s:
cur = t
res.append((s, t))
return res
N, *XL = list(map(int, open(0).read().split()))
A = [(x - l, x + l) for x, l in zip(*[iter(XL)] * 2)]
print((len(interval_scheduling(A)))) | p02796 |
N = int(eval(input()))
A = [list(map(int,input().split())) for _ in range(N)]
B = sorted([[A[i][0]-A[i][1],A[i][0]+A[i][1]] for i in range(N)],key=lambda x:x[1])
cur = 1
C = [B[0]]
while cur<N:
if B[cur][0]>=C[-1][1]:
C.append(B[cur])
cur += 1
print((len(C))) | N = int(eval(input()))
A = [list(map(int,input().split())) for _ in range(N)]
B = sorted([(A[i][0]-A[i][1],A[i][0]+A[i][1]) for i in range(N)],key=lambda x:x[0],reverse=True)
B = sorted(B,key=lambda x:x[1])
cnt = 1
cur = B[0][1]
for i in range(1,N):
if B[i][0]>=cur:
cnt += 1
cur = B[i][1]
print(cnt) | p02796 |
N = int(eval(input()))
A = [list(map(int,input().split())) for _ in range(N)]
B = sorted([(A[i][0]-A[i][1],A[i][0]+A[i][1]) for i in range(N)],key=lambda x:x[0],reverse=True)
B = sorted(B,key=lambda x:x[1])
cnt = 1
cur = B[0][1]
for i in range(1,N):
if B[i][0]>=cur:
cnt += 1
cur = B[i][1]
print(cnt) | N = int(eval(input()))
X = [list(map(int,input().split())) for _ in range(N)]
A = []
for i in range(N):
x,l = X[i]
A.append((x-l,x+l))
B1 = sorted(A,key=lambda x:x[1])
B1 = [(B1[i][0],B1[i][1],i) for i in range(N)]
B2 = sorted(B1,key=lambda x:x[0])
hist = [0 for _ in range(N)]
cnt = 0
i = 0
for k in range(N):
if hist[k]==0:
r = B1[k][1]
hist[k] = 1
cnt += 1
while i<N:
l,j = B2[i][0],B2[i][2]
if hist[j]==1:
i += 1
continue
if l<r:
hist[j] = 1
i += 1
else:
break
print(cnt) | p02796 |
N = int(eval(input()))
XL = [list(map(int, input().split())) for _ in range(N)]
XL = sorted(XL, key=lambda x: x[0]+x[1])
ans = [0]
for i in range(1, N):
can_put = True
for j in ans:
# ぶつかった場合
if XL[i][0] - XL[i][1] < XL[j][0] + XL[j][1] and XL[j][0] - XL[j][1] < XL[i][0] + XL[i][1]:
can_put = False
if can_put:
ans.append(i)
print((len(ans))) | N = int(eval(input()))
XL = [list(map(int, input().split())) for _ in range(N)]
XL = sorted(XL, key=lambda x: x[0]+x[1])
ans = 1
right = XL[0][0] + XL[0][1]
for i in range(1, N):
if right <= XL[i][0] - XL[i][1]:
right = XL[i][0] + XL[i][1]
ans += 1
print(ans) | p02796 |
n = int(eval(input()))
lis = []
for i in range(n):
a,b =list(map(int,input().split()))
lis.append([a-b,a+b])
lis.sort(key = lambda x:x[1])
dp = {(-2 * 10 ** 9,0)}
for aa,bb in lis:
now = set()
for nowa,ans in dp:
if nowa <= aa:
now.add((bb,ans+1))
now.add((nowa,ans))
dp = now
an = 0
for aaa,ans in dp:
an = max(an,ans)
print(an) | n = int(eval(input()))
lis = []
for i in range(n):
a,b =list(map(int,input().split()))
lis.append([a-b,a+b])
lis.sort(key = lambda x:x[1])
ans = 0
now = -10 ** 10
for a,b in lis:
if now <= a:
ans += 1
now = b
print(ans) | p02796 |
n = int(eval(input()))
ra = []
for i in range(n):
x,l = list(map(int,input().split()))
ra.append([x-l,x+l])
ra.sort(key = lambda x:x[0])
ans = 1
t = ra[0][1]
for i in range(n):
if ra[i][0] >= t:
ans += 1
t = ra[i][1]
else:
t = min(t,ra[i][1])
print(ans) | n = int(eval(input()))
ra = []
for i in range(n):
x,l = list(map(int,input().split()))
ra.append([x-l,x+l])
ra.sort(key=lambda x:x[1])
t = ra[0][1]
ans = 1
for i in range(1,n):
if ra[i][0] >= t:
ans += 1
t = ra[i][1]
print(ans) | p02796 |
import sys
import math
import copy
from functools import lru_cache
sys.setrecursionlimit(1000000000)
def solve(robots):
total = len(robots)
local_robots = copy.deepcopy(robots)
for i, current in enumerate(robots):
if count_collisions(current, local_robots) > 0:
local_robots.remove(current)
total -= 1
else:
break
return total
def count_collisions(current, robots):
count = 0
for robot in robots:
if collision(current[0], current[1], robot[0], robot[1]):
count += 1
return count
@lru_cache(maxsize=None)
def collision(currentX, currentL, robotX, rootL):
return robotX < currentX and robotX+ rootL > currentX - currentL or currentX < robotX and currentX + currentL > robotX - rootL
N, = list(map(int, input().split()))
ROBOTS = [list(map(int, input().split())) for _ in range(N)]
ROBOTS = list(reversed(sorted(ROBOTS, key=lambda x: count_collisions(x, ROBOTS))))
print((solve(ROBOTS))) | import sys
import math
sys.setrecursionlimit(1000000000)
def solve(robots):
total = len(robots)
prev = None
for current in robots:
if prev and prev[0] + prev[1] > current[0] - current[1]:
total -= 1
else:
prev = current
return total
N, = list(map(int, input().split()))
ROBOTS = [list(map(int, input().split())) for _ in range(N)]
ROBOTS = sorted(ROBOTS, key=lambda x: x[0] + x[1])
print((solve(ROBOTS))) | p02796 |
import copy
n = int(eval(input()))
x = sorted([list(map(int, input().split())) for i in range(n)])
y = copy.deepcopy(x)
j = 0
while j < len(x)-1:
if x[j][0]+x[j][1] > x[j+1][0]-x[j+1][1]:
y.pop(j+1)
j += 2
continue
j += 1
print((len(y))) | N = int(eval(input()))
XL = [list(map(int, input().split())) for i in range(N)]
LR = [[x - l, x + l] for x, l in XL]
LR.sort(key=lambda x: x[1])
ans = 0
prev = -float("INF")
for l, r in LR:
if prev <= l:
ans += 1
prev = r
print(ans) | p02796 |
N = int(eval(input()))
robot_list = []
for i in range(N):
robot_list.append(list(map(int, input().split())))
def choose_coordinate(now_edge):
global robot_list
global res
next_edge = pow(10, 10)
for i in range(N):
robot_right_edge = robot_list[i][0] + robot_list[i][1]
robot_left_edge = robot_list[i][0] - robot_list[i][1]
if robot_left_edge >= now_edge and robot_right_edge <= next_edge:
next_edge = robot_right_edge
if next_edge == pow(10, 10):
return
else:
res += 1
choose_coordinate(next_edge)
res = 0
choose_coordinate(- pow(10,10))
print(res) | N = int(eval(input()))
robot_list = []
for i in range(N):
X, L = list(map(int, input().split()))
left_edge = X - L
right_edge = X + L
robot_list.append([left_edge, right_edge])
robot_list.sort(key=lambda x: x[1])
res = 0
index = - pow(10, 10)
for i in range(N):
if robot_list[i][0] >= index:
index = robot_list[i][1]
res += 1
print(res) | p02796 |
N = int(eval(input()))
XL = [list(map(int, input().split())) for _ in range(N)]
length = []
for i in range(N):
s = XL[i][0] - XL[i][1]
f = XL[i][0] + XL[i][1]
length.append([s, f])
length = sorted(length, key=lambda x:x[1])
ans = 0
f = - (10**9+7)
for i in range(N):
if f <= length[i][0]:
ans += 1
f = length[i][1] - 0.5
print(ans) | N = int(eval(input()))
XL = [list(map(int, input().split())) for _ in range(N)]
XL.sort(key=lambda x: sum(x))
f = -99999999999
ans = 0
for x, l in XL:
if x - l >= f:
ans += 1
f = x + l
print(ans) | p02796 |
n = int(eval(input()))
xl_lis = [list(map(int,input().split())) for i in range(n)]
tempx = -(10**10)
ans = 0
xl_lis.sort()
# print(xl_lis)
for i in xl_lis:
if tempx > i[0] - i[1] and tempx < i[0] + i[1]:
ans += 1
elif tempx > i[0] - i[1] and tempx >= i[0] + i[1]:
ans += 1
tempx = i[0] + i[1]
else:
tempx = i[0] + i[1]
print((n-ans))
| n = int(eval(input()))
xl_lis = [list(map(int,input().split())) for i in range(n)]
tempx = -(10**10)
ans = 0
xl_lis.sort()
# print(xl_lis)
for i in xl_lis:
a = i[0]
b = i[1]
if tempx > a - b and tempx < a + b:
ans += 1
elif tempx > a - b and tempx >= a + b:
ans += 1
tempx = a + b
else:
tempx = a + b
print((n-ans))
| p02796 |
n = int(eval(input()))
xl = []
lr = []
for _ in range(n):
x, l = list(map(int, input().split()))
xl.append([x, l])
lr.append([x-l, x+l])
lr.sort(key=lambda x: x[1])
ans = 0
r = -float("inf")
for i in range(n):
if r <= lr[i][0]:
ans += 1
r = lr[i][1]
print(ans)
| n = int(eval(input()))
d = []
for _ in range(n):
x, l = list(map(int, input().split()))
d.append([x-l, x+l])
d.sort(key=lambda x: x[1])
c = -float("inf")
ans = 0
for i in range(n):
if c <= d[i][0]:
c = d[i][1]
ans += 1
print(ans)
| p02796 |
# -*- coding: utf-8 -*-
n = int(eval(input()))
a = []
b = []
b2 = []
c = []
count = 0
for i in range(n):
x,y = list(map(int,input().split()))
a.append([x,y,x+y])
a.sort(key=lambda x: x[2])
for i in a:
c = b.copy()
if len(b) > 0:
if i[0]-i[1] <= max(b):
b.extend(list(range(i[0]-i[1], i[0]+i[1])))
b2 = b.copy()
b = list(set(b))
if len(b2) != len(b):
b = c.copy()
count += 1
else:
b = []
b.extend(list(range(i[0]-i[1], i[0]+i[1])))
else:
b.extend(list(range(i[0]-i[1], i[0]+i[1])))
print((n - count)) | # -*- coding: utf-8 -*-
n = int(eval(input()))
a = []
b = []
b2 = []
c = []
count = 0
for i in range(n):
x,y = list(map(int,input().split()))
a.append([x,y,x+y])
a.sort(key=lambda x: x[2])
for i in a:
c = b.copy()
if len(b) > 0:
if i[0]-i[1] <= max(b):
#b.extend(list(range(i[0]-i[1], i[0]+i[1])))
#b2 = b.copy()
#b = list(set(b))
#if len(b2) != len(b):
#b = c.copy()
count += 1
else:
b = []
b.extend(list(range(i[0]-i[1], i[0]+i[1])))
else:
b.extend(list(range(i[0]-i[1], i[0]+i[1])))
print((n - count)) | p02796 |
n = int(eval(input()))
res = n
num_list = []
max_list = []
for i in range(n):
a,b = list(map(int,input().split(" ")))
if i == 0:
for i in range(a-b,a+b+1):
num_list.append(i)
elif (a or b) in num_list:
res -= 1
else:
for i in range(a-b,a+b+1):
num_list.append(i)
sorted(num_list)
print(res)
| n = int(eval(input()))
min_list = []
max_list = []
middle_list = []
for i in range(n):
a,b = list(map(int,input().split(" ")))
min_list.append(a - b)
max_list.append(a + b)
middle_list.append(a)
count = 0
count_b = 0
for j,k in enumerate(middle_list):
if j == 0:
for i in range(n):
if min_list[i] <= k <= max_list[i]:
count += 1
else:
for i in range(n):
if min_list[i] <= k <= max_list[i]:
count_b += 1
count = max(count,count_b)
count_b = 0
res = n - (count - 1)
print(res)
| p02796 |
import sys
def main():
input = sys.stdin.readline
N = int(eval(input()))
robots = dict()
x_list = []
duplicates = dict()
for i in range(N):
x, l = list(map(int, input().split()))
x_list.append(x)
robots[x] = l
duplicates[x] = 0
x_list.sort()
n_duplicates = 0
for i, x in enumerate(x_list):
arm = robots[x]
for y in x_list[i:]:
if x == y:
continue
if x+arm > y-robots[y]:
duplicates[x] += 1
duplicates[y] += 1
n_duplicates += 2
n_d_list = sorted(list(duplicates.values()), reverse=True)
count = 0
for d in n_d_list:
if n_duplicates < 1:
break
n_duplicates -= 2 * d
count += 1
print((N - count))
if __name__ == '__main__':
main()
| import sys
def main():
input = sys.stdin.readline
N = int(eval(input()))
robots = list()
for i in range(N):
x, arm = list(map(int, input().split()))
right = x+arm
robots.append([x, right])
robots.sort(key=lambda x: x[1])
count = 0
last_r = -10**10
for x, r in robots:
l = x - (r - x)
if l < last_r:
count += 1
else:
last_r = r
print((N - count))
if __name__ == '__main__':
main()
| p02796 |
n = int(eval(input()))
robot_arms = []
for _ in range(n):
x, l = list(map(int, input().split()))
robot_arms.append([x-l, x+l])
robot_arms = sorted(robot_arms, key=lambda x: x[1])
l, r = 0, 1
cnt = 1
while r < n:
if robot_arms[l][1] <= robot_arms[r][0]:
l = r
r += 1
cnt += 1
else:
r += 1
print(cnt) | n = int(eval(input()))
robots = []
for _ in range(n):
x, l = list(map(int, input().split()))
robots.append([x-l, x+l])
robots = sorted(robots, key=lambda x: x[1])
cnt = 1
current_end = robots[0][1]
for i in range(1, n):
if current_end <= robots[i][0]:
cnt += 1
current_end = robots[i][1]
print(cnt) | p02796 |
n = int(eval(input()))
robots = []
for i in range(n):
x_tmp, l_tmp = (int(i) for i in input().split())
robots.append({'x': x_tmp, 'l': l_tmp})
robots_sorted = sorted(robots, key=lambda x: x['x'])
ans = n
i = 0
while(i < n-1):
if((robots_sorted[i]['x'] + robots_sorted[i]['l']) > (robots_sorted[i+1]['x'] - robots_sorted[i+1]['l'])):
if(i == 0):
if(robots_sorted[0]['l'] > robots_sorted[1]['l'] * 2):
robots_sorted.pop(i)
else:
robots_sorted.pop(i+1)
elif(i == n-2):
if(robots_sorted[n-2]['l'] * 2 >= robots_sorted[n-1]['l']):
robots_sorted.pop(i)
else:
robots_sorted.pop(i+1)
elif(robots_sorted[i]['l'] > robots_sorted[i+1]['l']):
robots_sorted.pop(i)
else:
robots_sorted.pop(i+1)
i += -1
n += -1
i += 1
print(n)
| n = int(eval(input()))
robots = []
for i in range(n):
x_tmp, l_tmp = (int(i) for i in input().split())
robots.append([x_tmp - l_tmp, x_tmp + l_tmp])
robots.sort()
ans = n
right = robots[0][1]
for i in range(n-1):
if(robots[i+1][0] < right):
ans -= 1
right = min(right, robots[i+1][1])
else:
right = robots[i+1][1]
print(ans)
| p02796 |
N = int(eval(input()))
R = sorted([list(map(int, input().split())) for i in range(N)])
T = []
for i in range(N):
T.append([R[i][0] + R[i][1], R[i][0] - R[i][1]])
T.sort(reverse=True)
while len(T) - 1 > 0:
t = T.pop()
i = 1
while len(T) and t[0] > T[-1][1]:
N -= 1
i += 1
T.pop()
print(N) | N = int(eval(input()))
XL = [list(map(int, input().split())) for _ in range(N)]
A = []
for x, l in XL:
A.append([x + l, x - l])
A.sort()
B = []
i = 0
while True:
B.append(A[i])
if i == N - 1:
break
j = 1
while True:
if A[i][0] > A[i + j][1]:
j += 1
if i + j == N:
break
continue
else:
break
if i + j == N:
break
i = i + j
print((len(B))) | p02796 |
n = int(eval(input()))
xs = []
ls = []
for _ in range(n):
x, l = list(map(int, input().split()))
xs.append(x)
ls.append(l)
ok = [True for _ in range(n)]
def f(i):
rs = []
for j in range(n):
if i == j or not ok[j]:
continue
if xs[i] - ls[i] < xs[j] + ls[j] and xs[j] - ls[j] < xs[i] + ls[i]:
rs.append(j)
return rs
for i in range(n):
if not ok[i]:
continue
rs = f(i)
if len(rs) == 1:
j = rs[0]
ts = f(j)
if len(ts) == 0:
ok[i] = False
else:
ok[j] = False
elif len(rs) > 1:
ok[i] = False
c = 0
for v in ok:
if v:
c += 1
print(c)
| n = int(eval(input()))
robots = []
for _ in range(n):
x, l = list(map(int, input().split()))
robots.append((x + l, x - l))
robots.sort()
cur = -float('inf')
ans = 0
for i in range(n):
t, s = robots[i]
if cur <= s:
ans += 1
cur = t
print(ans) | p02796 |
from operator import itemgetter
from itertools import permutations
N = int(eval(input()))
XL = [tuple(map(int, input().split())) for _ in range(N)]
XL = sorted(XL, key=itemgetter(0))
for i in range(N):
for remove in permutations(XL, i):
remained = [i for i in XL if i not in remove]
edge = []
for remain in remained:
x, l = remain
edge.append(x-l)
edge.append(x+l)
if edge == sorted(edge):
print((len(remained)))
exit() | n = int(eval(input()))
xl = [list(map(int, input().split())) for _ in range(n)]
le = [[p[0]-p[1], p[0]+p[1]] for p in xl]
le.sort(key = lambda x : x[1])
ans = 0
right = -(10 ** 9) - 1
for i in range(n):
if right <= le[i][0]:
ans += 1
right = le[i][1]
print(ans) | p02796 |
n = int(eval(input()))
xl = [list(map(int, input().split())) for _ in range(n)]
le = [[p[0]-p[1], p[0]+p[1]] for p in xl]
le.sort(key = lambda x : x[1])
ans = 0
right = -(10 ** 9) - 1
for i in range(n):
if right <= le[i][0]:
ans += 1
right = le[i][1]
print(ans) | n = int(eval(input()))
ls = []
for _ in range(n):
x, l = list(map(int, input().split()))
ls.append([x-l, x+l])
ls.sort(key=lambda x: x[1])
ans = n
for i in range(1, n):
if ls[i][0] < ls[i-1][1]:
ls[i][1] = ls[i-1][1]
ans -= 1
print(ans)
| p02796 |
N = int(eval(input()))
robots, count = [], 0
for x in range(N):
X, L = list(map(int, input().split()))
robots.append((X+L, X-L))
robots.sort()
node = -10**12
for end, start in robots:
if start >= node:
node = end
count += 1
print(count) | import sys
input = sys.stdin.readline
n = int(eval(input()))
robots = []
for i in range(n):
x, l = [int(item) for item in input().split()]
robots.append((x+l, x-l))
robots.sort()
cnt = 0
node = -10**12
for end, start in robots:
if start >= node:
node = end
cnt += 1
print(cnt) | p02796 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
robots = []
for i in range(n):
x, l = [int(item) for item in input().split()]
robots.append((x+l, x-l))
robots.sort()
cnt = 0
node = -10**12
for end, start in robots:
if start >= node:
node = end
cnt += 1
print(cnt) | import sys
input = sys.stdin.readline
N = int(eval(input()))
robots, count = [], 0
for x in range(N):
X, L = list(map(int, input().split()))
robots.append((X+L, X-L))
robots.sort()
node = -10**12
for end, start in robots:
if start >= node:
node = end
count += 1
print(count)
| p02796 |
n = int(eval(input()))
xl = [list(map(int, input().split())) for _ in range(n)]
lr = []
for i in range(n):
l = max(xl[i][0] - xl[i][1], 0)
r = max(xl[i][0] + xl[i][1], 0)
lr.append([r, l])
lr = sorted(lr)
keep = [False] * n
# print(lr)
cur = 0
for i in range(n):
if cur <= lr[i][1]:
keep[i] = True
cur = lr[i][0]
'''
for j in range(n - 1):
if keep[j]:
if lr[j][0] == lr[j + 1][0]:
keep[j + 1] = False
elif lr[j][0] < lr[j + 1][0]:# < lr[j][1]:
keep[j + 1] = False
'''
#print(keep)
ans = sum(1 for x in range(n) if keep[x])
print(ans)
| n = int(eval(input()))
xl = [list(map(int, input().split())) for _ in range(n)]
lr = []
for i in range(n):
l = max(xl[i][0] - xl[i][1], 0)
r = max(xl[i][0] + xl[i][1], 0)
lr.append([l, r])
lr.sort(key=lambda x: x[1])
keep = [False] * n
cur = 0
for i in range(n):
if cur <= lr[i][0]:
keep[i] = True
cur = lr[i][1]
ans = sum(keep)
print(ans)
| p02796 |
N = int(eval(input()))
XL = [tuple(map(int, input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0]+x[1])
right = -10**9
removed = 0
for x, l in XL:
if x-l < right:
removed += 1
else:
right = x+l
print((N-removed))
| N = int(eval(input()))
XL = [tuple(map(int, input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0] + x[1])
ans = 0
prev = - 10**9
for x, l in XL:
if prev <= x - l:
ans += 1
prev = x + l
print(ans)
| p02796 |
from collections import defaultdict
n = int(eval(input()))
rob = defaultdict(list)
for i in range(n):
x,l = list(map(int,input().split()))
rob[x] = [l,x-l,x+l]
rob = sorted(list(rob.items()), key=lambda x:x[1])
tmp = []
for idx in range(0,len(rob)-1):
i,[l,left,right] = rob[idx]
for idx2 in range(idx+1,len(rob)):
j,[_,_,_] = rob[idx2]
if left < j < right:
tmp.append(idx2)
print((len(rob)-len(set(tmp)))) | n = int(eval(input()))
rob = []
for i in range(n):
x,l = list(map(int,input().split()))
rob.append([x-l,x+l])
rob.sort()
ans = n
right = rob[0][1]
for i,[l,r] in enumerate(rob):
if i == 0:
continue
if l < right:
ans -= 1
right = min(right,r)
else:
right = r
print(ans) | p02796 |
def main():
N, *XL = list(map(int, open(0).read().split()))
# print(N, XL)
robots = [0]*N
for i in range(N):
X, L = XL[2 * i + 0], XL[2 * i + 1]
robots[i] = (i, X - L, X + L)
robots.sort(key=lambda x: x[2])
# print(robots)
remains = []
for robot in robots:
# print('remains={}, robot={}'.format(remains, robot))
conflict = False
l = robot[1]
r = robot[2]
for remain in remains:
# print(l, r, remain)
if remain[1] <= l and l < remain[2]:
# print(robot, remain, l, remain[2], remain[1], r)
conflict = True
break
if remain[1] < r and r < remain[2]:
# print(robot, remain, l, remain[2], remain[1], r)
conflict = True
break
if l <= remain[1] and remain[1] < r:
conflict = True
break
if l < remain[2] and remain[2] < r:
conflict = True
break
if not conflict:
remains.append(robot)
print((len(remains)))
if __name__ == '__main__':
main()
| def main():
N, *XL = list(map(int, open(0).read().split()))
# print(N, XL)
robots = [0]*N
for i in range(N):
X, L = XL[2 * i + 0], XL[2 * i + 1]
robots[i] = (X - L, X + L)
robots.sort(key=lambda x: x[1])
# print(robots)
ans = 0
last = robots[0][0] - 1
for robot in robots:
if last <= robot[0]:
last = robot[1]
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p02796 |
n = int(eval(input()))
ar = []
z = 0
for i in range(n):
a,b = list(map(int,input().split(" ")))
count = 0
br = []
for i in range(a-(b-1),a+b):
if i in ar:
count += 1
break
br.append(i)
if count == 0:
z += 1
for r in br:
ar.append(r)
print(z) | n = int(eval(input()))
ar = []
mi = 0
mx = 0
count = 1
for i in range(n):
a,b = list(map(int,input().split(" ")))
br = [a+b,a-b]
ar.append(br)
ar.sort()
for i,r in enumerate(ar):
if i == 0:
mx = r[0]
else:
if mx <= r[1]:
count += 1
mx = r[0]
print(count) | p02796 |
N = int(eval(input()))
l = [list(map(int,input().split())) for _ in range(N)]
cnt = 0
for i in l:
x = 0 if i[0]-i[1] < 0 else i[0]-i[1]
i[1] = i[0]+i[1]
i[0] = x
l.sort(key=lambda x:x[1])
while l:
cnt+=1
x = l.pop(0)
delete = []
for i in range(len(l)):
if x[1] > l[i][0]:
delete.append(i)
for i in range(len(delete)):
l.pop(delete[i]-i)
print(cnt) | N = int(eval(input()))
l = [list(map(int,input().split())) for _ in range(N)]
ans = N
for i in l:
x = 0 if i[0]-i[1] < 0 else i[0]-i[1]
i[1] = i[0]+i[1]
i[0] = x
l.sort(key=lambda x:x[1])
right = 0
for i in range(N):
if right > l[i][0]:
ans-=1
else:
right = l[i][1]
print(ans) | p02796 |
N = int(eval(input()))
XL = [list(map(int, input().split())) for _ in range(N)]
def compare(item):
return item[1]
newXL = sorted([[x-l, x+l] for x, l in XL], key=compare)
memo = [0]
for i in range(N):
flag = True
for j in memo:
if newXL[i][0] < newXL[j][1]:
flag = False
if flag:
memo.append(i)
print((len(memo))) | N = int(eval(input()))
XL = [list(map(int, input().split())) for _ in range(N)]
newXL = sorted([[x-l, x+l] for x, l in XL], key=lambda x:x[1])
previous = 0
total = 1
for i in range(1, N):
if newXL[i][0] < newXL[previous][1]:
pass
else:
previous = i
total += 1
print(total) | p02796 |
(N,), *XL = [list(map(int, s.split())) for s in open(0)]
XL.sort(key=lambda x: x[0] + x[1])
curr = -float("inf")
ans = 0
for x, l in XL:
if x - l >= curr:
curr = x + l
ans += 1
print(ans)
| N, *XL = list(map(int, open(0).read().split()))
XL = sorted((x + l, x - l) for x, l in zip(*[iter(XL)] * 2))
curr = -float("inf")
ans = 0
for right, left in XL:
if left >= curr:
curr = right
ans += 1
print(ans)
| p02796 |
def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
XL = []
for i in range(N):
x, l = list(map(int, input().split()))
XL.append((x, l))
XL.sort(key=lambda p: p[0] - p[1])
inf = 10**10
dp = [[inf] * (N+1) for _ in range(N+1)]
dp[0][0] = -inf
for i in range(N):
x, l = XL[i]
for j in range(N):
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
if j < N:
if dp[i][j] <= x - l:
dp[i+1][j+1] = min(dp[i+1][j+1], x + l)
for i in range(N, -1, -1):
if dp[-1][i] < 10**10:
print(i)
exit()
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
XL = []
for i in range(N):
x, l = list(map(int, input().split()))
XL.append((x, l))
XL.sort(key=lambda p: p[1] + p[0])
ans = 0
prev = -10**10
for i in range(N):
x, l = XL[i]
if x - l >= prev:
ans += 1
prev = x + l
print(ans)
if __name__ == '__main__':
main()
| p02796 |
N = int(eval(input()))
R = [tuple(map(int, input().split())) for _ in range(N)]
# 左端でソート
R.sort(key=lambda x: x[0]-x[1])
prev_L_arm = R[0][0] - R[0][1]
prev_R_arm = R[0][0] + R[0][1]
ans = N
for i in range(1, N):
L_arm = R[i][0] - R[i][1]
R_arm = R[i][0] + R[i][1]
if L_arm < prev_R_arm:
prev_R_arm = min(prev_R_arm, R_arm)
ans -= 1
else:
prev_R_arm = R_arm
print(ans) | # 解き直し https://atcoder.jp/contests/keyence2020/tasks/keyence2020_b
N = int(eval(input()))
R = [None] * N
for i in range(N):
X, L = list(map(int, input().split()))
R[i] = (X-L, X+L)
# 右端でソート
R.sort(key=lambda x: x[1])
ans = N
max_R = R[0][1]
for i in range(1, N):
if R[i][0] < max_R:
ans -= 1
else:
max_R = R[i][1]
print(ans) | p02796 |
N = int(eval(input()))
XL = [tuple(map(int,input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0]+x[1])
right = -float('inf')
ans = 0
for x,l in XL:
s,t = x-l, x+l-1
if s > right:
right = t
ans += 1
print(ans)
| N = int(eval(input()))
XL = [tuple(map(int,input().split())) for i in range(N)]
XL.sort(key=lambda x: x[0]+x[1])
right = -float('inf')
ans = 0
for x,l in XL:
s,t = x-l, x+l
if s >= right:
right = t
ans += 1
print(ans)
| p02796 |
n = int(eval(input()))
r = []
for _ in range(n):
r.append(list(map(int,input().split())))
r.sort()
i = 0
while i <= len(r)-2:
if r[i][0] + r[i][1] > r[i+1][0] - r[i+1][1]:
r = r[:i+1] + r[i+2:]
else:
i += 1
print((len(r)))
| n = int(eval(input()))
r = []
for _ in range(n):
x,l = list(map(int,input().split()))
r.append([x+l, x-l])
r.sort()
tmp = r[0]
cnt = 0
for i in range(1, n):
if r[i][1] < tmp[0]:
cnt += 1
else:
tmp = r[i]
print((n-cnt)) | p02796 |
n=int(eval(input()))
B=[]
for i in range(n):
x,l=list(map(int,input().split()))
B.append([x+l,x-l])
B.sort()
Left=[]
for b in B:
l=b[1];r=b[0]
flag=1
for c in Left:
if (c[0]<l and c[1]>l) or (c[0]<r and c[1]>r):
flag=0;break
elif c[0]>=l and c[1]<=r:
flag=0;break
if flag:
Left.append([l,r])
print((len(Left))) | n=int(eval(input()))
B=[]
for i in range(n):
x,l=list(map(int,input().split()))
B.append([x-l,x+l])
B.sort(key=lambda x:x[1])
max_l=-10**18-5
ans=0
for b in B:
if max_l <= b[0]:
max_l = b[1]
ans+=1
print(ans) | p02796 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.