input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from math import ceil
from bisect import bisect_left
def solve(n, h):
a = []
b = []
for i in range(n):
ai, bi = list(map(int, input().split()))
a.append(ai)
b.append(bi)
a.sort()
b.sort()
if n == 1:
ans = ceil((h-b[n-1])/a[n-1])+1
else:
over_amax = b[bisect_left(b, a[n-1]):]
if h <= sum(over_amax):
ans = len(over_amax)
else:
ans = ceil((h - sum(over_amax)) / a[n-1]) + len(over_amax)
return ans
if __name__ == '__main__':
n, h = list(map(int, input().split()))
print((solve(n, h)))
| from math import ceil
from bisect import bisect_left
def solve(n, h):
a = []
b = []
for i in range(n):
ai, bi = list(map(int, input().split()))
a.append(ai)
b.append(bi)
amax = max(a)
b.sort()
if n == 1:
ans = ceil((h-b[n-1])/amax)+1
else:
over_amax = b[bisect_left(b, amax):]
if h <= sum(over_amax):
for j in range(n-1, -1, -1):
h -= b[j]
if h <= 0:
ans = n-j
break
else:
ans = ceil((h - sum(over_amax)) / amax) + len(over_amax)
return ans
if __name__ == '__main__':
n, h = list(map(int, input().split()))
print((solve(n, h)))
| p03472 |
n,h=list(map(int,input().split()))
a=[]
b=[]
for _ in range(n):
a_i,b_i=list(map(int,input().split()))
a.append(a_i)
b.append(b_i)
import bisect,math
b=sorted(b)
index = bisect.bisect_left(b,max(a))
cnt=0
for i in range(n-1,-1,-1):
if i>=index:
h-=b[i]
cnt+=1
else:
break
if h<=0:
h=0
break
ans=math.ceil(h/max(a))+cnt
print(ans)
| n,h=list(map(int,input().split()))
b = []
t = []
for _ in range(n):
c,d = list(map(int,input().split()))
b.append(c)
t.append(d)
b_max = max(b)
t =sorted(t)
from bisect import bisect_right
from math import ceil
index = bisect_right(t,b_max)
ans=0
for i in range(n-1,index-1,-1):
h-=t[i]
ans+=1
if h<=0:
print(ans)
exit(0)
cnt = ceil(h/b_max)
print((ans+cnt))
| p03472 |
import math
n,h = list(map(int, input().split()))
al = []
bl = []
for _ in range(n):
a,b = list(map(int, input().split()))
al.append((a,'swing'))
bl.append((b,'throw'))
abl = al + bl
abl.sort(reverse=True)
remain_h = h
ans = 0
for v in abl:
damage, command = v
if command == 'swing':
ans += math.ceil(remain_h/damage)
break
else:
ans += 1
remain_h -= damage
if remain_h <= 0:
break
print(ans) | n,h = list(map(int, input().split()))
al = []
bl = []
for _ in range(n):
a,b = list(map(int, input().split()))
al.append(a)
bl.append(b)
al.sort(reverse=True)
bl.sort(reverse=True)
amax = al[0]
ans = 0
rem = h
for b in bl:
if b >= amax:
rem -= b
ans += 1
else:
break
if rem <= 0:
print(ans)
exit()
cnt = (rem-1)//amax + 1
ans += cnt
print(ans) | p03472 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, h = LI()
power = []
for a, b in LIR(n):
power += [(a, 1)]
power += [(b, 0)]
power.sort(reverse=True)
for i in range(2 * n):
p, flag = power[i]
h -= p
if h <= 0:
print((i + 1))
exit()
elif flag:
print((i + h // p + bool(h % p) + 1))
exit() | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, h = LI()
A = []
B = []
for _ in range(n):
a, b = LI()
A += [a]
B += [b]
max_a = max(A)
power_sort = sorted(B + [max_a], reverse=True)
for i in range(n + 1):
h -= power_sort[i]
if h <= 0:
print((i + 1))
exit()
elif power_sort[i] == max_a:
print((h // max_a + bool(h % max_a) + i + 1))
exit()
| p03472 |
import math
n, h = list(map(int, input().split()))
sl = 0
th = []
for i in range(n):
a, b = list(map(int, input().split()))
sl = max(sl, a)
th.append(b)
th.sort()
th_damage = th.pop()
turn = 0
while (h > 0):
if th_damage > sl:
h -= th_damage
if len(th) != 0:
th_damage = th.pop()
else:
th_damage = 0
else:
turn += math.ceil(h / sl)
break
turn += 1
print(turn)
| # 16:15
import sys
input = lambda: sys.stdin.readline().rstrip()
import math
n, h = list(map(int, input().split()))
sl = 0
th = []
for i in range(n):
a, b = list(map(int, input().split()))
sl = max(sl, a)
th.append(b)
th.sort()
th_damage = th.pop()
turn = 0
while (h > 0):
if th_damage > sl:
h -= th_damage
if len(th) != 0:
th_damage = th.pop()
else:
th_damage = 0
else:
turn += math.ceil(h / sl)
break
turn += 1
print(turn)
| p03472 |
n, h = list(map(int, input().split()))
a = []
b = []
for i in range(n):
ai, bi = list(map(int, input().split()))
a.append(ai)
b.append(bi)
b.append(0)
b = sorted(b, reverse=True)
count = 0
while True:
if max(b) < max(a):
count += -(-h // max(a))
break
else:
h -= b.pop(0)
count += 1
print(count)
| n, h = list(map(int, input().split()))
a = []
b = []
for i in range(n):
ai, bi = list(map(int, input().split()))
a.append(ai)
b.append(bi)
b.append(0)
a2 = sorted(a, reverse=True)
b2 = sorted(b, reverse=True)
count = 0
while True:
if h <= 0:
break
elif b2[0] <= a2[0]:
count += -(- h // a2[0])
break
else:
h -= b2.pop(0)
count += 1
print(count) | p03472 |
from math import ceil
N, H = list(map(int, input().split()))
a, b = [], []
for _ in range(N):
ta, tb = list(map(int, input().split()))
a.append(ta)
b.append(tb)
Ma = max(a)
b = sorted([x for x in b if x > Ma], reverse=True)
lb = len(b)
t = 0
while t < lb:
H -= b[t]
t += 1
if H <= 0:
break
if H > 0:
t += ceil(H / Ma)
print(t)
| def main():
import sys
input = sys.stdin.readline
N, H = list(map(int, input().split()))
bs = []
a_mx = -1
for _ in range(N):
a, b = list(map(int, input().split()))
a_mx = max(a_mx, a)
bs.append(b)
bs = [b for b in bs if b > a_mx]
bs.sort(reverse=True)
ans = 0
for b in bs:
H -= b
ans += 1
if H <= 0:
break
if H > 0:
ans += (H + a_mx - 1) // a_mx
print(ans)
if __name__ == '__main__':
main()
| p03472 |
from functools import reduce
from math import ceil
# 入力
N, H = list(map(int, input().split()))
a, b = list(zip(*(list(map(int, input().split())) for _ in range(N))))
# 投げるべき刀を強力なものから投げる。その後、振るべき刀を降り続ける。
m = max(a)
c = sorted([x for x in b if x > m], reverse=True)
ans = (
reduce(
lambda acc, e: (acc[0] + 1, acc[1] + e) if acc[1] < H else acc,
c,
(0, 0)
)[0] if sum(c) >= H else
len(c) + ceil((H - sum(c)) / m)
)
# 出力
print(ans)
| from functools import reduce
from math import ceil
# 入力
N, H = list(map(int, input().split()))
a, b = list(zip(*(list(map(int, input().split())) for _ in range(N))))
# 投げるべき刀を強力なものから投げる。その後、振るべき刀を降り続ける。
m = max(a)
c = sorted(
[x for x in b if x > m],
reverse=True
)
ans, _ = (
reduce(
lambda acc, e:
(acc[0] + 1, acc[1] + e) if acc[1] < H else
acc,
c,
(0, 0)
) if sum(c) >= H else
(len(c) + ceil((H - sum(c)) / m), 0)
)
# 出力
print(ans)
| p03472 |
N,H=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(N)]
B=[]
C=[]
for a,b in A:
B.append(a)
C.append(b)
D=sorted(B)[::-1]
F=[]
for i in C:
if max(B)<i:
F.append(i)
cnt=0
for i in F:
H-=i
cnt+=1
if H<=0:
print(cnt)
exit()
print((cnt-((-H)//D[0])))
| N,H=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(N)]
B=[]
C=[]
for a,b in A:
B.append(a)
C.append(b)
D=sorted(B)[::-1]
b=D[0]
F=[]
for i in C:
if b<i:
F.append(i)
G=sorted(F)[::-1]
cnt=0
for i in G:
H-=i
cnt+=1
if H<=0:
print(cnt)
exit()
print((cnt-((-H)//b))) | p03472 |
# coding: utf-8
from math import ceil
N, H = list(map(int, input().split()))
li = []
atop = 0
for _ in range(N):
a, b = list(map(int, input().split()))
atop = max(atop, a)
li.append([a, b])
li.sort(key=lambda x: x[1], reverse=True)
# print(li)
ans = ceil(H/atop)
cnt = 0
for i in range(N):
H -= li[i][1]
cnt += 1
ans = min(ans, cnt + max(0, ceil(H/atop)))
print(ans) | # coding: utf-8
from math import ceil
N, H = list(map(int, input().split()))
li = []
atop = 0
for _ in range(N):
a, b = list(map(int, input().split()))
atop = max(atop, a)
li.append(b)
li.sort(reverse=True)
# print(li)
ans = ceil(H/atop)
cnt = 0
for i in range(N):
H -= li[i]
cnt += 1
ans = min(ans, cnt + max(0, ceil(H/atop)))
print(ans) | p03472 |
from math import ceil
N, H = list(map(int, input().split()))
sword = [[int(x) for x in input().split()] for _ in range(N)]
max_swing = max(sword, key=lambda x:x[0])[0]
attack = 0
# 投げで攻撃
for i in sorted(sword, key=lambda x: x[1], reverse=True):
if max_swing < i[1]:
H -= i[1]
attack += 1
if H <= 0:
break
# 残りを振りで攻撃
if 0 < H:
attack += ceil(H / max_swing)
print(attack)
| # 振るのは最強のやつだけ
# 投げるのは強い順
N,H = list(map(int,input().split()))
AB = [[int(x) for x in input().split()] for _ in range(N)]
A,B = list(zip(*AB))
a = max(A) # 振る
B = [b for b in B if b > a] # 投げる価値あり
B.sort(reverse = True)
attack_cnt = 0
for b in B:
if H <= 0:
break
attack_cnt += 1
H -= b
if H > 0:
attack_cnt += (H-1)//a + 1
print(attack_cnt) | p03472 |
# -*- coding: utf-8 -*-
from bisect import bisect_left
N, H = list(map(int, input().split()))
A, B = [0]*N, [0]*N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
a_max = max(A)
B.sort()
# 一番強い振る刀より弱い投げる刀はいらない
B2 = list(reversed(B[bisect_left(B, a_max):]))
cnt = 0
# 投げるだけで倒せるか
if H <= sum(B2):
# 強い方から順番に投げる
for i in range(len(B2)):
cnt += 1
H -= B2[i]
if H <= 0:
print(cnt)
exit()
else:
# 全部投げた結果
H -= sum(B2)
cnt += len(B2)
# 倒すまでに振る回数
cnt += -(-H // a_max)
print(cnt)
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, H = MAP()
A = [0] * N
B = [0] * N
for i in range(N):
a, b = MAP()
A[i] = a
B[i] = b
A.sort(reverse=1)
B.sort(reverse=1)
mxa = A[0]
cnt = 0
for b in B:
if H <= 0 or b <= mxa:
break
H = max(0, H-b)
cnt += 1
cnt += ceil(H, mxa)
print(cnt)
| p03472 |
N,H=list(map(int,input().split()))
L=[list(map(int,input().split())) for _ in range(N)]
A=max(a for a,_ in L)
B=sorted(b for _,b in L if b>A)
c=0
while B and H>0:
H-=B.pop()
c+=1
print((c-(-max(0,H)//A))) | N,H=list(map(int,input().split()))
L=[list(map(int,input().split()))for _ in[0]*N]
A=max(a[0]for a in L)
B=sorted(b for _,b in L if b>A)
c=0
while B and H>0:
H-=B.pop()
c+=1
print((c-(-max(0,H)//A))) | p03472 |
import math
inn = [int(x) for x in input().split()]
aa = []
bb = []
for i in range(inn[0]):
tmp = [int(x) for x in input().split()]
aa.append(tmp[0])
bb.append(tmp[1])
count = 0
tot = 0
ba = list(filter((lambda x: x > max(aa)), bb))
if sum(ba) == inn[1]:
print((len(ba)))
exit()
elif sum(ba) > inn[1]:
for b in sorted(ba, reverse=True):
tot += b
count += 1
if tot >= inn[1]:
print(count)
exit()
else:
tot = sum(ba)
count = len(ba) + math.ceil((inn[1]-tot)/max(aa))
print(count)
| import math
inn = [int(x) for x in input().split()]
aa = []
bb = []
for i in range(inn[0]):
tmp = [int(x) for x in input().split()]
aa.append(tmp[0])
bb.append(tmp[1])
maxaa = max(aa)
ba = [x for x in bb if x > maxaa]
sumba = sum(ba)
lenba = len(ba)
if sumba == inn[1]:
print(lenba)
exit()
elif sumba > inn[1]:
count = lenba
tot = sumba
for b in sorted(ba):
tot -= b
if tot < inn[1]:
print(count)
exit()
count -= 1
else:
count = lenba + math.ceil((inn[1]-sumba)/max(aa))
print(count)
| p03472 |
# ABC 085 D
import bisect, math
N, H = list(map(int, input().split()))
a = []
b = []
for k in range(N):
x, y = list(map(int, input().split()))
a.append(x)
b.append(y)
a = sorted(a)
b = sorted(b)
l = N - bisect.bisect_left(b,a[-1])
b = b[::-1]
ans = 0
for k in range(l):
ans += 1
H -= b[k]
if H <= 0:
print(ans)
exit(0)
print((ans + math.ceil(H/a[-1])))
| import math, sys
def input():
return sys.stdin.readline()[:-1]
def main():
N, H = list(map(int,input().split()))
A = [0 for k in range(N)]
B = [0 for k in range(N)]
for k in range(N):
a, b = list(map(int,input().split()))
A[k] = a
B[k] = b
A = sorted(A)[::-1]
m = A[0]
B = sorted(B)[::-1]
c = 0
for e in B:
if e > m:
c += 1
H -= e
if H <= 0:
print(c)
exit(0)
else:
break
print((c+math.ceil(H/m)))
if __name__ == '__main__':
main()
| p03472 |
from itertools import accumulate
from bisect import bisect_left
from math import ceil
N,H = list(map(int, input().split()))
AB = []
for _ in range(N):
AB.append(tuple(map(int, input().split())))
# A昇順、B降順にソート
AB.sort(key=lambda x: (x[0], -x[1]))
# 最後の刀を装備する
equip = AB.pop()
# a_max < b なる刀を集める
b_list = []
for a,b in AB:
if b > equip[0]:
b_list.append(b)
# bを攻撃力の高い順に並べ替える
b_list.sort(reverse=True)
b_list_cum = list(accumulate(b_list))
b_list_cum = [0] + b_list_cum
ans = 0
# hpがb_list_cum[-1]以下なら、刀投げで終わる
if H <= b_list_cum[-1]:
ans = bisect_left(b_list_cum,H)
print(ans)
# 違えば、まずはb>=a_maxなる刀を全部投げ、equipでhp<=bになるまで攻撃し、
# 最後の1手で刀を投げる
else:
ans = len(b_list_cum)-1
res = H - b_list_cum[-1]
a_attack = max(0, int(ceil((res-equip[1]) / equip[0])))
# aで攻撃した分と、最後の1手の刀投げの分を足す
ans += (a_attack + 1)
print(ans) | from itertools import accumulate
from bisect import bisect_left
from math import ceil
N,H = list(map(int, input().split()))
A = []
B = []
for _ in range(N):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
# 最も強いaを探す
a_max = max(A)
# それ以上のbを探す
b_strong = []
for b in B:
if b >= a_max:
b_strong.append(b)
# bをソートしてcum作る
b_strong.sort(reverse=True)
b_cum = list(accumulate(b_strong))
b_cum = [0] + b_cum
# もしHPがb_cum[-1]なら投げてるうちに倒せる
if H <= b_cum[-1]:
ans = bisect_left(b_cum, H)
else:
ans = len(b_cum) - 1
ans += ceil((H - b_cum[-1]) / a_max)
print(ans) | p03472 |
from itertools import accumulate
from bisect import bisect_left
from math import ceil
N,H = list(map(int, input().split()))
A = []
B = []
for _ in range(N):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
# 最も強いaを探す
a_max = max(A)
# それ以上のbを探す
b_strong = []
for b in B:
if b >= a_max:
b_strong.append(b)
# bをソートしてcum作る
b_strong.sort(reverse=True)
b_cum = list(accumulate(b_strong))
b_cum = [0] + b_cum
# もしHPがb_cum[-1]なら投げてるうちに倒せる
if H <= b_cum[-1]:
ans = bisect_left(b_cum, H)
else:
ans = len(b_cum) - 1
ans += ceil((H - b_cum[-1]) / a_max)
print(ans) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n,h = li()
alis = []
blis = []
for _ in range(n):
a,b = li()
alis.append(a)
blis.append(b)
amax = max(alis)
blis.sort()
buse = []
while blis:
cur = blis.pop()
if cur > amax:
buse.append(cur)
cnt = 0
res = h
for b in buse:
res -= b
cnt += 1
if res <= 0:
break
if res > 0:
cnt += -(-res//amax)
print(cnt) | p03472 |
from bisect import bisect_right
N,H = list(map(int,input().split()))
A = []
B = []
for _ in range(N):
a,b = list(map(int,input().split()))
A.append(a)
B.append(b)
A = sorted(A,reverse=True)
B = sorted(B)
a = A[0]
ind = bisect_right(B,a)
cnt = 0
flag = 0
for i in range(N-1,ind-1,-1):
H -= B[i]
cnt += 1
if H<=0:
flag = 1
break
if flag==0:
k = H//a
if H%a>0:
k += 1
cnt += k
print(cnt) | import math
N,H = list(map(int,input().split()))
A = [list(map(int,input().split())) for _ in range(N)]
a = 0
for i in range(N):
if A[i][0]>a:
a = A[i][0]
B = []
for i in range(N):
if A[i][1]>a:
B.append(A[i][1])
B = sorted(B,reverse=True)
totB = sum(B)
if totB>=H:
flag = 0
tot = 0
for i in range(len(B)):
tot += B[i]
if tot>=H:
flag = i+1
break
print(flag)
else:
h = H-totB
n = len(B)+math.ceil(h/a)
print(n) | p03472 |
import math
n, h = list(map(int, input().split()))
a, b = [0] * n, [0] * n
for i in range(n):
x, y = list(map(int, input().split()))
a[i], b[i] = x, y
b.sort(reverse = True)
ans = 0
for i in range(n):
if b[i] < max(a):
break
h -= b[i]
ans += 1
if h <= 0:
break
if not h <= 0:
ans += math.ceil(h / max(a))
print(ans) | import math
n, h = list(map(int, input().split()))
b = [0] * n
maxa = 0
for i in range(n):
x, y = list(map(int, input().split()))
maxa = max(x, maxa)
b[i] = y
b.sort(reverse = True)
ans = 0
for i in range(n):
if b[i] < maxa:
break
h -= b[i]
ans += 1
if h <= 0:
break
if not h <= 0:
ans += math.ceil(h / maxa)
print(ans) | p03472 |
N, H = [int(_) for _ in input().split()]
katana = [[int(_) for _ in input().split()] for _ in range(N)]
katana.sort(key=lambda x:x[1], reverse=True)
a_max_katana = max(katana)
a_max = a_max_katana[0]
a_max_b = a_max_katana[1]
katana.pop(katana.index(a_max_katana))
count = 0
for katana_use in katana:
if katana_use[1] > a_max:
H -= katana_use[1]
count += 1
if H > a_max_b:
continue
else:
count += 1
break
else:
count += (H - a_max_b) // a_max + bool((H - a_max_b) % a_max) + 1
break
else:
count += (H - a_max_b) // a_max + bool((H - a_max_b) % a_max) + 1
print(count)
| N, H = [int(_) for _ in input().split()]
katana = [[int(_) for _ in input().split()] for _ in range(N)]
katana.sort(key=lambda x:x[1], reverse=True)
a_max_katana = max(katana)
a_max = a_max_katana[0]
a_max_b = a_max_katana[1]
katana.pop(katana.index(a_max_katana))
count = 0
for katana_use in katana:
if katana_use[1] > a_max:
H -= katana_use[1]
count += 1
if H > a_max_b:
continue
else:
count += 1
break
else:
count += -(-(H - a_max_b) // a_max) + 1
break
else:
count += -(-(H - a_max_b) // a_max) + 1
print(count)
| p03472 |
from collections import deque
n,h=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(n)]
l.sort(reverse=True)
fa,fb=l[0]
M=max(fa,fb)
if n==1:
print((max(0,(h-M-1)//fa)+2-(h<=M)))
else:
cnt=0;tmp=[]
for _,j in l[1:]:
if j>fa:
tmp.append(j)
b=deque(sorted(tmp))
lim=len(b)
while h > M and cnt < lim:
h-=b.pop()
cnt+=1
if len(b)!=0:
print((cnt+1))
else:
print((cnt+max(0,(h-M-1)//fa)+2-(h<=M))) | n,h,*l=list(map(int,open(0).read().split()))
a=max(l[::2])
c=0;f=1
for b in sorted(l[1::2])[::-1]:
if b>a:
h-=b
c+=1
if h<1:
f=0
break
print((c+(~-h//a+1)*f)) | p03472 |
import math
n,h = list(map(int,input().split()))
A = []
B = []
for i in range(n):
a,b = list(map(int,input().split()))
A.append(a)
B.append(b)
x = max(A)
B = sorted(B, reverse=True)
B_lst = []
for i in range(n):
if B[i] > x:
B_lst.append(B[i])
cnt = 0
damage = 0
ans = None
for i in range(len(B_lst)):
damage += B_lst[i]
cnt += 1
if damage >= h:
ans = cnt
break
ans = cnt
if damage < h:
ans = cnt + math.ceil((h - damage)/x)
print(ans) | from math import ceil
n,h = list(map(int,input().split()))
a,b = [],[]
for _ in range(n):
a_,b_ = list(map(int,input().split()))
a.append(a_)
b.append(b_)
mx_a = max(a)
b.sort(reverse=True)
cnt = 0
tmp = 0
for b_ in b:
if b_ >= mx_a:
tmp += b_
cnt += 1
if tmp >= h:
print(cnt)
exit()
else:
break
print((cnt+ceil((h-tmp)/mx_a))) | p03472 |
import sys
import math
N, H = list(map(int, input().split()))
a = []
b = []
num_attack = 0
for _ in range(N):
a_i, b_i = list(map(int, input().split()))
a.append(a_i)
b.append(b_i)
max_a = max(a)
Strong_b = [b_i for b_i in b if b_i > max_a]
if sum(Strong_b) >= H:
while H > 0:
H -= max(Strong_b)
max_index = Strong_b.index(max(Strong_b))
Strong_b[max_index] = 0
num_attack += 1
print(num_attack)
sys.exit()
H -= sum(Strong_b)
num_attack = len(Strong_b) + math.ceil(H/max_a)
print(num_attack)
| import sys
import math
N, H = list(map(int, input().split()))
a = []
b = []
num_attack = 0
for _ in range(N):
a_i, b_i = list(map(int, input().split()))
a.append(a_i)
b.append(b_i)
max_a = max(a)
Strong_b = [b_i for b_i in b if b_i > max_a]
if sum(Strong_b) >= H:
Strong_b = sorted(Strong_b, reverse = True)
for i in range(N):
H -= Strong_b[i]
if H <= 0:
print((i+1))
sys.exit()
H -= sum(Strong_b)
num_attack = len(Strong_b) + math.ceil(H/max_a)
print(num_attack) | p03472 |
# coding=utf-8
from math import floor, ceil, sqrt, factorial, log, gcd, log10
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement, chain
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heappushpop, heapify
from copy import copy, deepcopy
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)
def lcm(a, b): return a * b / gcd(a, b)
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
# 1 2 3
# a, b, c = LI()
def I(): return int(sys.stdin.buffer.readline())
# a = I()
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
# abc def
# a, b = LS()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
# a = S()
def IR(n): return [I() for i in range(n)]
# 2
# 1
# 2
# [1, 2]
def LIR(n): return [LI() for i in range(n)]
# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]]
def SR(n): return [S() for i in range(n)]
# 2
# abc
# def
# [abc, def]
def LSR(n): return [LS() for i in range(n)]
# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]]
def SRL(n): return [list(S()) for i in range(n)]
# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]]
n, h = LI()
a, b = [], []
for i in range(n):
A, B = LI()
a.append(A)
b.append(B)
b.sort(reverse=True)
a_max = max(a)
b = list([x for x in b if x >= a_max])
life = 0
cnt = 0
while life < h:
if len(b) > 0:
life += b.pop(0)
cnt += 1
else:
cnt += (h - life-1) // a_max + 1
break
print(cnt)
| # coding=utf-8
from math import floor, ceil, sqrt, factorial, log, gcd, log10
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement, chain
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heappushpop, heapify
from copy import copy, deepcopy
import sys
INF = float('inf')
mod = 10**9+7
sys.setrecursionlimit(10 ** 6)
def lcm(a, b): return a * b / gcd(a, b)
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
# 1 2 3
# a, b, c = LI()
def I(): return int(sys.stdin.buffer.readline())
# a = I()
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
# abc def
# a, b = LS()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
# a = S()
def IR(n): return [I() for i in range(n)]
# 2
# 1
# 2
# [1, 2]
def LIR(n): return [LI() for i in range(n)]
# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]]
def SR(n): return [S() for i in range(n)]
# 2
# abc
# def
# [abc, def]
def LSR(n): return [LS() for i in range(n)]
# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]]
def SRL(n): return [list(S()) for i in range(n)]
# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]]
n, h = LI()
a, b = [], []
for i in range(n):
A, B = LI()
a.append(A)
b.append(B)
a_max = max(a)
b = list([x for x in b if x >= a_max])
b.sort(reverse=True)
life = 0
cnt = 0
for x in b:
life += x
cnt += 1
if life >= h:
print(cnt)
break
if life < h:
cnt += (h - life - 1) // a_max + 1
print(cnt)
| p03472 |
n,h = list(map(int,input().split()))
a_list = []
b_list = []
use_b_list = []
for i in range(n):
a,b = list(map(int,input().split()))
a_list.append(a)
b_list.append(b)
import math
for b in b_list:
if b > max(a_list):
use_b_list.append(b)
use_b_list.sort(reverse = True)
count = 0
if sum(use_b_list) >= h:
for i in range(len(use_b_list)):
h -= use_b_list[i]
count += 1
if h <= 0:
break
print(count)
else:
h -= sum(use_b_list)
print((len(use_b_list) + int(math.ceil(h/max(a_list))))) | n,h = list(map(int,input().split()))
a_list = []
b_list = []
use_b_list = []
for i in range(n):
a,b = list(map(int,input().split()))
a_list.append(a)
b_list.append(b)
use_a = max(a_list)
import math
for b in b_list:
if b > use_a:
use_b_list.append(b)
use_b_list.sort(reverse = True)
count = 0
if sum(use_b_list) >= h:
for i in range(len(use_b_list)):
h -= use_b_list[i]
count += 1
if h <= 0:
break
print(count)
else:
h -= sum(use_b_list)
print((len(use_b_list) + int(math.ceil(h/max(a_list))))) | p03472 |
import math
N,H = list(map(int,input().split()))
data=[]
for i in range(N):
a,b = list(map(int,input().split()))
data.append([a,b,i])
s1 = sorted(data,key = lambda x:(-x[1],x[0]))
s2 = sorted(data,key = lambda x:(-x[0],x[1]))
cnt = 0
maxNum = s2[0][2]
for i in range(N):
if H > 0:
if s1[i][1] > s2[0][0]:
if s1[i][2] == maxNum:
continue
else:
H -= s1[i][1]
cnt += 1
else:
H -= s2[0][1]
cnt += 1
break
else:
print(cnt)
exit()
else:
H -= s2[0][1]
cnt += 1
if H > 0:
print((cnt + math.ceil(H/s2[0][0])))
else:
print(cnt) | import math
N,H = list(map(int,input().split()))
data=[]
for i in range(N):
a,b = list(map(int,input().split()))
data.append([a,b])
s1 = sorted(data,key = lambda x:-x[1])
s2 = sorted(data,key = lambda x:-x[0])
cnt = 0
for i in range(N):
if H > 0:
if s1[i][1] > s2[0][0]:
H -= s1[i][1]
cnt += 1
else:
break
else:
print(cnt)
exit()
if H > 0:
print((cnt + math.ceil(H/s2[0][0])))
else:
print(cnt)
| p03472 |
n,h = list(map(int,input().split()))
x = (tuple(map(int, input().split())) for _ in [0] * n)
a2,b = [],[]
for j in x:
a2.append(j[0])
b.append(j[1])
a = max(a2)
b = [i for i in b if i>a]
b.sort()
b = b[::-1]
if h <= sum(b):
num,i = 0,0
while h > 0:
h -= b[i]
num += 1
i += 1
else:
h -= sum(b)
num = (h+a-1)//a + len(b)
print(num) | n,h = (int(i) for i in input().split())
x = [[int(i) for i in input().split()] for i in range(n)]
a,b = 0,[]
for j in x:
if a < j[0]: a = j[0]
b.append(j[1])
b = [i for i in b if i>a]
b.sort()
b = b[::-1]
if h <= sum(b):
num,i = 0,0
while h > 0:
h -= b[i]
num += 1
i += 1
else:
h -= sum(b)
num = (h+a-1)//a + len(b)
print(num) | p03472 |
def slove():
import sys
import heapq
input = sys.stdin.readline
n, h = list(map(int, input().rstrip('\n').split()))
m_k = 0
t = []
heapq.heapify(t)
for i in range(n):
a, b = list(map(int, input().rstrip('\n').split()))
m_k = max(m_k, a)
heapq.heappush(t, -b)
cnt = 0
while True:
if len(t) != 0:
p = heapq.heappop(t)
if m_k < -p:
h += p
cnt += 1
if h <= 0:
print(cnt)
exit()
else:
break
else:
break
print(((h + m_k - 1) // m_k + cnt))
if __name__ == '__main__':
slove()
| def slove():
import sys
input = sys.stdin.readline
al = []
bl = []
n, h = list(map(int, input().rstrip('\n').split()))
for i in range(n):
a, b = list(map(int, input().rstrip('\n').split()))
al.append(a)
bl.append(b)
al.sort()
bl.sort()
cnt = 0
while True:
if h > 0:
if len(bl) != 0:
bv = bl.pop()
if bv > al[-1]:
h -= min(h, bv)
cnt += 1
else:
break
else:
break
else:
break
cnt += ((h + al[-1] - 1) // al[-1])
print(cnt)
if __name__ == '__main__':
slove()
| p03472 |
import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, h = list(map(int, input().rstrip('\n').split()))
al = 0
bl = []
for i in range(n):
a, b = list(map(int, input().rstrip('\n').split()))
al = max(al, a)
bl.append(b)
bl.sort()
cnt = 0
while True:
if len(bl) != 0:
b = bl.pop()
if h <= 0:
print(cnt)
exit()
elif al < b:
h -= min(h, b)
cnt += 1
else:
cnt += (h + al - 1) // al
h -= (h + al - 1) // al * al
print(cnt)
exit()
else:
cnt += (h + al - 1) // al
h -= (h + al - 1) // al * al
print(cnt)
exit()
if __name__ == '__main__':
solve()
| import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, h = list(map(int, input().rstrip('\n').split()))
md = 0
dl = []
for i in range(n):
a, b = list(map(int, input().rstrip('\n').split()))
md = max(md, a)
dl.append(b)
dl.sort(reverse=True)
cnt = 0
for v in dl:
if v > md:
h -= min(h, v)
cnt += 1
if h == 0:
print(cnt)
exit()
else:
break
cnt += (h + md - 1) // md
print(cnt)
exit()
if __name__ == '__main__':
solve()
| p03472 |
import math
N,H = list(map(int,input().split()))
src = [tuple(map(int,input().split())) for i in range(N)]
n = max(src)[0]
src.sort(key=lambda x:x[1],reverse=True)
ans = d = 0
for a,b in src:
if b <= n: break
d += b
ans += 1
if d >= H:
print(ans)
exit()
ans += math.ceil((H-d) / n)
print(ans)
| N,H = list(map(int,input().split()))
src = [tuple(map(int,input().split())) for i in range(N)]
maxa = max(src)[0]
ans = 0
for a,b in sorted(src, key=lambda x:x[1], reverse=True):
if b <= maxa:
break
H -= b
ans += 1
if H <= 0:
print(ans)
exit()
ans += (H-1)//maxa + 1
print(ans)
| p03472 |
def main():
N, H = list(map(int, input().split()))
A = [0] * N
B = [0] * N
num_list = []
for i in range(N):
a, b = list(map(int, input().split()))
A[i] = a
B[i] = b
num_list.append(a)
num_list.append(b)
num = sorted(num_list, reverse=True)
ans = 0
for a in num:
if a in A:
ans += -(-H // a)
break
else:
ans += 1
H -= a
print(ans)
main() | def main():
N, H = list(map(int, input().split()))
A = [0] * N
B = [0] * N
num_list = []
for i in range(N):
a, b = list(map(int, input().split()))
A[i] = a
B[i] = b
sort_B = sorted(B, reverse=True)
max_A = max(A)
ans = 0
for b in sort_B:
if b > max_A:
ans += 1
H -= b
else:
break
if H <= 0:
break
if H > 0:
ans += -(-H // max_A)
print(ans)
main() | p03472 |
import sys
input = sys.stdin.readline
def main():
N, H = list(map(int, input().split()))
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
cnt = 0
max_A = max(A)
sort_B = sorted(B, reverse=True)
for b in sort_B:
if b > max(A):
cnt += 1
H -= b
else:
break
if H <= 0:
break
cnt += H // max(A) if H % max(A) == 0 else H // max(A) + 1
print(cnt)
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
def main():
N, H = list(map(int, input().split()))
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
cnt = 0
max_A = max(A)
sort_B = sorted(B, reverse=True)
for b in sort_B:
if b > max_A:
cnt += 1
H -= b
else:
break
if H <= 0:
break
if H > 0:
cnt += H // max_A if H % max_A == 0 else H // max_A + 1
print(cnt)
if __name__ == "__main__":
main() | p03472 |
import bisect
from math import ceil
N,H=list(map(int, input().split()))
A=[]
B=[]
for i in range(N):
a,b=list(map(int, input().split()))
A.append(a)
B.append(b)
A=sorted(A)
B=sorted(B)
idx=bisect.bisect_right(B,A[-1])
throw=sum(B[idx:])
if throw<=H:
ans=N-idx
res=H-throw
ans+=ceil(res/A[-1])
#print(res/A[-1], throw)
else:
res=H
ans=0
for i in range(N):
ans+=1
res-=B[-(i+1)]
if res<=0:
break
print(ans)
| from math import ceil
N,H=list(map(int, input().split()))
A=[0]*N
B=[0]*N
for i in range(N):
a,b=list(map(int, input().split()))
A[i]=a
B[i]=b
A=sorted(A)
B=sorted(B, reverse=True)
amax=max(A)
ans=0
for i in range(N):
b=B[i]
if b>amax:
H-=b
ans+=1
if H<=0:
break
else:
break
if H>0:
ans+=ceil(H/amax)
print(ans)
| p03472 |
from math import ceil
import sys
input=sys.stdin.readline
n, h = list(map(int, input().split()))
a = []
b = []
for i in range(n):
p, q = list(map(int, input().split()))
a.append(p)
b.append(q)
b.sort(reverse=1)
ans=0
m=max(a)
while(h>0 and len(b) != 0):
if b[0] < m:
break
h-=b[0]
b.pop(0)
ans+=1
if h>0:
ans+=ceil(h/m)
print(ans)
| from math import ceil
import sys
input=sys.stdin.readline
n, h = list(map(int, input().split()))
a = []
b = []
for i in range(n):
p, q = list(map(int, input().split()))
a.append(p)
b.append(q)
b.sort()
ans=0
m=max(a)
while(h>0 and len(b) != 0):
if b[-1]< m:
break
h-=b.pop()
ans+=1
if h>0:
ans+=ceil(h/m)
print(ans)
| p03472 |
n,h = list(map(int,input().split()))
x = []
for i in range(n):
x.append(list(map(int,input().split())))
t = 0
c = []#強い投げ刀たち
for i in range(n):
if x[i][1]>max(x[i][0] for i in range(n))-1:
c.append(x[i][1])
c.sort()
c.reverse()
if sum(c)>h-1:
for i in range(len(c)):
t += 1
h -= c[i]
if h<1:
print(t)
break
else:
h -=sum(c)
q = (h-1)//max(x[i][0] for i in range(n))+1
print((q+len(c))) | n,h = list(map(int,input().split()))
x = []
for i in range(n):
x.append(list(map(int,input().split())))
t = 0
c = []#強い投げ刀たち
M = max(x[i][0] for i in range(n))
for i in range(n):
if x[i][1]>M-1:
c.append(x[i][1])
c.sort()
c.reverse()
if sum(c)>h-1:
for i in range(len(c)):
t += 1
h -= c[i]
if h<1:
print(t)
break
else:
h -=sum(c)
q = (h-1)//M+1
print((q+len(c))) | p03472 |
# -*- coding: utf-8 -*-
# 入力から変数を初期化
N, H = list(map(int, input().split()))
a = []
b = []
for i in range(N):
ai, bi = list(map(int, input().split()))
a.append(ai)
b.append(bi)
ans = H
# 振る刀の最大値
amax = max(a)
# 投げる刀を降順でソートしておく
b.sort(reverse=True)
# 攻撃力の高い刀から順にk本投げ、残りの体力をamaxを使って削る
for k in range(N+1):
damage_throw = 0 + sum(b[0:k])
H_minus_throw = H - damage_throw
if H_minus_throw <= 0:
tmp_ans = k
else:
num_swing = -(-H_minus_throw // amax)
tmp_ans = k + num_swing
ans = min(tmp_ans, ans)
print(ans)
| # -*- coding: utf-8 -*-
# 入力から変数を初期化
N, H = list(map(int, input().split()))
a = []
b = []
for i in range(N):
ai, bi = list(map(int, input().split()))
a.append(ai)
b.append(bi)
ans = H
# 振る刀の最大値
amax = max(a)
# 投げる刀を降順でソートしておく
b.sort(reverse=True)
# 攻撃力の高い刀から順にk本投げ、残りの体力をamaxを使って削る
damage_throw = 0
for k in range(N+1):
damage_throw += 0 if k == 0 else b[k-1]
H_minus_throw = H - damage_throw
if H_minus_throw <= 0:
tmp_ans = k
else:
num_swing = -(-H_minus_throw // amax)
tmp_ans = k + num_swing
ans = min(tmp_ans, ans)
print(ans)
| p03472 |
import sys
N, H = [int(x) for x in sys.stdin.readline().strip().split()]
A = []
B = []
for i in range(N):
a, b = [int(x) for x in sys.stdin.readline().strip().split()]
A.append(a)
B.append(b)
r = 1000000000000
for i in range(N):
p = A[i]
qs = [B[i] for i in range(N) if B[i] > p]
rr = ((H - sum(qs) + (p - 1)) // p) + len(qs)
r = min(r, rr)
print(r)
| import sys
N, H = [int(x) for x in sys.stdin.readline().strip().split()]
AB = [tuple(int(x) for x in sys.stdin.readline().strip().split()) for i in range(N)]
AB.sort(key=lambda x:(-x[0],x[1]))
p = AB[0][0]
qs = [AB[j][1] for j in range(N) if AB[j][1] > p]
qs.sort(key=lambda x:-x)
r = 0
for i in range(len(qs)):
if H <= 0:
break
H -= qs[i]
r += 1
if H > 0:
r = r + (H + (p - 1)) // p
print(r)
| p03472 |
import math
def find_argmax(num_list):
argmax = sorted(enumerate(num_list), key=lambda x:x[1])[-1][0]
return argmax
def find_all_more_than(threshold, num_list):
indices = [
idx
for idx, num in enumerate(num_list)
if num > threshold
]
return indices
def read_input():
initial_inputs = input().split(" ")
N = int(initial_inputs[0])
H = int(initial_inputs[1])
a_list = []
b_list = []
for _ in range(N):
inputs = input().split(" ")
a = int(inputs[0])
b = int(inputs[1])
a_list.append(a)
b_list.append(b)
return N, H, a_list, b_list
# TLE
def searchA(N, H, a_list, b_list):
# initialize used_indices
used_indices = [ False for b in b_list]
# initialize search_area
search_area = [ b for b in b_list ]
# count how many times
times_count = 0
while H > 0:
# search
idx = find_argmax(search_area)
# check
if used_indices[idx]:
# calculate rest and finish
rest_count = math.ceil(H / search_area[idx])
return times_count + rest_count
# attack
H -= search_area[idx]
# change
search_area[idx] = a_list[idx]
used_indices[idx] = True
# count
times_count += 1
return times_count
# still TLE
def searchB(N, H, a_list, b_list):
# initialize used_indices
used_indices = [ False ] * N
# initialize search_area
search_area = [ b for b in b_list ]
# count how many times
times_count = 0
# pick up b indices higher than max(a_list)
higher_b_indices = find_all_more_than(max(a_list), b_list)
higher_b_list = [ b_list[idx] for idx in higher_b_indices ]
for b in reversed(sorted(higher_b_list)):
if not H > 0:
return times_count
# attack
H -= b
times_count += 1
# fix search_area used_indices
for idx in higher_b_indices:
# change
search_area[idx] = a_list[idx]
used_indices[idx] = True
while H > 0:
# search
idx = find_argmax(search_area)
# check
if used_indices[idx]:
# calculate rest and finish
rest_count = math.ceil(H / search_area[idx])
return times_count + rest_count
# attack
H -= search_area[idx]
times_count += 1
# change
search_area[idx] = a_list[idx]
used_indices[idx] = True
return times_count
# still TLE
def searchC(N, H, a_list, b_list):
# initialize used_indices
used_indices = [ False ] * N
# initialize search_area
search_area = [ b for b in b_list ]
# count how many times
times_count = 0
# pick up b indices higher than max(a_list)
max_a = max(a_list)
higher_b_indices = find_all_more_than(max_a, b_list)
higher_b_list = [ b_list[idx] for idx in higher_b_indices ]
for b in reversed(sorted(higher_b_list)):
if not H > 0:
return times_count
# attack
H -= b
times_count += 1
# fix search_area used_indices
for idx in higher_b_indices:
# change
search_area[idx] = a_list[idx]
used_indices[idx] = True
# use max(a_list)
rest_count = math.ceil(H / max_a)
return times_count + rest_count
def main():
# read input
N, H, a_list, b_list = read_input()
# search
times_count = searchB(N, H, a_list, b_list)
# output
print(times_count)
if __name__ == '__main__':
main()
| import math
def find_argmax(num_list):
argmax = sorted(enumerate(num_list), key=lambda x:x[1])[-1][0]
return argmax
def find_all_more_than(threshold, num_list):
indices = [
idx
for idx, num in enumerate(num_list)
if num > threshold
]
return indices
def read_input():
initial_inputs = input().split(" ")
N = int(initial_inputs[0])
H = int(initial_inputs[1])
a_list = []
b_list = []
for _ in range(N):
inputs = input().split(" ")
a = int(inputs[0])
b = int(inputs[1])
a_list.append(a)
b_list.append(b)
return N, H, a_list, b_list
# TLE
def searchA(N, H, a_list, b_list):
# initialize used_indices
used_indices = [ False for b in b_list]
# initialize search_area
search_area = [ b for b in b_list ]
# count how many times
times_count = 0
while H > 0:
# search
idx = find_argmax(search_area)
# check
if used_indices[idx]:
# calculate rest and finish
rest_count = math.ceil(H / search_area[idx])
return times_count + rest_count
# attack
H -= search_area[idx]
# change
search_area[idx] = a_list[idx]
used_indices[idx] = True
# count
times_count += 1
return times_count
# still TLE
def searchB(N, H, a_list, b_list):
# initialize used_indices
used_indices = [ False ] * N
# initialize search_area
search_area = [ b for b in b_list ]
# count how many times
times_count = 0
# pick up b indices higher than max(a_list)
higher_b_indices = find_all_more_than(max(a_list), b_list)
higher_b_list = [ b_list[idx] for idx in higher_b_indices ]
for b in reversed(sorted(higher_b_list)):
if not H > 0:
return times_count
# attack
H -= b
times_count += 1
# fix search_area used_indices
for idx in higher_b_indices:
# change
search_area[idx] = a_list[idx]
used_indices[idx] = True
while H > 0:
# search
idx = find_argmax(search_area)
# check
if used_indices[idx]:
# calculate rest and finish
rest_count = math.ceil(H / search_area[idx])
return times_count + rest_count
# attack
H -= search_area[idx]
times_count += 1
# change
search_area[idx] = a_list[idx]
used_indices[idx] = True
return times_count
# still TLE
def searchC(N, H, a_list, b_list):
# count how many times
times_count = 0
# pick up b indices higher than max(a_list)
max_a = max(a_list)
higher_b_indices = find_all_more_than(max_a, b_list)
higher_b_list = [ b_list[idx] for idx in higher_b_indices ]
for b in reversed(sorted(higher_b_list)):
if not H > 0:
return times_count
# attack
H -= b
times_count += 1
# use max(a_list)
rest_count = math.ceil(H / max_a)
return times_count + rest_count
def main():
# read input
N, H, a_list, b_list = read_input()
# search
times_count = searchC(N, H, a_list, b_list)
# output
print(times_count)
if __name__ == '__main__':
main()
| p03472 |
n, h, *k = list(map(int, open(0).read().split()))
a = 0; b = []
for i, j in zip(*[iter(k)]*2):
a = max(a, i)
b.append(j)
b = sorted(b, reverse = True)
ans = 0
while ans < n and b[ans] > a and h > 0:
h -= b[ans]
ans += 1
if h > 0: ans += (h + a - 1) // a
print(ans) | n, h, *k = list(map(int, open(0).read().split()))
a = max(k[::2]); b = sorted(k[1::2], reverse = True)
ans = 0
while ans < n and b[ans] > a and h > 0:
h -= b[ans]
ans += 1
if h > 0: ans += (h + a - 1) // a
print(ans) | p03472 |
#!/usr/bin/env python3
import math
N, H = list(map(int, input().split()))
a = [0] * N
b = [0] * N
for i in range(N):
a[i], b[i] = list(map(int, input().split()))
b.sort(reverse=True)
m = max(a)
s = [0]
for i in range(N):
b[i] = max(b[i], m)
s.append(s[-1] + b[i])
if s[-1] >= H:
print((i + 1))
break
else:
print((max(N + 1, math.ceil((H - sum(b)) / m) + N)))
| #!/usr/bin/env python3
import math
N, H = list(map(int, input().split()))
a = [0] * N
b = [0] * N
for i in range(N):
a[i], b[i] = list(map(int, input().split()))
b.sort(reverse=True)
m = max(a)
s = 0
for i in range(N):
b[i] = max(b[i], m)
s += b[i]
if s >= H:
print((i + 1))
break
else:
print((N + math.ceil((H - s) / m)))
| p03472 |
import sys
import math
n, h = list(map(int, input().split()))
a = 0
b = []
for i in range(n):
x, y = list(map(int, input().split()))
a = max(a, x)
b.append(y)
b.sort(reverse=True)
b = [x for x in b if x > a]
for i, x in enumerate(b):
h -= x
if h <= 0:
print((i + 1))
sys.exit()
if len(b) == 0:
i = -1
ans = i + 1 + math.ceil(h / a)
print(ans) | import sys
n, h = list(map(int, input().split()))
max_a = 0
b = []
for i in range(n):
x, y = list(map(int, input().split()))
max_a = max(max_a, x)
b.append(y)
# 投げる価値がある刀を抜粋する
b = [x for x in b if x > max_a]
# 強い順に投げていく
b.sort(reverse=True)
i = 0
if len(b) > 0:
for i, x in enumerate(b):
i += 1
h -= x
if h <= 0:
print(i)
sys.exit()
# 投げ終わったら最強の刀で攻撃し続ける
print(((h + max_a - 1) // max_a + i)) | p03472 |
N,H = list(map(int,input().split()))
ans = 0
A = []
B = []
for i in range(N) :
a,b = list(map(int,input().split()))
A.append(a)
B.append(b)
B = sorted(B,reverse = True)
flag = 0
for i in range(N) :
if H <= 0 :
break
if max(A) < B[i] :
H -= B[i]
ans += 1
else :
break
if H <= 0 :
print(ans)
else :
if H % max(A) == 0 :
ans += H // max(A)
else :
ans += H // max(A) + 1
print(ans)
| N,HP = list(map(int,input().split()))
L = list(list(map(int,input().split())) for i in range(N))
L = sorted(L, key=lambda x: x[0], reverse=True)
max_a = L[0][0]
L = sorted(L, key=lambda x: x[1], reverse=True)
ans = 0
for i in range(N) :
if L[i][1] < max_a :
break
HP -= L[i][1]
ans += 1
if HP <= 0 :
break
if HP >= 0 :
if HP % max_a == 0 :
ans += HP//max_a
else :
ans += HP//max_a + 1
print(ans)
| p03472 |
def solve():
N, HP = list(map(int, input().split()))
score = 0
f = []
n = []
for i in range(N):
a, b = list(map(int, input().split()))
f.append(a)
n.append(b)
#最後まで使う刀保存
lastf = max(f)
lastid = f.index(lastf)
lastn = n[lastid]
for i in range(len(n)):
mn = max(n)
id = n.index(mn)
if lastf < mn:
HP -= mn
n.pop(id)
score += 1
if HP <= 0:
return score
else:
break
score += -(-HP // lastf)
return score
print((solve()))
| def solve():
N, HP = list(map(int, input().split()))
score = 0
f = []
n = []
for i in range(N):
a, b = list(map(int, input().split()))
f.append(a)
n.append(b)
#最後まで使う刀保存
lastf = max(f)
lastid = f.index(lastf)
lastn = n[lastid]
n.sort(reverse = True)
for i in range(len(n)):
mn = n[0]
id = 0
if lastf < mn:
HP -= mn
n.pop(id)
score += 1
if HP <= 0:
return score
else:
break
score += -(-HP // lastf)
return score
print((solve()))
| p03472 |
from heapq import heappush, heappop
def solve():
N, H = list(map(int, input().split()))
cut_dmgs = []
thr_dmgs = []
for _ in range(N):
a, b = list(map(int, input().split()))
heappush(cut_dmgs, -a)
heappush(thr_dmgs, -b)
ans = 0
max_cut_dmg = -min(cut_dmgs)
while thr_dmgs:
thr_dmg = -heappop(thr_dmgs)
if thr_dmg <= max_cut_dmg:
break
ans += 1
H -= thr_dmg
if H <= 0:
return ans
return ans + (H + max_cut_dmg - 1) // max_cut_dmg
print((solve()))
| N, H, *blades = list(map(int, open(0).read().split()))
cut = max(blades[::2])
throws = sorted(b for b in blades[1::2] if b >= cut)
ans = 0
while throws:
H -= throws.pop()
ans += 1
if H <= 0:
print(ans)
exit()
ans += (H + cut - 1) // cut
print(ans) | p03472 |
n,h=list(map(int,input().split()))
A=list(tuple(map(int,input().split())) for i in range(n))
A,B=list(zip(*A))
a=max(A)
count=0
for i in sorted(B)[::-1]:
if h<=0:break
elif i>=a:
count +=1
h -=i
if h>0:
count +=(h-1)//a+1
print(count) | n,h=list(map(int,input().split()))
A=list(tuple(map(int,input().split())) for i in range(n))
A,B=list(zip(*A))
a=max(A)
count=0
for i in sorted(B)[::-1]:
if h<=0:break
elif i>=a:
count +=1
h -=i
if h>0:
if h%a==0:count +=h//a
else:count +=h//a+1
print(count) | p03472 |
n, h = list(map(int, input().split()))
arr = []
for _ in range(n) :
a,b = list(map(int, input().split()))
arr.append((a,-1))
arr.append((b,1))
arr.sort()
arr.reverse()
cnt = 0
ans = 10**9 + 100
for p in arr :
if p[1] == -1 :
# a
ans = min(ans, cnt + (h+p[0]-1)//p[0])
elif p[1] == 1 and h>0 :
# b
h -= p[0]
cnt += 1
if h <= 0 :
h = 0
ans = min(ans, cnt)
print(ans)
| n, h = list(map(int, input().split()))
arr = []
for _ in range(n) :
a,b = list(map(int, input().split()))
arr.append((a,-1))
arr.append((b,1))
arr.sort()
arr.reverse()
cnt = 0
ans = 10**9 + 100
for p in arr :
if p[1] == -1 :
# a
ans = min(ans, cnt + (h+p[0]-1)//p[0])
break
elif p[1] == 1 and h>0 :
# b
h -= p[0]
cnt += 1
if h <= 0 :
h = 0
ans = min(ans, cnt)
print(ans)
| p03472 |
from math import ceil
N, H = list(map(int, input().split()))
A, B = [], []
for _ in range(N):
a, b = list(map(int, input().split()))
A.append(a), B.append(b)
B = sorted(list([x for x in B if x > max(A)]))
count = 0
while H > 0:
if B:
H -= B.pop()
else:
count += ceil(H / max(A))
break
count += 1
print(count) | from math import ceil
N, H = list(map(int, input().split()))
A, B = [], []
for _ in range(N):
a, b = list(map(int, input().split()))
A.append(a), B.append(b)
max_a = max(A)
B = sorted(list([x for x in B if x > max_a]))
count = 0
while H > 0:
if B:
H -= B.pop()
else:
count += ceil(H / max_a)
break
count += 1
print(count)
| p03472 |
def d_katana_thrower(N, H, Swords):
import math
# 振ったとき最もダメージが大きい刀以上に投げたときのダメージが大きな刀
# について、ダメージが大きなものから投げていく。そのダメージの総和が
# 敵の体力より大きければ投げて倒せばいいし、足りなければ刀を降って倒せばいい。
# ただし、振る刀の投げダメージが振るより高ければ、投げる前に振らなければならないが、
# 計算時には「投げてから振る」とみなしても問題ない。
swing_damage_max = max([s[0] for s in Swords])
throw_higher_than_swing = [s[1] for s in Swords if s[1] >= swing_damage_max]
throw_higher_than_swing.sort(reverse=True)
minimum_moving = 0
for damage in throw_higher_than_swing:
if H <= 0: # 刀を投げている途中で敵を倒したら終わり
H = 0
break
H -= damage
minimum_moving += 1
minimum_moving += math.ceil(H / swing_damage_max)
return minimum_moving
N, H = [int(i) for i in input().split()]
Swords = [[int(i) for i in input().split()] for j in range(N)]
print((d_katana_thrower(N, H, Swords))) | def d_katana_thrower():
# 最大振り火力をもつ刀以上の投げ火力をもつ刀は、大火力のものから順に投げる。
# 投げダメージの総和が敵の体力より大きければ投げて倒せばいいし、
# 足りなければ最大振り火力をもつ刀を降り続けて倒せばいい。
# ただし、最大振り火力をもつ刀については、投げ火力が振り火力より高くても、
# 投げる前に振らなければならないが、「投げてから振る」とみなして問題ない。
N, H = [int(i) for i in input().split()]
Swords = [[int(i) for i in input().split()] for j in range(N)]
max_swing = max([s[0] for s in Swords])
sword_to_throw = sorted([s[1] for s in Swords if s[1] >= max_swing], reverse=True)
threw_times = 0
for damage in sword_to_throw:
H -= damage
threw_times += 1
if H <= 0:
return threw_times # 刀を投げている途中で敵を倒したら終わり
return threw_times + -(-H // max_swing)
print((d_katana_thrower())) | p03472 |
mina=10**10
def waru(a,b):
if a%b==0:
return a//b
else:
return (a//b)+1
N,H=list(map(int,input().split()))
A=list()
B=list()
for i in range(N):
a,b=list(map(int,input().split()))
A.append(a)
B.append(b)
sb=sum(B)
for i in range(N):
S=[k for k in B if k>A[i]]
n=sum(S)
if H-n<=0:
mina=min(mina,len(S))
else:
mina=min(mina,waru(H-n,A[i])+len(S))
print(mina) | import sys
mina=10**10
def waru(a,b):
if a%b==0:
return a//b
else:
return (a//b)+1
N,H=list(map(int,input().split()))
A=list()
B=list()
for i in range(N):
a,b=list(map(int,input().split()))
A.append(a)
B.append(b)
ma=max(A)
ind=A.index(ma)
B=[i for i in B if i>ma]
B=sorted(B,reverse=True)
cou=1
s=0
for i in range(len(B)):
s+=B[i]
if H<=s:
print((i+1))
sys.exit()
H=H-s
print((len(B)+waru(H,ma))) | p03472 |
n, h = [int(t) for t in input().split()]
aa = []
bb = []
for _ in range(n):
a, b = [int(t) for t in input().split()]
aa.append(a)
if b > a:
bb.append(b)
aa.sort()
bb.sort()
cnt = 0
while h > 0:
if not bb:
cnt += (h - 1) // aa[-1] + 1
break
elif bb[-1] > aa[-1]:
h -= bb.pop()
else:
h -= aa[-1]
cnt += 1
print(cnt)
| n, h = [int(t) for t in input().split()]
aa = []
bb = []
for _ in range(n):
a, b = [int(t) for t in input().split()]
aa.append(a)
if b > a:
bb.append(b)
aa.sort()
bb.sort()
cnt = 0
while h > 0:
if not bb or aa[-1] >= bb[-1]:
cnt += (h - 1) // aa[-1] + 1
break
else:
h -= bb.pop()
cnt += 1
print(cnt)
| p03472 |
import math
N , H = list(map(int , input().split()))
slash = []
throw = []
for _ in range(N):
a , b = list(map(int , input().split()))
slash.append(a)
throw.append(b)
count = 0
#print(slash)
slash_max = max(slash)
#print(throw)
throw.sort(reverse = True)
#print(throw)
while H > 0:
#print(H)
if not throw or throw[0] < slash_max :
count += math.ceil(H / slash_max)
break
else:
H -= throw[0]
throw.pop(0)
#print(throw)
count += 1
print(count)
| import math
N, H = list(map(int, input().split()))
a_l = []
b_l = []
for _ in range(N):
a, b = list(map(int, input().split()))
a_l.append(a)
b_l.append(b)
a_l.sort(reverse=True)
b_l.sort(reverse=True)
ans = 0
for i in range(N):
if a_l[0] >= b_l[i]:
break
else:
ans += 1
H = max(H - b_l[i], 0)
if H <= 0:
break
ans += math.ceil(H / a_l[0])
print(ans) | p03472 |
from collections import Counter
from functools import reduce
from itertools import combinations
from operator import xor
n = int(eval(input()))
nodes = [0] * n
for _ in range(n - 1):
x, y, a = list(map(int, input().split()))
nodes[x] ^= a
nodes[y] ^= a
c = Counter(nodes)
ans = 0
remains = set()
for i, v in list(c.items()):
if i == 0:
continue
ans += v // 2
if v % 2:
remains.add(i)
for r in (3, 4, 5):
while True:
for ns in combinations(remains, r):
if reduce(xor, ns) == 0:
remains.difference_update(ns)
ans += r - 1
break
else:
break
print(ans)
| from collections import Counter
from functools import reduce
from itertools import combinations
from operator import xor
n = int(eval(input()))
nodes = [0] * n
for _ in range(n - 1):
x, y, a = list(map(int, input().split()))
nodes[x] ^= a
nodes[y] ^= a
c = Counter(nodes)
del c[0]
ans = 0
remains = set()
for i, v in list(c.items()):
ans += v // 2
if v % 2:
remains.add(i)
for r in (3, 4, 5):
while not r < len(remains) < r * 2:
for ns in combinations(remains, r):
if reduce(xor, ns) == 0:
remains.difference_update(ns)
ans += r - 1
break
else:
break
print(ans)
| p03442 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
def f(v,i,ans):
if i == 0:return
if str(v)[-1] != "0":
x = int(str(v)+str(int(str(v)[-1])-1))
ans.add(x)
f(x,i-1,ans)
y = int(str(v)+str(v)[-1])
ans.add(y)
f(y,i-1,ans)
if str(v)[-1] != "9":
z = int(str(v)+str(int(str(v)[-1])+1))
ans.add(z)
f(z,i-1,ans)
def main():
K = int(eval(input()))
ans = set()
for i in range(1,10):
ans.add(i)
f(i,10,ans)
ans = list(ans)
ans.sort()
print((ans[K-1]))
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
from collections import deque
def main():
K = int(eval(input()))
que = deque(["1", "2", "3", "4", "5", "6", "7", "8", "9"])
if K <= 9:
print((que[K-1]))
else:
K -= 9
while K >= 0:
v = que.popleft()
if v[-1] != "0":
K -= 1
v1 = v + str(int(v[-1])-1)
if K == 0:
print(v1)
break
que.append(v1)
K -= 1
v2 = v + v[-1]
if K == 0:
print(v2)
break
que.append(v2)
if v[-1] != "9":
K -= 1
v3 = v + str(int(v[-1])+1)
if K == 0:
print(v3)
break
que.append(v3)
if __name__ == "__main__":
main() | p02720 |
# 再帰的なDFS
def rec(d, val, nums):
nums.append(val)
if d == 10:
return
for delta in (-1, 0, 1):
add = val % 10 + delta
if add >= 0 and add <= 9:
rec(d+1, val * 10 + add, nums)
def main():
K = int(eval(input()))
nums = []
for val in range(1, 10):
rec(1, val, nums)
nums.sort()
print((nums[K-1]))
main() | from collections import deque
K = int(eval(input()))
que = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
for i in range(K):
num = que.popleft()
if i == K-1:
print(num)
break
if num%10 == 0:
que.append(num*10 + num%10)
que.append(num*10 + num%10 + 1)
elif num%10 == 9:
que.append(num*10 + num%10 - 1)
que.append(num*10 + num%10)
else:
que.append(num*10 + num%10 - 1)
que.append(num*10 + num%10)
que.append(num*10 + num%10 + 1)
| p02720 |
from collections import deque
from heapq import heappush, heappop
def main():
K = int(eval(input()))
q = []
for i in range(1, 10):
heappush(q, i)
while True:
v = heappop(q)
K -= 1
if K == 0:
print(v)
exit()
u = v % 10
nv = v * 10 + u
heappush(q, nv)
if u == 0:
heappush(q, nv + 1)
elif u == 9:
heappush(q, nv - 1)
else:
heappush(q, nv - 1)
heappush(q, nv + 1)
main()
| from collections import deque
from collections import deque
def main():
K = int(eval(input()))
q = deque()
for i in range(1, 10):
q.append(i)
while True:
v = q.popleft()
K -= 1
if K == 0:
print(v)
exit()
u = v % 10
nv = v * 10 + u
if u == 0:
q.append(nv)
q.append(nv + 1)
elif u == 9:
q.append(nv - 1)
q.append(nv)
else:
q.append(nv - 1)
q.append(nv)
q.append(nv + 1)
main()
| p02720 |
K = int(eval(input()))
ans = []
R = [[] for _ in range(11)]
for i in range(1,10):
R[0].append(i)
for i in range(1,11):
R[i] = [10**i]
if i > 1:
for j in range(i-1):
for r in R[i-2-j]:
d = r//(10**(i-2-j))
if d <= 1:
R[i].append(10**i+r)
for r in R[i-1]:
d = r//(10**(i-1))
for j in [-1,0,1]:
if 1<= d+j <= 9:
R[i].append((d+j)*(10**i)+r)
A = []
#print(sorted(R[0]))
#print(sorted(R[1]))
#print(sorted(R[2]))
#print(sorted(R[3]))
#print(sorted(R[4]))
#print(sorted(R[10]))
for i in range(11):
for r in R[i]:
A.append(r)
A.sort()
#print(len(A))
print((A[K-1]))
| from heapq import heappush, heappop
K = int(eval(input()))
hq = []
for i in range(1,10):
heappush(hq,i)
cnt = 0
while(cnt < K):
x = heappop(hq)
cnt += 1
for i in [-1,0,1]:
d = (x%10)+i
if 0 <= d <= 9:
heappush(hq,x*10+d)
print(x)
| p02720 |
from collections import deque
k=int(eval(input()))
d=deque()
for i in range(1,10): d.append(i)
for i in range(k):
x=d.popleft()
if i==k-1:
print(x)
break
if x%10!=0:
d.append(10*x+x%10-1)
d.append(10*x+x%10)
if x%10!=9:
d.append(10*x+x%10+1) | from collections import deque
d=deque(list(range(1,10)))
for i in range(int(eval(input()))):
x=d.popleft()
r=x%10;c=x*10+r
if r!=0:d.append(c-1)
d.append(c)
if r!=9:d.append(c+1)
print(x) | p02720 |
k=int(eval(input()))
l=[]
for i1 in range(10):
l.append(i1)
for i2 in range(max(i1-1,0),min(i1+2,10)):
l.append(i1*(10**1)+i2)
for i3 in range(max(i2-1,0),min(i2+2,10)):
l.append(i1*(10**2)+i2*(10**1)+i3)
for i4 in range(max(i3-1,0),min(i3+2,10)):
l.append(i1*(10**3)+i2*(10**2)+i3*(10**1)+i4)
for i5 in range(max(i4-1,0),min(i4+2,10)):
l.append(i1*(10**4)+i2*(10**3)+i3*(10**2)+i4*(10**1)+i5)
for i6 in range(max(i5-1,0),min(i5+2,10)):
l.append(i1*(10**5)+i2*(10**4)+i3*(10**3)+i4*(10**2)+i5*(10**1)+i6)
for i7 in range(max(i6-1,0),min(i6+2,10)):
l.append(i1*(10**6)+i2*(10**5)+i3*(10**4)+i4*(10**3)+i5*(10**2)+i6*(10**1)+i7)
for i8 in range(max(i7-1,0),min(i7+2,10)):
l.append(i1*(10**7)+i2*(10**6)+i3*(10**5)+i4*(10**4)+i5*(10**3)+i6*(10**2)+i7*(10**1)+i8)
for i9 in range(max(i8-1,0),min(i8+2,10)):
l.append(i1*(10**8)+i2*(10**7)+i3*(10**6)+i4*(10**5)+i5*(10**4)+i6*(10**3)+i7*(10**2)+i8*(10**1)+i9)
for i10 in range(max(i9-1,0),min(i9+2,10)):
l.append(i1*(10**9)+i2*(10**8)+i3*(10**7)+i4*(10**6)+i5*(10**5)+i6*(10**4)+i7*(10**3)+i8*(10**2)+i9*(10**1)+i10)
l=list(set(l))
l.sort()
print((l[k])) | import copy
k=int(eval(input()))
ans=[[str(i+1) for i in range(9)]]
l2=[]
for i in range(9):
l=ans[-1]
l2=[]
for j in range(len(l)):
if int(l[j][-1])!=0:
l2.append(l[j]+str(int(l[j][-1])-1))
l2.append(l[j]+str(int(l[j][-1])))
if int(l[j][-1])!=9:
l2.append(l[j]+str(int(l[j][-1])+1))
ans.append(l2)
l=copy.copy(l2)
a=[]
for i in range(10):
a=a+ans[i]
print((a[k-1])) | p02720 |
from collections import deque
def main():
k = int(eval(input()))
queue = deque([i for i in range(1, 10)])
pop_time = 0
now = 1
while pop_time < k:
now = queue.popleft()
if now % 10 != 0:
queue.append(10 * now + now % 10 - 1)
queue.append(10 * now + now % 10)
if now % 10 != 9:
queue.append(10 * now + now % 10 + 1)
pop_time += 1
print(now)
if __name__ == '__main__':
main()
| from collections import deque
def main():
k = int(eval(input()))
q = deque([i for i in range(1, 10)])
answer = 0
for i in range(k):
now = q.popleft()
answer = now
if now % 10 != 0:
q.append(10 * now + now % 10 - 1)
q.append(10 * now + now % 10)
if now % 10 != 9:
q.append(10 * now + now % 10 + 1)
print(answer)
if __name__ == '__main__':
main()
| p02720 |
K = int(eval(input()))
V = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in range (0, 100000):
if V[i]%10 == 0:
V.append(10*V[i]+0)
V.append(10*V[i]+1)
elif V[i]%10 == 9:
V.append(10*V[i]+8)
V.append(10*V[i]+9)
else:
V.append(10*V[i]+V[i]%10-1)
V.append(10*V[i]+V[i]%10)
V.append(10*V[i]+V[i]%10+1)
print((V[K-1])) | import collections
K = int(eval(input()))
L = [1,2,3,4,5,6,7,8,9]
Q = collections.deque(L)
count = 0
while count < K-1:
V = Q.popleft()
count+=1
if V%10 == 0:
Q.append(10*V)
Q.append(10*V+1)
elif V%10 == 9:
Q.append(10*V+8)
Q.append(10*V+9)
else:
Q.append(10*V+(V%10)-1)
Q.append(10*V+(V%10))
Q.append(10*V+(V%10)+1)
print((Q.popleft())) | p02720 |
k = int(eval(input()))
def dfs(now, depth):
STACK.append(str(now))
if depth == limit:
LUNLUN.append(int("".join(STACK)))
else:
for next in range(now - 1, now + 2):
if next == -1 or next == 10:
continue
dfs(next, depth + 1)
STACK.pop()
LUNLUN = []
STACK= []
for limit in range(10):
for i in range(1, 10):
dfs(i, 0)
print((LUNLUN[k - 1]))
| k = int(eval(input()))
L = list(range(10))
i = 1
while len(L) <= k:
Li = L[i]
a = Li % 10
for b in range(a - 1, a + 2):
if b < 0 or b > 9:
continue
L.append(Li * 10 + b)
i += 1
print((L[k]))
| p02720 |
k = int(eval(input()))
a=['1','2','3','4','5','6','7','8','9']
while 1:
if k<=len(a):
print((a[k-1]))
exit()
b=[]
for i in a:
if i[-1]!='0':
b.append(i+chr(ord(i[-1])-1))
b.append(i+i[-1])
if i[-1]!='9':
b.append(i+chr(ord(i[-1])+1))
k-=len(a)
a=b.copy() | k = int(eval(input()))
a=['1','2','3','4','5','6','7','8','9']
while k>len(a):
b=[]
for i in a:
if i[-1]!='0':
b.append(i+chr(ord(i[-1])-1))
b.append(i+i[-1])
if i[-1]!='9':
b.append(i+chr(ord(i[-1])+1))
k-=len(a)
a=b.copy()
print((a[k-1])) | p02720 |
K = int(eval(input()))
def dfs(d, val, x):
x.append(val)
if d == 10:
return
for i in range(-1, 2):
add = (val % 10) + i
if 0 <= add <= 9:
dfs(d + 1, val * 10 + add, x)
x = []
for i in range(1, 10):
dfs(0, i, x)
print((sorted(x)[K - 1]))
| from collections import deque
K = int(eval(input()))
q = deque(list(range(1, 10)))
ctr = 0
while ctr < K:
val = q.popleft()
ctr += 1
for i in range(-1, 2):
add = (val % 10) + i
if 0 <= add <= 9:
q.append(val * 10 + add)
print(val)
| p02720 |
from collections import deque
K = int(eval(input()))
q = deque(list(range(1, 10)))
cnt = 0
ans = 0
while True:
u = q.popleft()
cnt += 1
if cnt == K:
ans = u
break
ll = u % 10
for i in range(max(0, ll - 1), min(9, ll + 1) + 1):
q.append(u * 10 + i)
print(ans)
|
from collections import deque
K = int(eval(input()))
q = deque(list(range(1, 10)))
for _ in range(K - 1):
u = q.popleft()
n = u % 10
for x in range(max(0, n - 1), min(9, n + 1) + 1):
q.append(u * 10 + x)
print((q.popleft()))
| p02720 |
from queue import Queue
def solve():
K = int(eval(input()))
q = Queue()
for i in range(9):
q.put(i+1)
num = 0
for i in range(K):
num = q.get()
if num % 10 != 0:
q.put(num*10+num % 10-1)
q.put(num*10+num % 10)
if num % 10 != 9:
q.put(num*10+num % 10+1)
print(num)
if __name__ == "__main__":
solve()
| from collections import deque
def solve():
K = int(eval(input()))
dq = deque()
# 一桁のケース
for i in range(9):
dq.append(i+1)
for i in range(K):
num = dq.popleft()
if num % 10 != 0:
dq.append(num*10+num % 10-1)
dq.append(num*10+num % 10)
if num % 10 != 9:
dq.append(num*10+num % 10+1)
print(num)
if __name__ == "__main__":
solve()
| p02720 |
maxn = 100005
def solve(n):
if n<=9:
return n
q = [0 for i in range(maxn)]
front = 1
rear = 0
for i in range(1,10):
rear += 1
q[rear] = i
cnt = 9
while 1:
u = q[front]
front += 1
if u%10 != 0:
t = u*10 + u%10 -1
rear += 1
q[rear] = t
cnt += 1
if cnt==n:
return t
t = u*10 + u%10
rear += 1
q[rear] = t
cnt += 1
if cnt==n:
return t;
if u%10 != 9:
t = u*10 + u%10 + 1
rear += 1
q[rear] = t
cnt += 1
if cnt==n:
return t
print((solve(int(eval(input()))))) | def solve(n):
if n<=9:
return n
q = [0]
for i in range(1,10):
q.append(i)
now = 1
cnt = 9
while 1:
u = q[now]
now += 1
if u%10!=0:
t = u*10 + u%10 - 1
cnt += 1
if cnt==n:
return t
q.append(t)
t = u*10 + u%10
cnt += 1
if cnt==n:
return t
q.append(t)
if u%10 !=9:
t = u*10 + u%10 + 1
cnt += 1
if cnt==n:
return t
q.append(t)
print((solve(int(eval(input()))))) | p02720 |
from itertools import product
K = int(eval(input()))
ans = []
for l in range(10):
for s in range(1, 10):
for pattern in product([0, 1, 2], repeat=l): # そのまま, １つ上, １つ下
X = [s]
for p in pattern:
if X[-1] == 0 and p == 2:
break
if X[-1] == 9 and p == 1:
break
if p == 0:
X.append(X[-1])
if p == 1:
X.append(X[-1] + 1)
if p == 2:
X.append(X[-1] - 1)
else:
ans.append(int(''.join(map(str, X))))
ans.sort()
print((ans[K - 1]))
| from itertools import product
K = int(eval(input()))
ans = []
for l in range(10):
for s in range(1, 10):
for pattern in product([-1, 0, 1], repeat=l):
X = [s]
for p in pattern:
if not (0 <= X[-1] + p <= 9):
break
X.append(X[-1] + p)
else:
ans.append(int(''.join(map(str, X))))
ans.sort()
print((ans[K - 1]))
| p02720 |
k = int(eval(input()))
numset = {i for i in range(1,10)}
flag = False
count = len(numset)
if count >= k:
flag = True
arr = [numset]
index = 0
while not flag:
beforeset = arr[index]
tmpset = set()
for i in beforeset:
tail = str(i)[-1]
if tail == "0":
tmpset.add(int(str(i)+str(0)))
tmpset.add(int(str(i)+str(1)))
elif tail == "9":
tmpset.add(int(str(i)+str(8)))
tmpset.add(int(str(i)+str(9)))
else:
tmpset.add(int(str(i)+str(int(tail))))
tmpset.add(int(str(i)+str(int(tail)+1)))
tmpset.add(int(str(i)+str(int(tail)-1)))
count += len(tmpset)
if count >= k:
flag = True
arr.append(tmpset)
index += 1
totalarr = []
for tmpset in arr:
totalarr += list(tmpset)
totalarr.sort()
print((totalarr[k-1])) | k = int(eval(input()))
from collections import deque
queue = deque(list(range(1,10)))
count = 0
while count < k:
tmp = queue.popleft()
tail = tmp%10
if tail != 0:
queue.append(tmp*10+tail-1)
queue.append(tmp*10+tail)
if tail != 9:
queue.append(tmp*10+tail+1)
count += 1
print(tmp)
| p02720 |
from collections import deque
K = int(eval(input()))
q = deque([0])
cnt = 0
ans = []
while q:
a = q.popleft()
r = a % 10
a *= 10
for i in range(10):
if abs(r - i) <= 1 or a == 0:
if cnt < K and a + i != 0:
q.append(a + i)
ans.append(a + i)
cnt += 1
print((ans[-1])) | from collections import deque
K = int(eval(input()))
q = deque([0])
cnt = 0
while q:
n = q.popleft()
r = n % 10; n *= 10;
for i in range(10):
if abs(r - i) <= 1 or n == 0:
if n + i != 0:
q.append(n + i)
cnt += 1
if cnt == K:
print((n+i))
exit() | p02720 |
def lunlun(n):
nums = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
while len(nums) < n:
old_nums = list(nums)
for num in old_nums:
num = str(num)
if num[-1] == '0':
adds = num + '0'
if int(adds) not in nums:
nums.add(int(adds))
adds = num + '1'
if int(adds) not in nums:
nums.add(int(adds))
elif num[-1] == '9':
adds = num + '9'
if int(adds) not in nums:
nums.add(int(adds))
adds = num + '8'
if int(adds) not in nums:
nums.add(int(adds))
else:
adds = num + str(int(num[-1]) - 1)
if int(adds) not in nums:
nums.add(int(adds))
adds = num + str(int(num[-1]))
if int(adds) not in nums:
nums.add(int(adds))
adds = num + str(int(num[-1]) + 1)
if int(adds) not in nums:
nums.add(int(adds))
if num[0] == '1':
adds = '1' + num
if int(adds) not in nums:
nums.add(int(adds))
adds = '2' + num
if int(adds) not in nums:
nums.add(int(adds))
elif num[0] == '9':
adds = '8' + num
if int(adds) not in nums:
nums.add(int(adds))
adds = '9' + num
if int(adds) not in nums:
nums.add(int(adds))
else:
adds = str(int(num[0]) - 1) + num
if int(adds) not in nums:
nums.add(int(adds))
adds = str(int(num[0])) + num
if int(adds) not in nums:
nums.add(int(adds))
adds = str(int(num[0]) + 1) + num
if int(adds) not in nums:
nums.add(int(adds))
nums = list(nums)
nums = sorted(nums)
return nums[n - 1]
n = int(eval(input()))
print((lunlun(n))) | def lunlun(n):
nums = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
while len(nums) < n:
old_nums = list(nums)
for num in old_nums:
num = str(num)
if num[-1] == '0':
adds = num + '0'
if int(adds) not in nums:
nums.add(int(adds))
adds = num + '1'
if int(adds) not in nums:
nums.add(int(adds))
elif num[-1] == '9':
adds = num + '9'
if int(adds) not in nums:
nums.add(int(adds))
adds = num + '8'
if int(adds) not in nums:
nums.add(int(adds))
else:
adds = num + str(int(num[-1]) - 1)
if int(adds) not in nums:
nums.add(int(adds))
adds = num + str(int(num[-1]))
if int(adds) not in nums:
nums.add(int(adds))
adds = num + str(int(num[-1]) + 1)
if int(adds) not in nums:
nums.add(int(adds))
# if num[0] == '1':
# adds = '1' + num
# if int(adds) not in nums:
# nums.add(int(adds))
# adds = '2' + num
# if int(adds) not in nums:
# nums.add(int(adds))
# elif num[0] == '9':
# adds = '8' + num
# if int(adds) not in nums:
# nums.add(int(adds))
# adds = '9' + num
# if int(adds) not in nums:
# nums.add(int(adds))
# else:
# adds = str(int(num[0]) - 1) + num
# if int(adds) not in nums:
# nums.add(int(adds))
# adds = str(int(num[0])) + num
# if int(adds) not in nums:
# nums.add(int(adds))
# adds = str(int(num[0]) + 1) + num
# if int(adds) not in nums:
# nums.add(int(adds))
nums = list(nums)
nums = sorted(nums)
return nums[n - 1]
n = int(eval(input()))
print((lunlun(n))) | p02720 |
import sys
sys.setrecursionlimit(10**9)
k=int(eval(input()))
def dfs(keta,num):
lunlun.append(int(num))
if keta==10:
return
min_v=max(0,int(num[-1])-1)
max_v=min(9,int(num[-1])+1)
for i in range(min_v,max_v+1):
dfs(keta+1,num+str(i))
lunlun=[]
for i in range(1,10):
dfs(0,str(i))
lunlun.sort()
print((lunlun[k-1])) | k=int(eval(input()))
def dfs(keta,num):
global ans
ans.append(int(''.join(num)))
if keta==10:
return
min_n=max(0,int(num[-1])-1)
max_n=min(9,int(num[-1])+1)
for i in range(min_n,max_n+1):
dfs(keta+1,num+[str(i)])
ans=[]
for i in range(1,10):
dfs(1,[str(i)])
ans.sort()
print((ans[k-1])) | p02720 |
#!/usr/bin/env python3
from heapq import *
a = [*list(range(1, 10))]
heapify(a)
i = 0
k = int(eval(input()))
c = 0
while True:
t = str(heappop(a))
i += 1
if i == k:
break
if t[-1] != "0":
heappush(a, int(t + str(int(t[-1]) - 1)))
heappush(a, int(t + t[-1]))
if t[-1] != "9":
heappush(a, int(t + str(int(t[-1]) + 1)))
print(t)
| # !/usr/bin/env python3
# from heapq import *
#
# a = [*range(1, 10)]
# heapify(a)
# i = 0
# k = int(input())
# c = 0
# while True:
# t = str(heappop(a))
# i += 1
# if i == k:
# break
# if t[-1] != "0":
# heappush(a, int(t + str(int(t[-1]) - 1)))
# heappush(a, int(t + t[-1]))
# if t[-1] != "9":
# heappush(a, int(t + str(int(t[-1]) + 1)))
# print(t)
from collections import deque
a = deque(list(range(1, 10)))
for _ in range(int(eval(input()))):
i = a.popleft()
m = i % 10
i = 10 * i + m
if m > 0:
a.append(i - 1)
a.append(i)
if m < 9:
a.append(i + 1)
print((i // 10))
| p02720 |
import heapq
K=int(eval(input()))
if K<10:
print(K)
exit()
nums=[1, 2, 3, 4, 5, 6, 7, 8, 9]
heapq.heapify(nums)
for i in range(K):
value=heapq.heappop(nums)
tmp=str(value)
if tmp[-1]=='0':
cand=[int(tmp+'0'), int(tmp+'1')]
elif tmp[-1]=='9':
cand=[int(tmp+'8'), int(tmp+'9')]
else:
h=int(tmp[-1])
cand=[int(tmp+str(h-1)), int(tmp+str(h)), int(tmp+str(h+1))]
for c in cand:
heapq.heappush(nums, c)
print(value) | from collections import deque
K=int(eval(input()))
q=deque()
for i in range(1, 10):
q.append(i)
for i in range(K):
v=q.popleft()
if v%10!=0:
q.append(10*v+v%10-1)
q.append(10*v+v%10)
if v%10!=9:
q.append(10*v+v%10+1)
print(v) | p02720 |
import queue
def solved(n):
if n <= 9:
return n
nums = queue.Queue()
for i in range(1, 10):
nums.put(i)
cnt = 9
for i in range(cnt, n):
i_num = nums.get()
ini_num = i_num % 10
for j in range(max(0, ini_num - 1), min(10, ini_num + 2)):
nums.put(i_num * 10 + j)
cnt += 1
if cnt == n:
return i_num * 10 + j
k = int(eval(input()))
num = queue.Queue()
print((solved(k))) | import queue
def solve(n):
if n < 10:
return n
cnt = 0
next = queue.Queue()
for i in range(1, 10):
next.put(i)
cnt += 1
while True:
i = next.get()
for j in range(i % 10 - 1, i % 10 + 2):
if j < 0 or 9 < j:
continue
next.put(i * 10 + j)
cnt += 1
if cnt == n:
return i * 10 + j
k = int(eval(input()))
next = queue.Queue
print((solve(k)))
| p02720 |
def main():
from collections import deque
k = int(eval(input()))
ans = 0
que = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
x = 0
for _ in range(k):
x = que.popleft()
p = x % 10
e = 10 * x
if p != 0:
a = e + p - 1
que.append(a)
b = e + p
que.append(b)
if p != 9:
c = e + p + 1
que.append(c)
print(x)
if __name__ == '__main__':
main()
| def LunLun(k, count, base):
nx = []
n = len(base)
if count + n >= k:
print((base[k - count - 1]))
return
for x in base:
count += 1
p = x % 10
x *= 10
a = x + p - 1
b = a + 1
c = b + 1
n = 3
if p == 0:
n -= 1
nx.extend([b, c])
elif p == 9:
n -= 1
nx.extend([a, b])
else:
nx.extend([a, b, c])
LunLun(k, count, nx)
def main():
k = int(eval(input()))
base = list(range(1, 10))
LunLun(k, 0, base)
if __name__ == '__main__':
main()
| p02720 |
def LunLun(k, count, base):
nx = []
n = len(base)
if count + n >= k:
ans = base[k - count - 1]
return ans
for x in base:
count += 1
p = x % 10
x *= 10
a = x + p - 1
b = a + 1
c = b + 1
n = 3
if p == 0:
n -= 1
nx.extend([b, c])
elif p == 9:
n -= 1
nx.extend([a, b])
else:
nx.extend([a, b, c])
return LunLun(k, count, nx)
def main():
k = int(eval(input()))
base = list(range(1, 10))
ans = LunLun(k, 0, base)
print(ans)
if __name__ == '__main__':
main()
| def LunLun(k, count, base):
nx = []
n = len(base)
if count + n >= k:
ans = base[k - count - 1]
print(ans)
exit()
for x in base:
count += 1
p = x % 10
x *= 10
a = x + p - 1
b = a + 1
c = b + 1
n = 3
if p == 0:
n -= 1
nx.extend([b, c])
elif p == 9:
n -= 1
nx.extend([a, b])
else:
nx.extend([a, b, c])
return LunLun(k, count, nx)
def main():
k = int(eval(input()))
base = list(range(1, 10))
LunLun(k, 0, base)
if __name__ == '__main__':
main()
| p02720 |
# coding: utf-8
# Your code here!
from collections import deque
k=int(eval(input()))
ans=[]
d=deque([1,2,3,4,5,6,7,8,9])
c=0
while c<11:
q=d.popleft()
ans.append(q)
c=len(str(q))
b=q%10
if b!=0:
d.append(q*10+b-1)
d.append(q*10+b)
if b!=9:
d.append(q*10+b+1)
print((ans[k-1])) | # coding: utf-8
# Your code here!
from collections import deque
k=int(eval(input()))
ans=[]
d=deque([1,2,3,4,5,6,7,8,9])
c=0
while c<100100:
q=d.popleft()
ans.append(q)
c+=1
b=q%10
if b!=0:
d.append(q*10+b-1)
d.append(q*10+b)
if b!=9:
d.append(q*10+b+1)
print((ans[k-1])) | p02720 |
n=int(eval(input()))
if n<10: print(n); exit()
l=[[[] for _ in range(10)] for _ in range(10)]
l[0]=[[i] for i in range(10)]
c=9
for i in range(9):
for j in range(10):
for k in (-1,0,1):
if 0<=j+k<=9:
for h in l[i][j+k]:
if j: c+=1
t=j*10**(i+1)+h
l[i+1][j]+=[t]
if c==n: print(t); exit() | n=int(eval(input()))
if n<10: print(n); exit()
r=range
l=[[[] for _ in r(10)] for _ in r(10)]
l[0]=[[i] for i in r(10)]
c=9
for i in r(9):
for j in r(10):
for k in r(-1,2):
if 0<=j+k<=9:
for h in l[i][j+k]:
if j: c+=1
t=j*10**(i+1)+h
l[i+1][j]+=[t]
if c==n: print(t); exit() | p02720 |
from collections import *
k=int(eval(input()));q=deque(list(range(1,10)));c=0
while c<k:
t=q.popleft()
for j in range(max(t%10-1,0),min(t%10+2,10)): q+=[t*10+j]
c+=1
print(t) | k=int(eval(input()));l=list(range(1,10))
for i in l:
if len(l)>k: break
for j in range(max(i%10-1,0),min(i%10+2,10)): l.append(i*10+j)
print((l[k-1])) | p02720 |
k = int(eval(input()))
lunlun = list(range(1, 10))
for i in range(k - 1):
a = lunlun[i]
b = a * 10 + a % 10
if a % 10 != 0:
lunlun.append(b - 1)
lunlun.append(b)
if a % 10 != 9:
lunlun.append(b + 1)
print((lunlun[k - 1])) | k = int(eval(input()))
li = [i + 1 for i in range(9)]
c = 0
while len(li) < k:
if li[c] % 10 != 0:
li.append(li[c] * 10 + li[c] % 10 - 1)
li.append(li[c] * 10 + li[c] % 10)
if li[c] % 10 != 9:
li.append(li[c] * 10 + li[c] % 10 + 1)
c += 1
print((li[k - 1])) | p02720 |
k = int(eval(input()))
cnt = 1
loop = 1
r_li = []
# 一桁小さいるんるんリストから次のるんるんリストを作成
def make_runrun(i, runrun_list):
new_list = []
for runrun in runrun_list:
new_list.append('{}{}'.format(i, runrun))
return new_list
tmp = [[str(i)] for i in range(10)]
r_li = [str(i) for i in range(1, 10)]
# 桁数ごとにループ
while len(r_li) < k:
# 一桁小さいルンルン数のリスト
next_tmp = [[]] * 10
for i in range(1, 10):
l = 0
r_li.extend(make_runrun(i, tmp[i - 1]))
l += len(tmp[i - 1])
r_li.extend(make_runrun(i, tmp[i]))
l += len(tmp[i])
if i != 9:
r_li.extend(make_runrun(i, tmp[i + 1]))
l += len(tmp[i + 1])
next_tmp[i] = r_li[-l:]
for i in tmp[0]:
next_tmp[0].append('{}{}'.format(0, i))
for i in tmp[1]:
next_tmp[0].append('{}{}'.format(0, i))
tmp = next_tmp
print((r_li[k - 1])) | from collections import deque
k = int(eval(input()))
lunlun = deque([])
ans = 0
# 一桁のルンルン数
for i in range(1, 10):
lunlun.append(str(i))
if k < 10:
ans = lunlun[k - 1]
# 二桁以上のルンルン数
cnt = 9
while cnt < k + 1:
# 1番小さなルンルン数を抜き出す
l = lunlun.popleft()
l_last = int(l[-1])
if l_last != 0:
lunlun.append('{}{}'.format(l, l_last - 1))
cnt += 1
if cnt == k:
ans = lunlun[-1]
break
lunlun.append('{}{}'.format(l, l_last))
cnt += 1
if cnt == k:
ans = lunlun[-1]
break
if l_last != 9:
lunlun.append('{}{}'.format(l, l_last + 1))
cnt += 1
if cnt == k:
ans = lunlun[-1]
break
print(ans) | p02720 |
def dfs(inParam, digits, lunlunCount, lunlun):
if len(inParam) != digits:
if int(inParam[len(inParam)-1]) == 0:
nextNumList = [0, 1]
elif int(inParam[len(inParam)-1]) == 9:
nextNumList = [8, 9]
else:
nextNum = int(inParam[len(inParam)-1])
nextNumList = [nextNum-1, nextNum, nextNum+1]
for item in nextNumList:
myTupp = dfs(inParam+str(item), digits, lunlunCount, lunlun)
lunlunCount = myTupp[0]
if myTupp[2] == 'e':
return myTupp
return myTupp
else:
lunlunCount += 1
state = 'c'
if lunlunCount == lunlun:
state = 'e'
print(inParam)
return (lunlunCount, inParam, state)
K = int(eval(input()))
mylunlun = 0
mydigits = 1
while mylunlun != K:
for indx in range(1, 10):
mylunlun, lunlunNumber, _ = dfs(str(indx), mydigits, mylunlun, K)
# if mylunlun == K:
# break
if mylunlun >= K:
break
mydigits += 1
| K = int(eval(input()))
if K <= 9:
print(K)
else:
mylun = 9
lunList = []
for indx in range(1, 10):
lunList.append(str(indx))
while mylun < K:
newLunList = []
for lunItem in lunList:
if lunItem[len(lunItem)-1] != "0":
mylun += 1
newLunList.append(lunItem + str( int(lunItem[len(lunItem)-1])-1 ))
if mylun == K:
print((lunItem + str( int(lunItem[len(lunItem)-1])-1 )))
break
mylun += 1
newLunList.append(lunItem + str( int(lunItem[len(lunItem)-1]) ))
if mylun == K:
print((lunItem + str( int(lunItem[len(lunItem)-1]) )))
break
if lunItem[len(lunItem)-1] != "9":
mylun += 1
newLunList.append(lunItem + str( int(lunItem[len(lunItem)-1])+1 ))
if mylun == K:
print((lunItem + str( int(lunItem[len(lunItem)-1])+1 )))
break
lunList = newLunList
| p02720 |
k=int(eval(input()))
cand=[[1,2,3,4,5,6,7,8,9]]
for _ in range(9):
tmp=[]
for val in cand[-1]:
s=str(val)
if s[-1]=='0':
tmp.append(val*10)
tmp.append(val*10+1)
elif s[-1]=='9':
tmp.append(val*10+8)
tmp.append(val*10+9)
else:
tmp.append(val*10+(int(s[-1])-1))
tmp.append(val*10+(int(s[-1])))
tmp.append(val*10+(int(s[-1])+1))
cand.append(tmp)
ans=[]
for i in range(len(cand)):
for val in cand[i]:
ans.append(val)
ans=sorted(ans)
print((ans[k-1])) | k=int(eval(input()))
cand=[[1,2,3,4,5,6,7,8,9]]
for _ in range(9):
tmp=[]
for val in cand[-1]:
if val%10!=0:
tmp.append(val*10+(val%10-1))
tmp.append(val*10+(val%10))
if val%10!=9:
tmp.append(val*10+(val%10+1))
cand.append(tmp)
ans=[]
for i in range(len(cand)):
for val in cand[i]:
ans.append(val)
ans=sorted(ans)
print((ans[k-1])) | p02720 |
import queue
k = int(eval(input()))
q = queue.Queue()
for i in range(1,10):
q.put(i)
for i in range(k):
x = q.get()
if not x%10 == 0:
q.put(10*x+(x%10)-1)
q.put(10*x+(x%10))
if not x%10 == 9:
q.put(10*x+(x%10)+1)
print(x)
| import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
k = int(ipt())
q = queue.Queue()
for i in range(1,10):
q.put(i)
for _ in [0]*k:
qi = q.get()
if not qi%10 == 0:
q.put(qi*10+qi%10-1)
q.put(qi*10+qi%10)
if not qi%10 == 9:
q.put(qi*10+qi%10+1)
print(qi)
return
if __name__ == '__main__':
main()
| p02720 |
import collections
def go_next(digits):
if all(x==9 for x in digits):
return [0]*len(digits) + [1]
digits[0] += 1
maxInc = -1
# print(digits)
for i in range(1, len(digits)):
if digits[i-1] >= 10 or abs(digits[i]-digits[i-1]) >= 2:
digits[i] += 1
maxInc = i
else:
break
# print(digits)
if maxInc > 0:
for i in range(maxInc, 0, -1):
digits[i-1] = max(0, digits[i]-1)
return digits
# go_next([9,8])
def main():
K = int(eval(input()))
digits = [0]
for _ in range(K):
digits = go_next(digits)
print(("".join(map(str, reversed(digits)))))
if __name__ == '__main__':
main() | def main():
from collections import deque
K = int(eval(input()))
q = deque(list(range(1, 10)))
for _ in range(K):
x = q.popleft()
lastdigit = x%10
base = x*10 + lastdigit
if lastdigit != 0:
q.append(base-1)
q.append(base)
if lastdigit != 9:
q.append(base+1)
print(x)
if __name__ == '__main__':
main() | p02720 |
import sys
from collections import deque
input=sys.stdin.readline
sys.setrecursionlimit(10**6)
lunlun=deque()
def dfs(now):
if len(now)>10:return
lunlun.append(int(now))
l=now[-1]
if l!="0":
dfs(now+str(int(l)-1))
if l!="9":
dfs(now+str(int(l)+1))
dfs(now+l)
k=int(input().rstrip())
for i in range(1,10):
dfs(str(i))
print((sorted(lunlun)[k-1])) | import sys
from collections import deque
input=sys.stdin.readline
sys.setrecursionlimit(10**6)
def main():
k=int(input().rstrip())
lunlun=deque([str(i) for i in range(1,10)])
for _ in range(k-1):
now=lunlun.popleft()
last=now[-1]
if last!="0":
lunlun.append(now+str(int(last)-1))
lunlun.append(now+last)
if last!="9":
lunlun.append(now+str(int(last)+1))
print((lunlun[0]))
if __name__=="__main__":
main() | p02720 |
import sys
input = sys.stdin.readline
import itertools
lunlun = [[] for i in range(11)]
def main():
n = int(eval(input()))
for i in range(100):
flag = True
l = len(str(i))
if l == 1:
lunlun[l - 1].append(i)
else:
for a in range(1, len(str(i))):
if abs(int(str(i)[a - 1]) - int(str(i)[a])) >= 2:
flag = False
break
if flag:
lunlun[l - 1].append(i)
else:
continue
for j in range(1, 9):
for a in lunlun[j]:
for b in range(10):
if abs(int(str(a)[-1]) - b) < 2:
lunlun[j+1].append(int(str(a)+str(b)))
lunlun2 = list(itertools.chain.from_iterable(lunlun))
print((lunlun2[n]))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
lunlun = [[] for i in range(11)]
lunlun[0] = [1, 2, 3, 4, 5, 6, 7, 8, 9]
cnt = 9
if n < 10:
print(n)
exit()
for j in range(0, 10):
for a in lunlun[j]:
for b in range(10):
if abs((a % 10) - b) < 2:
lunlun[j + 1].append(10 * a + b)
cnt += 1
if cnt == n:
print((10 * a + b))
exit()
if __name__ == '__main__':
main()
| p02720 |
import queue
k = int(eval(input()))
q = queue.Queue()
num = 0
for i in range(1,10):
q.put(i)
while num<k:
i = q.get()
l = i%10
if l!=0:
q.put(i*10+l-1)
q.put(i*10+l)
if l!=9:
q.put(i*10+l+1)
num += 1
print(i)
| k = int(eval(input()))
lst = [1,2,3,4,5,6,7,8,9]
count = 0
for i in range(k):
num = lst[count]
if num%10!=0:
lst.append(num*10+num%10-1)
lst.append(num*10+num%10)
if num%10!=9:
lst.append(num*10+num%10+1)
count += 1
print((lst[k-1]))
| p02720 |
from collections import deque
K = int(eval(input()))
dque = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
ans = 0
while True:
v = dque.popleft()
ans += 1
if ans == K:
print(v)
exit(0)
strv = str(v)
if strv[-1] == '0':
dque.append(int(strv+'0'))
dque.append(int(strv+'1'))
elif strv[-1] == '9':
dque.append(int(strv+'8'))
dque.append(int(strv+'9'))
else:
endv = int(strv[-1])
dque.append(int(strv+str(endv-1)))
dque.append(int(strv+str(endv)))
dque.append(int(strv+str(endv+1)))
| from collections import deque
K = int(eval(input()))
dque = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
ans = 0
while True:
v = dque.popleft()
ans += 1
if ans == K:
print(v)
exit(0)
for i in range(-1, 2):
# 10で割った余りを取得して、iを足す
tmp = v % 10+i
if not(0 <= tmp <= 9):
continue
dque.append(v*10+tmp) | p02720 |
import copy
k = int(eval(input()))
lun = [1,2,3,4,5,6,7,8,9]
tlun = []
tlun = copy.deepcopy(lun)
length = 2
while len(lun) < k:
tmp = []
for x in tlun:
y = str(x)
xt = int( y[-1] )
a = xt + 1
b = xt - 1
if a != 10:
lun.append(int(y+str(a)))
tmp.append(int(y+str(a)))
if b != -1:
lun.append(int(y+str(b)))
tmp.append(int(y+str(b)))
lun.append(int(y+str(xt)))
tmp.append(int(y+str(xt)))
tlun = copy.deepcopy(tmp)
lun.sort()
print((lun[k-1]))
|
import copy
k = int(eval(input()))
lun = [1,2,3,4,5,6,7,8,9]
tlun = []
tlun = copy.deepcopy(lun)
length = 2
while len(lun) < k:
tmp = []
for x in tlun:
y = str(x)
xt = int( y[-1] )
a = xt + 1
b = xt - 1
if b != -1:
lun.append(int(y+str(b)))
tmp.append(int(y+str(b)))
lun.append(int(y+str(xt)))
tmp.append(int(y+str(xt)))
if a != 10:
lun.append(int(y+str(a)))
tmp.append(int(y+str(a)))
tlun = copy.deepcopy(tmp)
# lun.sort()
print((lun[k-1]))
| p02720 |
k = int(eval(input()))
lun_ls = []
def change_to_num(ls):
ls = list(map(str, ls))
strnum = ''.join(ls)
return int(strnum)
def lun(num):
'''
渡された数が上限行ってなければlun_lsに追加して、次の数で再帰呼出
'''
if num > 3234566667:
return
lun_ls.append(num)
last = num % 10
for nex in range(last-1, last+2):
if 0<= nex < 10:
new_str = str(num) + str(nex)
new = int(new_str)
lun(new)
for start in range(1,10):
lun(start)
lun_ls.sort()
print((lun_ls[k-1])) | k = int(eval(input()))
# やっぱり一旦はglobalで書こ
total_ls = []
def dfs(A):
if int(A) > 3234566667:
return
global total_ls
total_ls.append(int(A))
last = int(A[-1])
if last == 0:
nex = [1,0]
elif last == 9:
nex = [8,9]
else:
nex = [last-1,last,last+1]
for n in nex:
A += str(n)
dfs(A)
A = A[:-1]
for i in range(1,10):
dfs(str(i))
total_ls.sort()
print((total_ls[k-1]))
| p02720 |
k=int(eval(input()))
#a,b=map(int,input().split())
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
from collections import deque
q=deque([1,2,3,4,5,6,7,8,9])
ansl=[]
s=1
while len(str(s))<=10:
s=q.popleft()
ansl.append(s)
sl=list(str(s))
last_digit=int(sl[-1])
for digit in range(max(0,last_digit-1),min(last_digit+1,9)+1):
newval=int(str(s)+str(digit))
#ansl.append(int(str(s)+str(digit)))
q.append(newval)
print((ansl[k-1]))
| k=int(eval(input()))
#n,p=map(int,input().split())
#al=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
#素因数分解した結果を2次元配列にして返す
all_list=[]
def rec(d,val):
global all_list
all_list.append(val)
if d==10:
return
for j in range(-1,2,1):
add=val%10+j
if add>=0 and add<=9:
rec(d+1,val*10+add)
for i in range(1,10):
rec(1,i)
all_list.sort()
print((all_list[k-1])) | p02720 |
k = int(eval(input()))
l = set()
def construct(lunnum: str, depth: int, flag: bool):
global l
if depth == 0:
l.add(int(lunnum))
return
m = int(lunnum[-1])
for i in list(range(0, 10)) if flag else set([max(0, m - 1), m, min(9, m + 1)]):
construct(lunnum + str(i), depth - 1, (i == 0) & flag)
construct("0", 10, True)
ls = sorted(list(l))
print((ls[k]))
| k = int(eval(input()))
l = set()
# lunnum : 構築中のルンルン数
# depth : 桁数
# flag : 上位桁が全て0かどうかのフラグ
def construct(lunnum: str, depth: int, flag: bool):
global l
if depth == 0:
l.add(int(lunnum))
return
# m = 末尾桁の値
m = int(lunnum[-1])
if flag:
# 上位桁に0以外の数字が無いなら
for i in range(0, 10):
construct(lunnum + str(i), depth - 1, i == 0)
else:
# m=[1,8] は [m-1,m,m+1], m=0 は [0,1], m=9 は [8,9] を末尾にくっつけて再帰
for i in set([max(0, m - 1), m, min(9, m + 1)]):
construct(lunnum + str(i), depth - 1, False)
# サンプルケース(input=100000 output=3234566667)より、答えは10桁以下であるのでdepth=10としてDFS
construct("0", 10, True)
ls = sorted(list(l))
print((ls[k]))
| p02720 |
k=int(eval(input()))
a=[]
for i in range(1,10):
a.append(i)
while True:
if k<=len(a):
print((a[k-1]))
break
k-=len(a)
old=[]
old,a=a,old
for x in old:
for i in range(-1,2):
d=x%10+i
if d<0 or d>9:
continue
nx=x*10+d
a.append(nx)
| k=int(eval(input()))
a=[i for i in range(1,10)]
for x in a:
if k<=len(a):
break
if x%10!=0:
a.append(10*x+(x%10)-1)
a.append(10*x+(x%10))
if x%10!=9:
a.append(10*x+(x%10)+1)
print((a[k-1])) | p02720 |
import sys
from collections import deque
sys.setrecursionlimit(10**9)
K = int(eval(input()))
lis = deque()
def dfs(nowD, maxD, x):
if nowD == maxD:
lis.append(x)
if len(lis) >= K:
print((lis.pop()))
exit()
else:
y = x%10
x *= 10
if y-1 >= 0:
dfs(nowD+1, maxD, x+y-1)
dfs(nowD+1, maxD, x+y)
if y+1 <= 9:
dfs(nowD+1, maxD, x+y+1)
for d in range(1, 11):
for x in range(1, 10):
dfs(1, d, x) | import sys
sys.setrecursionlimit(10**9)
K = int(eval(input()))
lis = []
def dfs(nowD, maxD, x):
if nowD == maxD:
lis.append(x)
if len(lis) >= K:
print((lis[K-1]))
exit()
else:
y = x%10
x *= 10
if y-1 >= 0:
dfs(nowD+1, maxD, x+y-1)
dfs(nowD+1, maxD, x+y)
if y+1 <= 9:
dfs(nowD+1, maxD, x+y+1)
for d in range(1, 11):
for x in range(1, 10):
dfs(1, d, x) | p02720 |
import queue
n = int(eval(input()))
q = queue.Queue()
count=0
p=0
for i in range(1,10):
q.put(i)
while count!=n:
count+=1
a = q.get()
p = a
str_a = str(a)
if str_a[-1]=='0':
q.put(a*10)
q.put(a*10+1)
elif str_a[-1]=='9':
q.put(a*10+8)
q.put(a*10+9)
else:
q.put(a*10 + int(str_a[-1])-1)
q.put(a*10 + int(str_a[-1]))
q.put(a*10 + int(str_a[-1])+1)
print(p)
| import queue
k = int(eval(input()))
q = queue.Queue()
for i in range(1,10):
q.put(i)
count = 0
while count < k:
num = q.get()
num_1 = int((str(num))[-1])
if num_1 ==0:
q.put(num*10)
q.put(num*10+1)
elif num_1==9:
q.put(num*10+num_1-1)
q.put(num*10+num_1)
else:
q.put(num*10+num_1-1)
q.put(num*10+num_1)
q.put(num*10+num_1+1)
count+=1
if k==count:
ans = num
print(ans)
| p02720 |
#!/usr/bin/env python3
def main():
def rec(d: int, val: int, all: list):
all.append(val)
if d == 10:
return
for j in range(-1, 2):
add = (val % 10) + j
if add >= 0 and add <= 9:
rec(d + 1, val * 10 + add, all)
K = int(eval(input()))
all = []
for v in range(1, 10):
rec(1, v, all)
print((sorted(all)[K - 1]))
if __name__ == '__main__':
main()
| def main():
from queue import deque
K = int(eval(input()))
q = deque()
for i in range(1, 10):
q.append(i)
for i in range(K - 1):
s = q.popleft()
for j in range(-1, 2):
add = (s % 10) + j
if add >= 0 and add <= 9:
q.append(s * 10 + add)
print((q[0]))
main()
| p02720 |
from collections import deque
K = int(eval(input()))
if K<10:
print(K)
exit()
q = deque([1,2,3,4,5,6,7,8,9])
cnt = 9
while q:
n = q.popleft()
r = n % 10
n *= 10;
for i in range(10):
if abs(r - i) <= 1:
q.append(n + i)
cnt += 1
if cnt == K:
print((n+i))
exit() | from collections import deque
k = int(eval(input()))
if k <= 9:
print(k)
exit()
que = deque([1,2,3,4,5,6,7,8,9])
cnt = len(que)
while cnt < k:
x = que.popleft()
m = x%10
if m != 0:
que.append(10*x+m-1)
cnt+=1
if cnt == k: print((que.pop())); exit();
que.append(10*x+m)
cnt+=1
if cnt == k: print((que.pop())); exit();
if m != 9:
que.append(10*x+m+1)
cnt+=1
if cnt == k: print((que.pop())); exit(); | p02720 |
from collections import deque
K = int(eval(input()))
q = deque([[1],[2],[3],[4],[5],[6],[7],[8],[9]])
cnt = 0
while cnt != K:
nums = q.popleft()
last = nums[-1]
if last == 9:
tmp = nums.copy()
tmp.append(8)
q.append(tmp)
tmp = nums.copy()
tmp.append(9)
q.append(tmp)
elif last == 0:
tmp = nums.copy()
tmp.append(0)
q.append(tmp)
tmp = nums.copy()
tmp.append(1)
q.append(tmp)
else:
tmp = nums.copy()
tmp.append(last-1)
q.append(tmp)
tmp = nums.copy()
tmp.append(last)
q.append(tmp)
tmp = nums.copy()
tmp.append(last+1)
q.append(tmp)
cnt += 1
ans = 0
l = len(nums)
for i in range(l):
ans += nums[i]*10**(l-i-1)
print(ans) | K = int(eval(input()))
lunlun = [1,2,3,4,5,6,7,8,9]
p = 0
def lunlun_generator(now_lunlun):
last = now_lunlun%10
if last-1>=0:
yield 10*now_lunlun+last-1
yield 10*now_lunlun+last
if last+1<=9:
yield 10*now_lunlun+last+1
while 1:
for new_lunlun in lunlun_generator(lunlun[p]):
lunlun.append(new_lunlun)
p += 1
if p == K:
break
print((lunlun[p-1]))
| p02720 |
k=int(eval(input()))
ans=[i for i in range(1,10)]
def dfs(x):
if x>=3234566667:
return
for i in range(max(0,x%10-1),min(10,x%10+2)):
ans.append(10*x+i)
dfs(10*x+i)
for i in range(1,10):
dfs(i)
print((sorted(ans)[k-1])) | k=int(eval(input()))
a=[]
def dfs(v):
if v>3234566667:
return
a.append(v)
for i in range(max(0,v%10-1),min(v%10+2,10)):
dfs(10*v+i)
for i in range(1,10):
dfs(i)
a.sort()
print((a[k-1])) | p02720 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.