input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
sys.setrecursionlimit(10**7)
k = int(eval(input()))
data = [1,2,3,4,5,6,7,8,9]
def dfs(prenum,numberstr):
if int(numberstr) > 3234566667:return
if prenum - 1 >= 0:
data.append(int(numberstr+str(prenum-1)))
dfs(prenum-1,numberstr+str(prenum-1))
data.append(int(numberstr+str(prenum)))
dfs(prenum,numberstr+str(prenum))
if prenum +1 <= 9:
data.append(int(numberstr+str(prenum+1)))
dfs(prenum+1,numberstr+str(prenum+1))
for i in range(1,10):
dfs(i,str(i))
data.sort()
print((data[k-1]))
# print(data[:20])
# print(len(data)) | #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
sys.setrecursionlimit(10**7)
k = int(eval(input()))
ans = []
def dfs(string):
if int(string) > 3234566667: return
ans.append(int(string))
botom = string[-1]
intbotom = int(botom)
if 0 <= intbotom -1 :
dfs(string + str(intbotom-1))
dfs(string+botom)
if intbotom + 1 <= 9:
dfs(string + str(intbotom+1))
for i in range(1,10):
dfs(str(i))
ans .sort()
print((ans[k-1])) | p02720 |
K = int(eval(input()))
queue = []
for i in range(1, 10):
queue.append(i)
while K != 0:
if K <= len(queue):
print((queue[K-1]))
exit(0)
K -= 1
num = queue.pop(0)
if K == 0:
print(num)
exit(0)
o = int(str(num)[-1])
for n in [o-1, o, o+1]:
if n == -1 or n == 10: continue
queue.append( int(str(num)+str(n)) ) | from collections import deque
K = int(eval(input()))
queue = deque([i for i in range(1,10)])
while K != 0:
if K <= len(queue):
print((queue[K-1]))
exit(0)
K -= 1
num = queue.popleft()
o = int(str(num)[-1])
for n in [o-1, o, o+1]:
if n == -1 or n == 10: continue
queue.append( int(str(num)+str(n)) ) | p02720 |
#coding:utf-8
def up(nums):
if len(nums) == nums.count(9):
nums = [1] + [0] * len(nums)
return nums
for i in list(reversed(list(range(len(nums))))):
if nums[i] > nums[i-1] or nums[i] == 9:
continue
else:
nums[i] += 1
for j in range(i+1, len(nums)):
if j == len(nums) - 1:
nums[j] = max(nums[j-1]-1, 0)
else:
nums[j] = max(nums[j-1] - 1, 0)
return nums
def main():
k = int(eval(input()))
if k < 10:
print(k)
return
cnt = 11
nums = [1, 0]
while cnt <= k:
cnt += 1
nums = up(nums)
#print(nums)
print((''.join([str(num) for num in nums])))
if __name__ == '__main__':
main() | #coding:utf-8
def up(nums):
if len(nums) == nums.count(9):
nums = [1] + [0] * len(nums)
return nums
for i in list(reversed(list(range(len(nums))))):
if nums[i] > nums[i-1] or nums[i] == 9:
continue
else:
nums[i] += 1
for j in range(i+1, len(nums)):
nums[j] = max(nums[j-1]-1, 0)
return nums
def main():
k = int(eval(input()))
nums = [0]
for _ in range(k):
nums = up(nums)
print((''.join([str(num) for num in nums])))
if __name__ == '__main__':
main() | p02720 |
from sys import stdin
import heapq
def main():
input = stdin.readline
K = int(eval(input()))
h = []
for i in range(1,10):
heapq.heappush(h,i)
for i in range(K):
ans = heapq.heappop(h)
if ans % 10 != 0:
heapq.heappush(h,ans * 10 + (ans % 10 - 1))
heapq.heappush(h,ans*10 + (ans%10))
if ans % 10 != 9:
heapq.heappush(h,ans * 10 + (ans % 10 + 1))
print(ans)
if __name__ == "__main__":
main() | from sys import stdin
import heapq
def main():
input = stdin.readline
K = int(eval(input()))
h = []
for i in range(1,10):
h.append(i)
for i in range(K):
ans = h[i]
if ans % 10 != 0:
h.append(ans * 10 + (ans % 10 - 1))
h.append(ans*10 + (ans%10))
if ans % 10 != 9:
h.append(ans * 10 + (ans % 10 + 1))
print(ans)
# for i in range(1,10):
# heapq.heappush(h,i)
# for i in range(K):
# ans = heapq.heappop(h)
# if ans % 10 != 0:
# heapq.heappush(h,ans * 10 + (ans % 10 - 1))
# heapq.heappush(h,ans*10 + (ans%10))
# if ans % 10 != 9:
# heapq.heappush(h,ans * 10 + (ans % 10 + 1))
# print(ans)
if __name__ == "__main__":
main() | p02720 |
import heapq
K = int(eval(input()))
def fun(h, n):
tmp = str(n)
if tmp[-1] == '0':
heapq.heappush(h, int(tmp + '0'))
heapq.heappush(h, int(tmp + '1'))
elif tmp[-1] == '9':
heapq.heappush(h, int(tmp + '8'))
heapq.heappush(h, int(tmp + '9'))
else:
heapq.heappush(h, int(tmp + str(int(tmp[-1]) - 1)))
heapq.heappush(h, int(tmp + tmp[-1]))
heapq.heappush(h, int(tmp + str(int(tmp[-1]) + 1)))
h = list(range(1, 10))
while K > 0:
tmp = heapq.heappop(h)
fun(h, tmp)
K -= 1
else:
print(tmp) | import heapq
K = int(eval(input()))
def fun(h, n):
tmp = n % 10
if tmp != 0:
heapq.heappush(h, 10 * n + tmp - 1)
heapq.heappush(h, 10 * n + tmp)
if tmp != 9:
heapq.heappush(h, 10 * n + tmp + 1)
h = list(range(1, 10))
while K > 0:
n = heapq.heappop(h)
fun(h, n)
K -= 1
else:
print(n) | p02720 |
a={0}
_,*s=list(range(10))
while s:
v=s.pop()
a|={v}
for w in range(max(0,v%10-1),min(10,v%10+2)):
w+=v*10
if w<4e9:s+=w,
print((sorted(a)[int(eval(input()))])) | _,*s=list(range(10))
for v in s:s+=[w+v*10for w in range(max(0,v%10-1),min(10,v%10+2))]*(v<4e8)
print((s[int(eval(input()))-1])) | p02720 |
import sys
sys.setrecursionlimit(10**7)
L = []
def lunlun(x, cnt, c):
if cnt == 10:
L.append(int(x))
return
e = int(x[-1])
if c:
for i in range(max(e-1, 0), min(e+2, 10)):
lunlun(x+str(i), cnt+1, 1)
else:
lunlun(x+"0", cnt+1, 0)
for i in range(1, 10):
lunlun(x+str(i), cnt+1, 1)
lunlun("0", 1, 0)
for i in range(1, 10):
lunlun(str(i), 1, 1)
k = int(eval(input()))
ans = L[k]
print(ans) | from collections import deque
que = deque()
L = []
k = int(eval(input()))
for i in range(1, 10):
L.append(str(i))
que.append(str(i))
while len(L) < k:
top = que.popleft()
e = int(top[-1])
for i in range(max(e-1, 0), min(e+2, 10)):
x = top + str(i)
L.append(x)
que.append(x)
ans = L[k-1]
print(ans) | p02720 |
from collections import deque
def main():
q=deque()
for i in range(1,10):
q.append((str(i)))
Ans=[]
while q:
s=q.popleft()
if int(s)>3234566667:
continue
Ans.append(int(s))
d=int(s[-1])
if d==0:
q.append(s+'0')
q.append(s+'1')
elif d==9:
q.append(s+'8')
q.append(s+'9')
else:
V=[d-1,d,d+1]
for v in V:
q.append(s+str(v))
Ans.sort()
#print(len(Ans))
k=int(eval(input()))
print((Ans[k-1]))
if __name__=='__main__':
main() | from collections import deque
def main():
k=int(eval(input()))
if k<=9:
return k
q=deque()
for i in range(1,10):
q.append(i)
Ans=list(range(1,10))
cnt=9
while cnt<k:
s=q.popleft()
d=s%10
s*=10
if d==0:
q.append(s)
q.append(s+1)
Ans.append(s)
Ans.append(s+1)
cnt+=2
elif d==9:
q.append(s+8)
q.append(s+9)
Ans.append(s+8)
Ans.append(s+9)
cnt+=2
else:
V=[d-1,d,d+1]
for v in V:
q.append(s+v)
Ans.append(s+v)
cnt+=3
return Ans[k-1]
if __name__=='__main__':
print((main())) | p02720 |
from heapq import heapify, heappop, heappush
# 次の桁の生成ルール ex. 1 -> 10, 11, 12
def next_int(n):
nums = {0: [0, 1],
1: [0, 1, 2],
2: [1, 2, 3],
3: [2, 3, 4],
4: [3, 4, 5],
5: [4, 5, 6],
6: [5, 6, 7],
7: [6, 7, 8],
8: [7, 8, 9],
9: [8, 9]}
return nums[n]
K = int(eval(input()))
queue = [1, 2, 3, 4, 5, 6, 7, 8, 9] # とりあえず 1 桁目を初期値にとる
heapify(queue)
for _ in range(K-1):
now = heappop(queue) # 最小値を取り出す
# 取り出した値を使って次の桁を生成し queue に投げる
for next_i in next_int(int(str(now)[-1])):
heappush(queue, int(str(now)+str(next_i)))
print((heappop(queue))) # K 回目に取り出す最小値
| from heapq import heapify, heappop, heappush
# 次の桁の生成ルール ex. 1 -> 10, 11, 12
def next_int(n):
nums = {0: [0, 1],
1: [0, 1, 2],
2: [1, 2, 3],
3: [2, 3, 4],
4: [3, 4, 5],
5: [4, 5, 6],
6: [5, 6, 7],
7: [6, 7, 8],
8: [7, 8, 9],
9: [8, 9]}
return nums[n]
K = int(eval(input()))
queue = [1, 2, 3, 4, 5, 6, 7, 8, 9] # とりあえず 1 桁目を初期値にとる
heapify(queue)
for _ in range(K-1):
now = heappop(queue) # 最小値を取り出す
# 取り出した値を使って次の桁を生成し queue に投げる
for next_i in next_int(now%10):
heappush(queue, now*10 + next_i)
print((heappop(queue))) # K 回目に取り出す最小値
| p02720 |
from heapq import heapify, heappop, heappush
# 次の桁の生成ルール ex. 1 -> 10, 11, 12
def next_int(n):
nums = {0: [0, 1],
1: [0, 1, 2],
2: [1, 2, 3],
3: [2, 3, 4],
4: [3, 4, 5],
5: [4, 5, 6],
6: [5, 6, 7],
7: [6, 7, 8],
8: [7, 8, 9],
9: [8, 9]}
return nums[n]
K = int(eval(input()))
queue = [1, 2, 3, 4, 5, 6, 7, 8, 9] # とりあえず 1 桁目を初期値にとる
heapify(queue)
for _ in range(K-1):
now = heappop(queue) # 最小値を取り出す
# 取り出した値を使って次の桁を生成し queue に投げる
for next_i in next_int(now%10):
heappush(queue, now*10 + next_i)
print((heappop(queue))) # K 回目に取り出す最小値
| from heapq import heapify, heappop, heappush
# 次の桁の生成ルール ex. 1 -> 10, 11, 12
def next_int(n):
nums = {0: [0, 1],
1: [0, 1, 2],
2: [1, 2, 3],
3: [2, 3, 4],
4: [3, 4, 5],
5: [4, 5, 6],
6: [5, 6, 7],
7: [6, 7, 8],
8: [7, 8, 9],
9: [8, 9]}
return nums[n]
K = int(eval(input()))
queue = [1, 2, 3, 4, 5, 6, 7, 8, 9] # とりあえず 1 桁目を初期値にとる
heapify(queue)
for _ in range(K-1):
now = heappop(queue) # 最小値を取り出す
# 取り出した値を使って次の桁を生成し queue に投げる
for next_i in next_int(now%10):
heappush(queue, now*10 + next_i)
print((queue[0])) # K 回目に取り出す最小値
| p02720 |
from heapq import heapify, heappop, heappush
# 次の桁の生成ルール ex. 1 -> 10, 11, 12
def next_int(n):
nums = {0: [0, 1],
1: [0, 1, 2],
2: [1, 2, 3],
3: [2, 3, 4],
4: [3, 4, 5],
5: [4, 5, 6],
6: [5, 6, 7],
7: [6, 7, 8],
8: [7, 8, 9],
9: [8, 9]}
return nums[n]
K = int(eval(input()))
queue = [1, 2, 3, 4, 5, 6, 7, 8, 9] # とりあえず 1 桁目を初期値にとる
heapify(queue)
for _ in range(K-1):
now = heappop(queue) # 最小値を取り出す
# 取り出した値を使って次の桁を生成し queue に投げる
for next_i in next_int(now%10):
heappush(queue, now*10 + next_i)
print((queue[0])) # K 回目に取り出す最小値
| from heapq import heapify, heappop, heappush
# 次の桁の生成ルール ex. 1 -> 10, 11, 12
def next_int(n):
if n == 0:
return [0, 1]
elif n == 9:
return [8, 9]
else:
return [n-1, n, n+1]
K = int(eval(input()))
queue = [1, 2, 3, 4, 5, 6, 7, 8, 9] # とりあえず 1 桁目を初期値にとる
heapify(queue)
for _ in range(K-1):
now = heappop(queue) # 最小値を取り出す
# 取り出した値を使って次の桁を生成し queue に投げる
for next_i in next_int(now%10):
heappush(queue, now*10 + next_i)
print((queue[0])) # K 回目に取り出す最小値
| p02720 |
from heapq import heapify, heappush, heappop
def next_num(n):
if n == 0:
return [0, 1]
elif n == 9:
return [8, 9]
else:
return [n-1, n, n+1]
K = int(eval(input()))
lunlun = [1, 2, 3, 4, 5, 6, 7, 8, 9]
heapify(lunlun)
for _ in range(K-1):
now = heappop(lunlun)
for i in next_num(int(str(now)[-1])):
heappush(lunlun, now*10+i)
print((lunlun[0]))
| from heapq import heapify, heappush, heappop
K = int(eval(input()))
ll = [1, 2, 3, 4, 5, 6, 7, 8, 9]
heapify(ll)
def next_num(X):
n = int(str(X)[-1])
if n == 0:
return (0, 1)
elif n == 9:
return (8, 9)
else:
return (n-1, n, n+1)
for _ in range(K-1):
lli = heappop(ll)
next_nums = next_num(lli)
for ni in next_nums:
heappush(ll, lli*10+ni)
ans = ll[0]
print(ans)
| p02720 |
k = int(eval(input()))
lun_list = [1,2,3,4,5,6,7,8,9]
for i in lun_list:
if str(i)[-1] == '0':
for j in range(2):
lun_list.append(int(str(i)+str(j)))
elif str(i)[-1] == '9':
for j in range(8,10):
lun_list.append(int(str(i)+str(j)))
else:
for j in range(int(str(i)[-1])-1,int(str(i)[-1])+2):
lun_list.append(int(str(i)+str(j)))
if len(lun_list) > k:
break
print((lun_list[k-1])) | k = int(eval(input()))
num_list = [1,2,3,4,5,6,7,8,9]
num_a = ['0', '1']
num_b = ['8', '9']
for i in num_list:
if str(i)[-1] == '0':
for j in num_a:
num_list.append(int(str(i)+j))
elif str(i)[-1] == '9':
for j in num_b:
num_list.append(int(str(i)+j))
else:
num = int(str(i)[-1])
for j in range(num-1, num+2):
num_list.append(int(str(i)+str(j)))
if len(num_list) > k:
break
print((num_list[k-1])) | p02720 |
#python3
from collections import deque
def main():
k = int(eval(input()))
cand = []
for i in range(1, 10):
cand.append(i)
cnt = 0
dq = deque()
for i in range(1, 10):
dq.append(i)
while len(dq):
v = dq.popleft()
x = v%10
cnt += 1
if x == 0:
for j in (0, 1):
nx = v*10 + j
cand.append(nx)
dq.append(nx)
elif x == 9:
for j in (-1, 0):
nx = v*10 + 9 + j
cand.append(nx)
dq.append(nx)
else:
for j in (-1, 0, 1):
nx = v*10 + x + j
cand.append(nx)
dq.append(nx)
if len(cand) > 2*k:
break
cand.sort()
print((cand[k-1]))
main() | #python3
from collections import deque
def main():
k = int(eval(input()))
cand = []
for i in range(1, 10):
cand.append(i)
cnt = 0
dq = deque()
for i in range(1, 10):
dq.append(i)
while len(dq):
v = dq.popleft()
x = v%10
cnt += 1
if x == 0:
for j in (0, 1):
nx = v*10 + j
cand.append(nx)
dq.append(nx)
elif x == 9:
for j in (-1, 0):
nx = v*10 + 9 + j
cand.append(nx)
dq.append(nx)
else:
for j in (-1, 0, 1):
nx = v*10 + x + j
cand.append(nx)
dq.append(nx)
if len(cand) > 2*k:
break
print((cand[k-1]))
main() | p02720 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
cnt = 0
def main():
K = int(readline())
cnd = [i for i in range(1, 10)]
dq = deque()
for i in range(1, 10):
dq.append(i)
cnt = 0
while len(dq)>0:
cnt += 1
x = dq.popleft()
v = x%10
if v==0:
for i in (0, 1):
nx = 10*x+i
cnd.append(nx)
dq.append(nx)
elif v == 9:
for i in (-1, 0):
nx = 10*x+9+i
cnd.append(nx)
dq.append(nx)
else:
for i in (-1, 0, 1):
nx = 10*x+v+i
cnd.append(nx)
dq.append(nx)
if cnt == K:
break
cnd.sort()
print((cnd[K-1]))
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
K = int(readline())
dq = []
for i in range(1, 10):
dq.append(i)
for i in range(K):
v = dq[i]
r = v%10
if r == 9:
dq.append(v*10+8)
dq.append(v*10+9)
elif r == 0:
dq.append(v*10)
dq.append(v*10+1)
else:
dq.append(v*10+(r-1))
dq.append(v*10+r)
dq.append(v*10+(r+1))
print((dq[K-1]))
if __name__ == '__main__':
main()
| p02720 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
K = int(readline())
dq = []
for i in range(1, 10):
dq.append(i)
for i in range(K):
v = dq[i]
r = v%10
if r == 9:
dq.append(v*10+8)
dq.append(v*10+9)
elif r == 0:
dq.append(v*10)
dq.append(v*10+1)
else:
dq.append(v*10+(r-1))
dq.append(v*10+r)
dq.append(v*10+(r+1))
print((dq[K-1]))
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
def main():
K = int(readline())
dq = deque()
cnd = []
for i in range(1, 10):
dq.append(i)
cnd.append(i)
while len(dq)>0:
v = dq.popleft()
r = v%10
if r == 0:
nx = v*10
dq.append(nx)
cnd.append(nx)
nx = v*10+1
dq.append(nx)
cnd.append(nx)
elif r == 9:
nx = v*10+8
dq.append(nx)
cnd.append(nx)
nx = v*10+9
dq.append(nx)
cnd.append(nx)
else:
nx = v*10+(r-1)
dq.append(nx)
cnd.append(nx)
nx = v*10+r
dq.append(nx)
cnd.append(nx)
nx = v*10+(r+1)
dq.append(nx)
cnd.append(nx)
if len(cnd) > K:
break
print((cnd[K-1]))
if __name__ == '__main__':
main() | p02720 |
from itertools import product
k = int(eval(input()))
ls = []
ls = [i for i in range(1, 10)]
digit = 1
while len(ls) < k:
for i in range(1, 10):
for j in product([-1, 0, 1], repeat=digit):
num = str(i)
skip = 0
for y in j:
x = int(num[-1])+y
if x < 0 or 9 < x:
skip = 1
break
num += str(x)
if skip:
continue
ls.append(int(num))
digit += 1
print((ls[k-1])) | k = int(eval(input()))
ans = [i for i in range(1, 10)]
def generate_lunlun(x):
y = x % 10
if 0 <= y-1:
yield 10*x + y-1
yield 10*x + y
if y+1 < 10:
yield 10*x + y+1
idx = 0
while len(ans) < k:
x = ans[idx]
for i in generate_lunlun(x):
ans.append(i)
idx += 1
print((ans[k-1])) | p02720 |
k = int(eval(input()))
ans = []
def dfs(x):
if x > 10**10:
return 0
else:
ans.append(x)
y = x % 10
for i in range(10):
if abs(y-i) <= 1:
dfs(10*x+i)
for i in range(1, 10):
dfs(i)
ans.sort()
print((ans[k-1])) | k = int(eval(input()))
ans = []
def dfs(x):
if x > 3234566667:
return 0
else:
ans.append(x)
y = x % 10
for i in range(10):
if abs(y-i) <= 1:
dfs(10*x+i)
for i in range(1, 10):
dfs(i)
ans.sort()
print((ans[k-1])) | p02720 |
k = int(eval(input()))
li = [str(i) for i in range(1, 10)]
n = 0
while n < 9:
rep = li[:]
for r in rep:
if r[-1] == "0":
li.append(r+"0")
li.append(r+"1")
elif r[-1] == "9":
li.append(r+"8")
li.append(r+"9")
else:
x = int(r[-1])
li.append(r+str(x-1))
li.append(r+str(x))
li.append(r+str(x+1))
n += 1
setli = set(li)
li = list(setli)
#print(li)
intli = [int(i) for i in li]
intli.sort()
#print(intli)
#intli.sort
#print(len(intli))
#print(intli)
print((intli[k-1]))
| from collections import deque
k = int(eval(input()))
def dfs(k):
cnt = 0
stack = deque()
for i in range(1, 10):
stack.append(i)
while cnt <= k:
q = stack.popleft()
ans.append(q)
cnt += 1
l = q % 10
for x in range(max(0, l - 1), min(10, l + 2)):
stack.append(q * 10 + x)
ans = []
dfs(k)
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(1,k):
l = q.get()
m = l % 10
if (m != 0):
q.put(l * 10 + m - 1)
q.put(l * 10 + m)
if (m != 9):
q.put(l * 10 + m + 1)
print((q.get())) | from collections import deque
k = int(eval(input()))
q = deque([1,2,3,4,5,6,7,8,9])
for i in range(1,k):
l = q.popleft()
if (len(q) < k):
m = l % 10
if (m != 0):
q.append(l * 10 + m - 1)
q.append(l * 10 + m)
if (m != 9):
q.append(l * 10 + m + 1)
print((q.popleft())) | p02720 |
N = int(eval(input()))
tmp = [i for i in range(1, 10)]
ans = list(tmp)
for i in range(10):
tmp2 = []
for x in tmp:
k = int(str(x)[-1])
if k != 0:
ans.append(10*x-1 + k)
tmp2.append(10*x-1 + k)
if k != 9:
tmp2.append(10*x+1 + k)
ans.append(10*x+1 + k)
tmp2.append(10*x + k)
ans.append(10*x + k)
tmp = list(tmp2)
ans.sort()
print((ans[N-1]))
| import collections
K = int(eval(input()))
q = collections.deque([i for i in range(1, 10)])
count = 0
while(q):
count += 1
x = q.popleft()
if count == K:
print(x)
break
if x % 10 != 0:
q.append(x*10 + (x % 10 - 1))
q.append(x*10 + (x % 10))
if x % 10 != 9:
q.append(x*10 + (x % 10 + 1))
| p02720 |
K = int(eval(input()))
d = [1,2,3,4,5,6,7,8,9]
if K <= 9:
print(K)
exit()
cnt = 9
while cnt < K:
_ = d.pop(0)
matsubi = _%10
if matsubi == 0:
d.append(_*10+matsubi)
cnt += 1
if cnt == K:
print((d[-1]))
exit()
d.append(_*10+matsubi+1)
cnt += 1
if cnt == K:
print((d[-1]))
exit()
elif matsubi == 9:
d.append(_*10+matsubi-1)
cnt += 1
if cnt == K:
print((d[-1]))
exit()
d.append(_*10+matsubi)
cnt += 1
if cnt == K:
print((d[-1]))
exit()
else:
d.append(_*10+matsubi-1)
cnt += 1
if cnt == K:
print((d[-1]))
exit()
d.append(_*10+matsubi)
cnt += 1
if cnt == K:
print((d[-1]))
exit()
d.append(_*10+matsubi+1)
cnt += 1
if cnt == K:
print((d[-1]))
exit() | K = int(eval(input()))
d = [1,2,3,4,5,6,7,8,9]
if K <= 9:
print(K)
exit()
cnt = 9
while cnt < K:
_ = d.pop(0)
matsubi = _%10
if matsubi == 0:
d.append(_*10+matsubi)
d.append(_*10+matsubi+1)
cnt += 2
elif matsubi == 9:
d.append(_*10+matsubi-1)
d.append(_*10+matsubi)
cnt += 2
else:
d.append(_*10+matsubi-1)
d.append(_*10+matsubi)
d.append(_*10+matsubi+1)
cnt += 3
ans = -1*(cnt - K + 1)
print((d[ans])) | p02720 |
k = int(eval(input()))
nums = []
def inc(num):
if num > 3234566667:
return None
if num <= 3234566667:
nums.append(num)
num_str = str(num)
end = num_str[-1:]
end_num = int(end)
if end_num < 9:
inc(int(num_str + str(end_num + 1)))
inc(int(num_str + end))
if end_num > 0:
inc(int(num_str + str(end_num - 1)))
for i in range(1, 10):
inc(i)
sort_nums = sorted(nums)
print((sorted(nums)[k - 1])) | k = int(eval(input()))
nums = []
def inc(num):
if num > 3234566667:
return None
if num <= 3234566667:
nums.append(num)
end = str(num)[-1:]
end_num = int(end)
if end_num < 9:
inc(num * 10 + end_num + 1)
inc(num * 10 + end_num)
if end_num > 0:
inc(num * 10 + end_num - 1)
for i in range(1, 10):
inc(i)
sort_nums = sorted(nums)
print((sorted(nums)[k - 1])) | p02720 |
z = int(eval(input()))
l = []
for i in range(1,10):
l.append(i)
for j in range(max(0,i-1),min(10,i+2)):
l.append(int(str(i)+str(j)))
for k in range(max(j-1,0),min(10,j+2)):
l.append(int(str(i)+str(j)+str(k)))
for m in range(max(k-1,0),min(10,k+2)):
l.append(int(str(i)+str(j)+str(k)+str(m)))
for n in range(max(m-1,0),min(10,m+2)):
l.append(int(str(i)+str(j)+str(k)+str(m)+str(n)))
for o in range(max(n-1,0),min(10,n+2)):
l.append(int(str(i)+str(j)+str(k)+str(m)+str(n)+str(o)))
for p in range(max(o-1,0),min(10,o+2)):
l.append(int(str(i)+str(j)+str(k)+str(m)+str(n)+str(o)+str(p)))
for q in range(max(p-1,0),min(10,p+2)):
l.append(int(str(i)+str(j)+str(k)+str(m)+str(n)+str(o)+str(p)+str(q)))
for r in range(max(q-1,0),min(10,q+2)):
l.append(int(str(i)+str(j)+str(k)+str(m)+str(n)+str(o)+str(p)+str(q)+str(r)))
for s in range(max(r-1,0),min(10,r+2)):
l.append(int(str(i)+str(j)+str(k)+str(m)+str(n)+str(o)+str(p)+str(q)+str(r)+str(s)))
l.sort()
print((l[z-1])) | from collections import deque
k = int(eval(input()))
s = deque([1,2,3,4,5,6,7,8,9])
for i in range(k):
c = s.popleft()
d = int(str(c)[-1])
for j in range(max(0,d-1),min(10,d+2)):
s.append(int(str(c)+str(j)))
print(c) | p02720 |
"""
import random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)
# import numpy as np
inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
nx = j + dx; ny = i + dy
if 0 <= nx < w and 0 <= ny < h:'''
"""
from collections import defaultdict
import sys
sys.setrecursionlimit(10 ** 7)
def wi(): return list(map(int, sys.stdin.readline().split()))
# WideIntPoint
def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def ws(): return sys.stdin.readline().split()
def si(): return int(sys.stdin.readline()) # SingleInt
def ss(): return eval(input())
def hi(n): return [si() for _ in range(n)]
def hs(n): return [ss() for _ in range(n)] # HeightString
def s_list(): return list(eval(input()))
def mi(n): return [wi() for _ in range(n)] # MatrixInt
def mip(n): return [wip() for _ in range(n)]
def ms(n): return [ws() for _ in range(n)]
def num_grid(n): return [[int(i) for i in sys.stdin.readline().split()[
0]] for _ in range(n)] # NumberGrid
def grid(n): return [s_list() for _ in range(n)]
def gcd(a, b):
while b:
a, b = b, a % b
return a
def round_up(a, b):
""" a/b の切り上げ """
c = (a + b - 1) / b
return c
def lcm(a, b):
"""a,bの最小公倍数"""
return a * b // gcd(a, b)
def floor(a, b):
"""floor(a/b) 整数値を返す"""
c = (a - a % b)/b
return int(c)
def main():
def dfs(x):
lunlun.append(x)
d = x % 10
if len(str(x)) == 11:
return
for v in [d+1, d, d-1]:
if 0 <= v <= 9:
dfs(x*10+v)
K = int(eval(input()))
cnt = 0
lunlun = []
for i in range(1, 10):
dfs(i)
lunlun.sort()
print((lunlun[K-1]))
if __name__ == '__main__':
main()
| """
import random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)
# import numpy as np
inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
nx = j + dx; ny = i + dy
if 0 <= nx < w and 0 <= ny < h:'''
"""
from collections import deque
import sys
sys.setrecursionlimit(10 ** 7)
def wi(): return list(map(int, sys.stdin.readline().split()))
# WideIntPoint
def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def ws(): return sys.stdin.readline().split()
def si(): return int(sys.stdin.readline()) # SingleInt
def ss(): return eval(input())
def hi(n): return [si() for _ in range(n)]
def hs(n): return [ss() for _ in range(n)] # HeightString
def s_list(): return list(eval(input()))
def mi(n): return [wi() for _ in range(n)] # MatrixInt
def mip(n): return [wip() for _ in range(n)]
def ms(n): return [ws() for _ in range(n)]
def num_grid(n): return [[int(i) for i in sys.stdin.readline().split()[
0]] for _ in range(n)] # NumberGrid
def grid(n): return [s_list() for _ in range(n)]
def gcd(a, b):
while b:
a, b = b, a % b
return a
def round_up(a, b):
""" a/b の切り上げ """
c = (a + b - 1) / b
return c
def lcm(a, b):
"""a,bの最小公倍数"""
return a * b // gcd(a, b)
def floor(a, b):
"""floor(a/b) 整数値を返す"""
c = (a - a % b)/b
return int(c)
def main():
K = int(eval(input()))
q = deque()
for i in range(1, 10):
q.append(i)
cnt = 9
if cnt >= K:
print((q[K-1]))
sys.exit()
while cnt < K:
x = q.popleft()
d = x % 10
for v in [d-1, d, d+1]:
if 0 <= v <= 9:
y = x*10 + v
q.append(y)
cnt += 1
if cnt == K:
break
print(y)
if __name__ == '__main__':
main()
| p02720 |
from collections import deque
k = int(eval(input()))
Q = deque(list(range(1, 10)))
for _ in range(k):
x = Q.popleft()
y = x % 10
z = 10*x + y
if y != 0:
Q += [z-1]
Q += [z]
if y != 9:
Q += [z+1]
print(x) | from collections import deque
k = int(eval(input()))
Q = deque(list(range(1, 10))) #るんるん数を格納するキュー
# Q: 1 2 3 4 5 6 7 8 9
for i in range(k):
x = Q.popleft()
#x = 1 <-- Q: 2 3 4 5 6 7 8 9
last_digit = x % 10 # 1 一番目の桁の値
if last_digit == 0:
Q.append(10*x + 0)
Q.append(10*x + 1)
elif last_digit == 9:
Q.append(10*x + 8)
Q.append(10*x + 9)
else: # 1<=last_digit <=8
Q.append(10*x + last_digit - 1)
Q.append(10*x + last_digit)
Q.append(10*x + last_digit + 1)
print(x) | p02720 |
from collections import deque
k = int(eval(input()))
Q = deque(list(range(1, 10))) #るんるん数を格納するキュー
# Q: 1 2 3 4 5 6 7 8 9
for i in range(k):
x = Q.popleft()
#x = 1 <-- Q: 2 3 4 5 6 7 8 9
last_digit = x % 10 # 1 一番目の桁の値
if last_digit == 0:
Q.append(10*x + 0)
Q.append(10*x + 1)
elif last_digit == 9:
Q.append(10*x + 8)
Q.append(10*x + 9)
else: # 1<=last_digit <=8
Q.append(10*x + last_digit - 1)
Q.append(10*x + last_digit)
Q.append(10*x + last_digit + 1)
print(x) | from collections import deque
k = int(eval(input()))
Q = deque(list(range(1, 10))) #るんるん数を格納するキュー
# Q: 1 2 3 4 5 6 7 8 9
for i in range(k):
x = Q.popleft()
#x = 1 <-- Q: 2 3 4 5 6 7 8 9
last_digit = x % 10 # 1 一番目の桁の値
z = 10*x + last_digit #11
if last_digit != 0:
Q.append(z-1)
# Q: 2 3 4 5 6 7 8 9 <--10
Q.append(z)
# Q: 2 3 4 5 6 7 8 9 10 <--11
if last_digit != 9:
Q.append(z+1)
# Q: 2 3 4 5 6 7 8 9 10 11 <--12
print(x) | p02720 |
# 解説放送
k = int(eval(input()))
a = [i+1 for i in range(9)]
while 1:
if k <= len(a):
print((a[k-1]))
exit()
k -= len(a)
old = []
a, old = old, a
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) | # 解説PDF
from collections import deque
k = int(eval(input()))
que = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
for i in range(k-1):
x = que.popleft()
y = x % 10
if y != 0:
que.append(10*x+y-1)
que.append(10*x+y)
if y != 9:
que.append(10*x+y+1)
ans = que.popleft()
print(ans) | p02720 |
from collections import deque
k = int(eval(input()))
cnt = 0
q = deque()
for i in range(1, 10):
q.append((str(i), i))
cnt += 1
if cnt == k:
print((str(i)))
exit()
while q:
lun, num = q.popleft()
for i in range(num - 1, num + 2):
if i < 0 or i >9:continue
temp = lun + str(i)
q.append((temp, i))
cnt += 1
if cnt == k:
print(temp)
exit() | from collections import deque
def bfs(k):
lunlun = []
q = deque()
count = 0
for i in range(1, 10):
lunlun.append(i)
q.append(i)
count += 1
if count >= k:return lunlun[k - 1]
while True:
num = q.popleft()
tail = num % 10
for i in [-1, 0, 1]:
temp = tail + i
if temp == -1 or temp == 10:continue
q.append(num * 10 + temp)
lunlun.append(num * 10 + temp)
count += 1
if k == count:return lunlun[k - 1]
k = int(eval(input()))
print((bfs(k)))
| p02720 |
from collections import deque
k = int(eval(input()))
d = deque([1,2,3,4,5,6,7,8,9])
ans = []
while len(ans) < k:
a = d.popleft()
ans.append(a)
l = [a%10-1, a%10, a%10+1]
for i in l:
if i==-1 or i==10:
continue
d.append(a*10 + i)
print((ans[k-1])) | from collections import deque
k = int(eval(input()))
d = deque([1,2,3,4,5,6,7,8,9])
for i in range(k):
a = d.popleft()
l = [a%10-1, a%10, a%10+1]
for j in l:
if j==-1 or j==10:
continue
d.append(a*10 + j)
print(a) | p02720 |
def gen_lunlun(digit, li):
if len(li) == digit:
lunluns.append(''.join(map(str, li)))
return
min_num = max(0, li[-1] - 1)
max_num = min(9, li[-1] + 1)
for i in range(min_num, max_num + 1):
gen_lunlun(digit, li + [i])
k = int(eval(input()))
lunluns = []
for d in range(1, 11):
for i in range(1, 10):
gen_lunlun(d, [i])
print((lunluns[k - 1]))
| from collections import deque
def nth_ll(k):
if k < 10:
return k
queue = deque([i for i in range(1, 10)])
cnt = 9
while True:
n = queue.popleft()
for i in range(-1 if n % 10 != 0 else 0, 2 if n % 10 != 9 else 1):
queue.append(10 * n + n % 10 + i)
cnt += 1
if cnt == k:
return queue.pop()
print((nth_ll(int(eval(input())))))
| p02720 |
import sys
sys.setrecursionlimit(10 ** 5)
def dfs(v):
ans.append(v)
if v > 1_000_000_000:
return
for d in range(10):
if abs(d - v % 10) <= 1:
nv = v * 10 + d
dfs(nv)
K = int(eval(input()))
ans = []
[dfs(i) for i in range(1, 10)]
print((sorted(ans)[K - 1]))
| import sys
sys.setrecursionlimit(10 ** 5)
def dfs(v):
if v > 3234566667:
return
ans.append(v)
d = v % 10
if d - 1 >= 0:
dfs(v * 10 + d - 1)
dfs(v * 10 + d)
if d + 1 < 10:
dfs(v * 10 + d + 1)
K = int(eval(input()))
ans = []
[dfs(i) for i in range(1, 10)]
print((sorted(ans)[K - 1]))
| p02720 |
import sys
sys.setrecursionlimit(10 ** 5)
def dfs(v):
if v > 3234566667:
return
ans.append(v)
d = v % 10
if d - 1 >= 0:
dfs(v * 10 + d - 1)
dfs(v * 10 + d)
if d + 1 < 10:
dfs(v * 10 + d + 1)
K = int(eval(input()))
ans = []
[dfs(i) for i in range(1, 10)]
print((sorted(ans)[K - 1]))
| def is_good(mid, key):
S = list(map(int, str(mid)))
N = len(S)
dp = [[[0] * 11 for _ in range(2)] for _ in range(N + 1)]
dp[1][1][10] = 1
for k in range(1, S[0]):
dp[1][1][k] = 1
dp[1][0][S[0]] = 1
for i in range(1, N):
for k in range(1, 11):
dp[i + 1][1][k] += dp[i][0][10] + dp[i][1][10]
for is_less in range(2):
for k in range(10):
for l in range(k - 1, k + 2):
if not 0 <= l <= 9 or (not is_less and l > S[i]):
continue
dp[i + 1][is_less or l < S[i]][l] += dp[i][is_less][k]
return sum(dp[N][0][k] + dp[N][1][k] for k in range(10)) >= key
def binary_search(bad, good, key):
while good - bad > 1:
mid = (bad + good) // 2
if is_good(mid, key):
good = mid
else:
bad = mid
return good
K = int(eval(input()))
print((binary_search(0, 3234566667, K)))
| p02720 |
def is_lunlun(n):
m = str(n)
for i in range(1,len(m)):
if abs(int(m[i]) - int(m[i-1])) > 1:
return False
return True
def main():
K = int(eval(input()))
A = [format(str(i),"0>5") for i in range(100000) if is_lunlun(i)]
B = [int(a1+a2) for a1 in A for a2 in A if int(a1+a2) < 3234566668 and is_lunlun(int(a1+a2))]
B2 = sorted(set(B))
print((B2[K]))
if __name__ == "__main__":
main() | def main():
K = int(eval(input()))
from collections import deque
A = deque([1,2,3,4,5,6,7,8,9])
a = 0
while True:
x = A.popleft()
xmod10 = x % 10
if xmod10 != 0:
A.append(10*x + xmod10 - 1)
A.append(10*x + xmod10)
if xmod10 != 9:
A.append(10*x + xmod10 + 1)
a += 1
if a == K:
print(x)
break
if __name__ == "__main__":
main() | p02720 |
import sys
from collections import deque
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, d=DVSR): return pow(x, d - 2, d)
def DIV(x, y, d=DVSR): return (x * INV(y, d)) % d
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(eval(input()))
deq=deque(["1", "2", "3", "4", "5", "6", "7", "8", "9"])
K=II()
for i in range(K-1):
v = deq.popleft()
last = int(v[-1])
if last == 0:
deq.append(v + "0")
deq.append(v + "1")
elif last == 9:
deq.append(v + "8")
deq.append(v + "9")
else:
deq.append("{}{}".format(v, last-1))
deq.append("{}{}".format(v, last))
deq.append("{}{}".format(v, last+1))
print((deq.popleft()))
| import sys
from collections import deque
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, d=DVSR): return pow(x, d - 2, d)
def DIV(x, y, d=DVSR): return (x * INV(y, d)) % d
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(eval(input()))
deq=deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
K=II()
for i in range(K-1):
v = deq.popleft()
last = v % 10
if last == 0:
deq.append(10*v)
deq.append(10*v + 1)
elif last == 9:
deq.append(10*v + 8)
deq.append(10*v + 9)
else:
deq.append(10*v + last-1)
deq.append(10*v + last)
deq.append(10*v + last+1)
print((deq.popleft()))
| p02720 |
n=int(eval(input()))
import queue
q=queue.Queue()
for i in range(1,10):
q.put(i)
while n!=1:
x=q.get();k=x%10
for j in [10*x+i for i in range(max(0,k-1),min(10,k+2))] :
q.put(j)
n-=1
print((q.get())) | n=int(eval(input()))
import queue
q=queue.Queue()
for i in range(1,10):
q.put(i)
while n!=1:
x=q.get();k=x%10
for i in range(max(0,k-1),min(10,k+2)) :
q.put(10*x+i)
n-=1
print((q.get())) | p02720 |
K = int(eval(input()))
numbers = set([])
q = set(list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])))
# print(f'{q=}')
while len(numbers) <= 100000: # 10**8:
# print('test')
qq = set([])
for i in q:
# print(f'{i=}')
if len(i) == 1:
if i == '0':
n = i + '0'
qq.add(n)
n = i + '1'
qq.add(n)
elif i == '9':
n = i + '9'
qq.add(n)
n = i + '8'
qq.add(n)
else:
v = int(i)
n = i + str(v - 1)
qq.add(n)
n = i + str(v)
qq.add(n)
n = i + str(v + 1)
qq.add(n)
else:
if i[-1] == '0':
n = i + '0'
qq.add(n)
n = i + '1'
qq.add(n)
elif i[-1] == '9':
n = i + '9'
qq.add(n)
n = i + '8'
qq.add(n)
else:
v = int(i[-1])
n = i + str(v - 1)
qq.add(n)
n = i + str(v)
qq.add(n)
n = i + str(v + 1)
qq.add(n)
# print(f'{qq=}')
numbers |= q
# print(f'{numbers=}')
# print(f'{len(numbers)=}')
q = qq
numbers = sorted(map(int, numbers))
# print(f'{numbers[:30]=}')
ans = numbers[K - 1]
print(ans)
| K = int(eval(input()))
numbers = set([])
q = set([1, 2, 3, 4, 5, 6, 7, 8, 9])
# print(f'{q=}')
while len(numbers) <= 100000: # 10**8:
# print('test')
qq = set([])
for i in q:
# print(f'{i=}')
if i % 10 != 0:
n = i * 10 + (i % 10) - 1
qq.add(n)
if i % 10 != 9:
n = i * 10 + (i % 10) + 1
qq.add(n)
n = i * 10 + (i % 10)
qq.add(n)
numbers |= q
# print(f'{numbers=}')
# print(f'{len(numbers)=}')
q = qq
numbers = sorted(map(int, numbers))
# print(f'{numbers[:30]=}')
ans = numbers[K - 1]
print(ans)
| p02720 |
cands = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def add_v(v):
global cands
global K
v = str(v)
v0 = int(v[-1])
if v0 == 0:
cands += [int(v+'0'), int(v+'1')]
K -=2
elif v0 == 9:
cands += [int(v+'8'), int(v+'9')]
K -= 2
else:
cands += [int(v+str(v0-1)), int(v+str(v0)), int(v+str(v0+1))]
K -= 3
K = int(eval(input()))
idk = K
K -= 9
idx = 0
while K >= 0:
add_v(cands[idx])
idx += 1
print((cands[idk-1])) | cands = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def add_v(v):
global cands
global K
v0 = v % 10
if v0 == 0:
cands += [v*10, v*10+1]
K -=2
elif v0 == 9:
cands += [v*10+8, v*10+9]
K -= 2
else:
cands += [v*10+v0-1, v*10+v0, v*10+v0+1]
K -= 3
K = int(eval(input()))
idk = K
K -= 9
idx = 0
while K >= 0:
add_v(cands[idx])
idx += 1
print((cands[idk-1])) | p02720 |
from collections import deque
li=[i for i in range(1,10)]
def bfs(K):
d=deque()
for i in range(1,10):
d.append(str(i))
while(len(li)<K):
s=d[0]
d.popleft()
now=[int(s+s[-1])]
if(s[-1]!='0'):
now.append(int(s+str(int(s[-1])-1)))
if(s[-1]!='9'):
now.append(int(s+str(int(s[-1])+1)))
now.sort()
for i in range(len(now)):
li.append(now[i])
d.append(str(now[i]))
K=int(eval(input()))
bfs(K)
print((li[K-1])) | from collections import deque
lunlun=[i for i in range(1,10)]
def bfs(K):
d=deque([1,2,3,4,5,6,7,8,9])
while(len(lunlun)<K):
s=d[0]
d.popleft()
n=[]
if(s%10!=0):
n.append((s%10-1)+s*10)
n.append(s%10+s*10)
if(s%10!=9):
n.append((s%10+1)+s*10)
lunlun.extend(n);d.extend(n)
K=int(eval(input()))
bfs(K)
print((lunlun[K-1])) | p02720 |
from collections import deque
k = int(eval(input()))
queue = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
for _ in range(k):
num = queue.popleft()
a = num // 10
b = num % 10
if b != 0:
queue.append(num*10 + b-1)
queue.append(num*10 + b)
if b != 9:
queue.append(num*10 + b+1)
print(num)
| from collections import deque
k = int(eval(input()))
queue = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
for _ in range(k):
num = queue.popleft()
x = num % 10
if x != 0:
queue.append(num*10 + x-1)
queue.append(num*10 + x)
if x != 9:
queue.append(num*10 + x+1)
print(num)
| p02720 |
def solve(K):
lun = [0]
def nextLunlun(arr, d=0):
arr[d] += 1
if arr[d] == 10:
if d + 1 == len(arr):
arr.append(1)
arr[d] = 0
return arr
else:
arr = nextLunlun(arr, d + 1)
arr[d] = arr[d + 1] - 1 if arr[d + 1] > 0 else 0
return arr
if d + 1 != len(arr):
if abs(arr[d] - arr[d + 1]) > 1:
if arr[d] < arr[d + 1]:
arr[d] = arr[d + 1] - 1
return arr
else:
arr = nextLunlun(arr, d + 1)
arr[d] = arr[d + 1] - 1 if arr[d + 1] > 0 else 0
return arr
return arr
for _ in range(K):
lun = nextLunlun(lun)
ans = 0
for i in range(len(lun)):
ans += lun[i] * (10 ** i)
print(ans)
if __name__ == '__main__':
K = int(eval(input()))
solve(K)
| # 解説を参考に作成
from collections import deque
def solve(K):
lunlun = deque([i for i in range(1, 10)])
ans = 0
for _ in range(K):
ans = lunlun.popleft()
x = ans * 10 + ans % 10
if x % 10 != 0:
lunlun.append(x - 1)
lunlun.append(x)
if x % 10 != 9:
lunlun.append(x + 1)
print(ans)
if __name__ == '__main__':
K = int(eval(input()))
solve(K)
| p02720 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
def solve(K: int):
X = set()
def rec(keta, val):
X.add(val)
if keta == 10:
return
for j in range(-1, 2):
add = (val % 10)+j
if add >= 0 and add <= 9:
rec(keta+1, val*10+add)
for i in range(1, 10):
rec(1, i)
X = sorted(X)
print((X[K-1]))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
solve(K)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from collections import deque
sys.setrecursionlimit(10**8)
INF = float("inf")
def solve(K: int):
h = deque([])
for i in range(1, 10):
h.append(i)
for i in range(K-1):
s = h.popleft()
for j in range(-1, 2):
add = (s % 10)+j
if 0 <= add <= 9:
h.append(s*10+add)
print((h.popleft()))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
solve(K)
if __name__ == '__main__':
main()
| p02720 |
K=int(eval(input()))
from collections import deque
d=deque([1,2,3,4,5,6,7,8,9])
k=1
while True:
a=d.popleft()
if k==K:
print(a)
exit()
else:
k+=1
r=a%10
if r==0:
for i in [0,1]:
temp=a*10+i
d.append(temp)
elif r==9:
for i in [8,9]:
temp=a*10+i
d.append(temp)
else:
for i in [-1,0,1]:
temp=a*10+(r+i)
d.append(temp)
| K=int(eval(input()))
from collections import deque
d=deque([1,2,3,4,5,6,7,8,9])
k=1
while True:
a=d.popleft()
if k==K:
print(a)
exit()
else:
k+=1
r=a%10
if 0<r<=9:
temp = a * 10 + (r -1)
d.append(temp)
temp=a*10+r
d.append(temp)
if 0<=r<9:
temp=a*10+(r+1)
d.append(temp)
| p02720 |
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush
from decimal import *
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
##### 累乗 #####
# pow(x, y, z) -> x**y % z
def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
K = inputInt()
counts = 0
DP = []
tmp = ["1","2","3","4","5","6","7","8","9"]
DP.append(tmp)
ans = [1,2,3,4,5,6,7,8,9]
for i in range(10):
tmp = []
for j_str in DP[i]:
sita = ""
ue = ""
namaka = j_str[-1]
if j_str[-1] == "0":
ue = str(int(j_str[-1]) + 1)
elif j_str[-1] == "9":
sita = str(int(j_str[-1]) - 1)
else:
ue = str(int(j_str[-1]) + 1)
sita = str(int(j_str[-1]) - 1)
tmp.append(j_str + namaka)
ans.append(int(j_str + namaka))
if sita == "":
tmp.append(j_str + ue)
ans.append(int(j_str + ue))
elif ue == "":
tmp.append(j_str + sita)
ans.append(int(j_str + sita))
else:
tmp.append(j_str + ue)
ans.append(int(j_str + ue))
tmp.append(j_str + sita)
ans.append(int(j_str + sita))
DP.append(tmp)
ans.sort()
#print(DP)
print((ans[K-1]))
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
# comb = Combination(n+r-1, mod)
# return comb(n+r-1, r)
return combination(n+r-1, r, mod)
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush
from decimal import *
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
##### 累乗 #####
# pow(x, y, z) -> x**y % z
##### 割り算の切り上げ #####
# tmp = -(-4 // 3)
##### dict の for文 #####
# for k, v in d.items():
# print(k, v)
##### 進数の変換 #####
# bin_str = bin(i)[2:]
# oct_str = oct(i)[2:]
# hex_str = hex(i)[2:]
##### とても大きな数 と 小数の計算誤差 #####
# 「Decimal」は計算誤差を 0にできる。必要に応じて粒度を設定せよ。
# getcontext().prec = 100
#
# tmp = Decimal(i)
# A,B = map(Decimal, input().split())
# ans = A * B
def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
K = inputInt()
dp = []
dp.append(["1","2","3","4","5","6","7","8","9"])
ans = [1,2,3,4,5,6,7,8,9]
for i in range(10):
testcase = dp[-1]
nextcalse = []
for val in testcase:
base = val[-1]
manaka = val + base
nextcalse.append(manaka)
ans.append(int(manaka))
samp = int(base)
if samp - 1 >= 0:
rinko = val + str(samp - 1)
nextcalse.append(rinko)
ans.append(int(rinko))
if samp + 1 <= 9:
nene = val + str(samp + 1)
nextcalse.append(nene)
ans.append(int(nene))
dp.append(nextcalse)
ans.sort()
print((ans[K-1]))
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索のリバース
def bisect_left_reverse(a, x):
if a[0] <= x:
return 0
if x < a[-1]:
return len(a)
# 二分探索
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] <= x:
ok = mid
else:
ng = mid
return ok
def bisect_right_reverse(a, x):
if a[0] < x:
return 0
if x <= a[-1]:
return len(a)
# 二分探索
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] < x:
ok = mid
else:
ng = mid
return ok
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# 2分検索
# 存在しない場合: None 存在する場合: その値
def binary_search(list, item):
low = 0
high = len(list) - 1
while low <= high:
mid = (low + high) //2
guess = list[mid]
if guess == item:
return mid
if guess > item:
high = mid -1
else:
low = mid + 1
return None
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# N 個のボールを K グループに分ける場合のパターン数
def sunuke(N, K, mod=10**9+7):
if N < K or K-1 < 0:
return 0
else:
return combination(N-1, K-1, mod)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
# comb = Combination(n+r-1, mod)
# return comb(n+r-1, r)
return combination(n+r-1, r, mod)
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# dfs のサンプル
def dfs(graph,parent,counter,edge):
stk = []
stk.append(edge)
while len(stk) > 0:
p = stk.pop()
for e in graph[p]:
if parent[p] == e:
continue
else:
parent[e] = p
counter[e] += counter[p]
stk.append(e)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
main()
| p02720 |
def d_lunlun_number():
import sys
sys.setrecursionlimit(10**6)
K = int(eval(input()))
ans = []
def dfs(num, current, digit_max):
if current == digit_max:
ans.append(num)
return None
for n in range(10):
if abs((num % 10) - n) >= 2:
continue
dfs(num * 10 + n, current + 1, digit_max)
for leading in range(1, 10):
for d in range(1, 11):
dfs(leading, 1, d)
return sorted(ans)[K - 1]
print((d_lunlun_number())) | def d_lunlun_number():
from collections import deque
K = int(eval(input()))
queue = deque(list(range(1, 10)))
ans = -1
for _ in range(K):
ans = queue.popleft()
lsd = ans % 10 # least significant digit
if lsd != 0:
queue.append(10 * ans + (lsd - 1))
queue.append(10 * ans + lsd)
if ans % 10 != 9:
queue.append(10 * ans + (lsd + 1))
return ans
print((d_lunlun_number())) | p02720 |
ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
k = ni()
LIMIT = 12
luns = []
def make_lunlun(l):
if len(l) == LIMIT:
return
luns.append(int(''.join(list(map(str,l)))))
if l[-1]!=0:
make_lunlun(l+[(l[-1]-1)%10])
make_lunlun(l+[(l[-1])%10])
if l[-1]!=9:
make_lunlun(l+[(l[-1]+1)%10])
for i in range(1,10):
make_lunlun([i])
print((sorted(luns)[k-1])) | ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
k = ni()
luns = []
def make_lunlun(l):
if l > 3234566667:
return
luns.append(l)
last = l-l//10*10
if last!=0:
make_lunlun(l*10 + last-1)
make_lunlun(l*10+last)
if last!=9:
make_lunlun(l*10 + last+1)
for i in range(1,10):
make_lunlun(i)
print((sorted(luns)[k-1])) | p02720 |
k=int(eval(input()))
cur=1
ans=[]
while len(ans)<k:
num=str(cur)
n=len(num)
flag=True
pos=-1
# print(num,end=' num\n')
for i in range(n-1):
if abs(int(num[i])-int(num[i+1]))>1:
pos=i+1
flag=False
break
# print(flag)
if flag==True:
ans.append(cur)
cur+=1
else:
if int(num[pos])!=9:
ch=str(int(num[pos])+1)
# print(ch)
cur=int(num[:pos]+ch+num[pos+1:])
else:
ch=str(int(num[pos-1])+1)
cur=int(num[:pos-1]+ch+'0'*len(num[pos:]))
print((ans[-1]))
| k=int(eval(input()))
cur=1
ans=-1
cnt=0
while cnt<k:
num=str(cur)
n=len(num)
flag=True
pos=-1
# print(num,end=' num\n')
for i in range(n-1):
if abs(int(num[i])-int(num[i+1]))>1:
pos=i+1
flag=False
break
# print(flag)
if flag==True:
ans=cur
cur+=1
cnt+=1
else:
if int(num[pos])!=9:
ch=str(int(num[pos])+1)
# print(ch)
cur=int(num[:pos]+ch+num[pos+1:])
else:
ch=str(int(num[pos-1])+1)
cur=int(num[:pos-1]+ch+'0'*len(num[pos:]))
print(ans)
| p02720 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
n = 0
def dfs(vec, d):
nonlocal n
if d == 0:
n += 1
if n == K:
print((''.join(map(str, vec))))
return
else:
return
for i in range(max(0, vec[-1] - 1), min(9, vec[-1] + 1) + 1):
vec.append(i)
dfs(vec, d - 1)
if n >= K:
return
vec.pop()
for d in range(10 ** 20):
for i in range(1, 10):
vec = [i]
dfs(vec, d)
if n >= K:
return
return
if __name__ == '__main__':
main()
| import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
queue = deque(list(range(1, 10)))
for _ in range(K):
n = queue.popleft()
tail = n % 10
n10 = n * 10
if tail != 0:
queue.append(n10 + tail - 1)
queue.append(n10 + tail)
if tail != 9:
queue.append(n10 + tail + 1)
print(n)
return
if __name__ == '__main__':
main()
| p02720 |
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
queue = deque(list(range(1, 10)))
for _ in range(K):
n = queue.popleft()
tail = n % 10
n10 = n * 10
if tail != 0:
queue.append(n10 + tail - 1)
queue.append(n10 + tail)
if tail != 9:
queue.append(n10 + tail + 1)
print(n)
return
if __name__ == '__main__':
main()
| import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
queue = deque(list(range(1, 10)))
for _ in range(K):
n = queue.popleft()
tail = n % 10
n10 = n * 10
if tail == 0:
queue.append(n10 + tail)
queue.append(n10 + tail + 1)
elif tail == 9:
queue.append(n10 + tail - 1)
queue.append(n10 + tail)
else:
queue.append(n10 + tail - 1)
queue.append(n10 + tail)
queue.append(n10 + tail + 1)
print(n)
return
if __name__ == '__main__':
main()
| p02720 |
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
queue = deque(list(range(1, 10)))
for _ in range(K):
n = queue.popleft()
tail = n % 10
n10 = n * 10
if tail == 0:
queue.append(n10 + tail)
queue.append(n10 + tail + 1)
elif tail == 9:
queue.append(n10 + tail - 1)
queue.append(n10 + tail)
else:
queue.append(n10 + tail - 1)
queue.append(n10 + tail)
queue.append(n10 + tail + 1)
print(n)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
vec = list(range(1, 10))
for i in range(K):
tail = vec[i] % 10
n10 = vec[i] * 10
if tail == 0:
vec.append(n10 + tail)
vec.append(n10 + tail + 1)
elif tail == 9:
vec.append(n10 + tail - 1)
vec.append(n10 + tail)
else:
vec.append(n10 + tail - 1)
vec.append(n10 + tail)
vec.append(n10 + tail + 1)
print((vec[K - 1]))
return
if __name__ == '__main__':
main()
| p02720 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
vec = list(range(1, 10))
for i in range(K):
tail = vec[i] % 10
n10 = vec[i] * 10
if tail == 0:
vec.append(n10 + tail)
vec.append(n10 + tail + 1)
elif tail == 9:
vec.append(n10 + tail - 1)
vec.append(n10 + tail)
else:
vec.append(n10 + tail - 1)
vec.append(n10 + tail)
vec.append(n10 + tail + 1)
print((vec[K - 1]))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
vec = list(range(1, 10))
for i in range(K):
tail = vec[i] % 10
n10 = vec[i] * 10
if tail == 0:
vec.append(n10 + tail)
vec.append(n10 + tail + 1)
elif tail == 9:
vec.append(n10 + tail - 1)
vec.append(n10 + tail)
else:
vec.append(n10 + tail - 1)
vec.append(n10 + tail)
vec.append(n10 + tail + 1)
if len(vec) == K:
break
print((vec[K - 1]))
return
if __name__ == '__main__':
main()
| p02720 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
vec = list(range(1, 10))
for i in range(K):
tail = vec[i] % 10
if tail == 0:
vec.append(vec[i] * 10 + tail)
vec.append(vec[i] * 10 + tail + 1)
elif tail == 9:
vec.append(vec[i] * 10 + tail - 1)
vec.append(vec[i] * 10 + tail)
else:
vec.append(vec[i] * 10 + tail - 1)
vec.append(vec[i] * 10 + tail)
vec.append(vec[i] * 10 + tail + 1)
if len(vec) == K:
break
print((vec[K - 1]))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
K = int(readline())
vec = list(range(1, 10))
for i in range(K):
tail = vec[i] % 10
n10 = vec[i] * 10
if tail == 0:
vec.append(n10 + tail)
vec.append(n10 + tail + 1)
elif tail == 9:
vec.append(n10 + tail - 1)
vec.append(n10 + tail)
else:
vec.append(n10 + tail - 1)
vec.append(n10 + tail)
vec.append(n10 + tail + 1)
if len(vec) >= K:
break
print((vec[K - 1]))
return
if __name__ == '__main__':
main()
| p02720 |
k = int(eval(input()))
A = [i for i in range(1, 10)]
while k:
if k <= len(A):
print((A[k-1]))
exit()
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()))
RunRun = [i for i in range(1, 10)]
while True:
if k <= len(RunRun):
print((RunRun[k-1]))
exit()
k -= len(RunRun)
now = []
now, RunRun = RunRun, now
for r in now:
for i in range(-1, 2):
tmp = r % 10 + i
if tmp < 0 or 9 < tmp: continue
tmp = (r * 10) + tmp
RunRun.append(tmp)
#print(RunRun)
| p02720 |
from collections import deque
K = int(eval(input()))
que = deque(['1', '2', '3', '4', '5', '6', '7', '8', '9'])
while K:
if K == 1:
ans = que.popleft()
break
K -= 1
v = que.popleft()
if v[-1] == '0':
que.append(v + '0')
que.append(v + '1')
elif v[-1] == '9':
que.append(v + '8')
que.append(v + '9')
else:
que.append(v + str(int(v[-1]) - 1))
que.append(v + str(int(v[-1])))
que.append(v + str(int(v[-1]) + 1))
print(ans) | from collections import deque
def main():
K = int(eval(input()))
que = deque(['1', '2', '3', '4', '5', '6', '7', '8', '9'])
while K:
if K == 1:
ans = que.popleft()
break
K -= 1
v = que.popleft()
if v[-1] == '0':
que.append(v + '0')
que.append(v + '1')
elif v[-1] == '9':
que.append(v + '8')
que.append(v + '9')
else:
que.append(v + str(int(v[-1]) - 1))
que.append(v + str(int(v[-1])))
que.append(v + str(int(v[-1]) + 1))
print(ans)
if __name__ == '__main__':
main() | p02720 |
from collections import deque
def main():
K = int(eval(input()))
que = deque(['1', '2', '3', '4', '5', '6', '7', '8', '9'])
while K:
if K == 1:
ans = que.popleft()
break
K -= 1
v = que.popleft()
if v[-1] == '0':
que.append(v + '0')
que.append(v + '1')
elif v[-1] == '9':
que.append(v + '8')
que.append(v + '9')
else:
que.append(v + str(int(v[-1]) - 1))
que.append(v + str(int(v[-1])))
que.append(v + str(int(v[-1]) + 1))
print(ans)
if __name__ == '__main__':
main() | from collections import deque
def main():
K = int(eval(input()))
que = deque([i for i in range(1, 10)])
while K:
if K == 1:
ans = que.popleft()
break
K -= 1
v = que.popleft()
if v % 10 == 0:
que.append(v * 10)
que.append(v * 10 + 1)
elif v % 10 == 9:
que.append(v * 10 + 8)
que.append(v * 10 + 9)
else:
que.append(v * 10 + (v % 10 - 1))
que.append(v * 10 + (v % 10))
que.append(v * 10 + (v % 10 + 1))
print(ans)
if __name__ == '__main__':
main() | p02720 |
def dfs(s):
d=len(s)
if d>10:
return
if s!='':
if s[0]!='0':
num.add(int(s))
for c in '0123456789':
if s=='':
dfs(s+c)
else:
if abs(int(s[-1])-int(c))<=1:
dfs(s+c)
k=int(eval(input()))
num=set()
dfs('')
ans=list(num)
ans.sort()
print((ans[k-1])) | from collections import deque
k=int(eval(input()))
q=deque([i for i in range(1,10)])
ans=0
cnt=0
while 1:
x=q.popleft()
cnt+=1
if cnt==k:
ans=x
break
xmod10 = x % 10
if xmod10 != 0:
q.append(10*x+(xmod10-1))
q.append(10*x+(xmod10))
if xmod10 != 9:
q.append(10*x+(xmod10+1))
print(ans)
| p02720 |
def dfs(s,l):
if s!="":
if len(s)>10 or s[0]=="0":
return
if s!="":
l.append(int(s))
for c in "0123456789":
if s!="":
if abs(int(s[-1])-int(c))<=1:
dfs(s+c,l)
else:
if c!="0":
dfs(s+c,l)
k=int(eval(input()))
l=[]
dfs("",l)
l.sort()
print((l[k-1]))
| import sys
sys.setrecursionlimit(10000000)
def dfs(s):
if len(s)==11:
return
if s!="":
a.append(int(s))
for c in "0123456789":
if s=="" and c=="0":continue
if len(s)>0:
if abs(ord(s[-1])-ord(c))<=1:
dfs(s+c)
else:
dfs(s+c)
k=int(eval(input()))
a=[]
dfs("")
a=list(set(a))
a.sort()
print((a[k-1]))
| p02720 |
import sys
sys.setrecursionlimit(10000000)
def dfs(s):
if len(s)==11:
return
if s!="":
a.append(int(s))
for c in "0123456789":
if s=="" and c=="0":continue
if len(s)>0:
if abs(ord(s[-1])-ord(c))<=1:
dfs(s+c)
else:
dfs(s+c)
k=int(eval(input()))
a=[]
dfs("")
a=list(set(a))
a.sort()
print((a[k-1]))
| import sys
sys.setrecursionlimit(10000000)
def dfs(s):
if len(s)==11:
return
if s!="":
a.append(int(s))
for c in "0123456789":
if s=="" and c=="0":continue
if s!="":
if abs(ord(c)-ord(s[-1]))<=1:
dfs(s+c)
else:
dfs(s+c)
k=int(eval(input()))
a=[]
dfs("")
a=list(set(a))
a.sort()
print((a[k-1]))
| p02720 |
import collections
k = int(eval(input()))
n = 10**10
li = list(range(1,10))
num_li = li[:]
q = collections.deque(li)
count = 0
for i in range(1,n):
num = str(q.popleft())
go = int(num[-1])
if go != 0:
numa = num + str(go - 1)
num_li.append(int(numa))
q.append(int(numa))
count += 1
numa = num + str(go)
num_li.append(int(numa))
q.append(int(numa))
count += 1
if go != 9:
numa = num + str(go + 1)
num_li.append(int(numa))
q.append(int(numa))
count += 1
if count > k+1:
break
print((num_li[k-1])) | import collections
k = int(eval(input()))
li = [str(i) for i in range(1,10)]
st_li = li[:]
q = collections.deque(li)
count = 0
n = 10 ** 10
for i in range(1, n):
a = q.popleft()
num = int(a[-1])
if num != 0:
aa = a + str(num-1)
st_li.append(aa)
q.append(aa)
count += 1
aa = a + str(num)
st_li.append(aa)
q.append(aa)
count += 1
if num != 9:
aa = a + str(num+1)
st_li.append(aa)
q.append(aa)
count += 1
if count > k+1:
print((st_li[k - 1]))
exit(0) | p02720 |
import sys
from collections import deque
def input():
return sys.stdin.readline().strip()
def main():
K = int(eval(input()))
ans = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
for _ in range(K - 1):
a = ans.popleft()
if a % 10 == 0:
ans.append(a * 10)
ans.append(a * 10 + 1)
elif a % 10 == 9:
ans.append(a * 10 + 8)
ans.append(a * 10 + 9)
else:
w = a % 10
ans.append(a * 10 + w - 1)
ans.append(a * 10 + w)
ans.append(a * 10 + w + 1)
print((ans.popleft()))
if __name__ == "__main__":
main()
| import sys
from collections import deque
def input():
return sys.stdin.readline().strip()
sys.setrecursionlimit(20000000)
MOD = 10 ** 9 + 7
INF = float("inf")
def main():
K = int(eval(input()))
q = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
for i in range(K):
d = q.popleft()
a = d % 10
if a == 0:
q.append(d * 10)
q.append(d * 10 + 1)
elif a == 9:
q.append(d * 10 + a - 1)
q.append(d * 10 + a)
else:
q.append(d * 10 + a - 1)
q.append(d * 10 + a)
q.append(d * 10 + a + 1)
print(d)
if __name__ == "__main__":
main()
| p02720 |
k=int(eval(input()))
L=[]
def f(d,now,L):
L.append(now)
if d==10:
return
for j in range(-1,2):
v=now%10+j
if 0<=v<=9:
f(d+1,now*10+v,L)
for l in range(1,10):
f(1,l,L)
L.sort()
print((L[k-1]))
| from collections import deque
k=int(eval(input()))
lunlun=deque(i for i in range(1,10))
for _ in range(k-1):
p=lunlun.popleft()
if p%10!=0:
lunlun.append(10*p+p%10-1)
lunlun.append(10*p+p%10)
if p%10!=9:
lunlun.append(10*p+p%10+1)
print((lunlun.popleft())) | p02720 |
from sys import stdin,setrecursionlimit
k = int(stdin.readline().rstrip())
li = [i for i in range(1,10)]
#ルンルン最初の数
def runrun(before,kazu):
if before == 0:
li.append(int(kazu+str(before+1)))
li.append(int(kazu+str(before)))
elif before == 9:
li.append(int(kazu+str(before-1)))
li.append(int(kazu+str(before)))
else:
li.append(int(kazu+str(before+1)))
li.append(int(kazu+str(before-1)))
li.append(int(kazu+str(before)))
if len(kazu)+1 >= 10:
return
else:
if before == 0:
return runrun(before+1,kazu+str(before+1)),runrun(before,kazu+str(before))
elif before == 9:
return runrun(before-1,kazu+str(before-1)),runrun(before,kazu+str(before))
else:
return runrun(before+1,kazu+str(before+1)),runrun(before-1,kazu+str(before-1)),runrun(before,kazu+str(before))
for i in range(1,10):
runrun(i,str(i))
li.sort()
print((li[k-1])) | from queue import deque
k = int(eval(input()))
que = deque()
for i in range(1,10):
que.append(i)
for i in range(k):
if i == (k-1):
print((que.popleft()))
exit()
now = que.popleft()
if now%10 != 0:
que.append(now*10+now%10-1)
que.append(now*10+now%10)
if now%10 != 9:
que.append(now*10+now%10+1) | p02720 |
k=int(eval(input()))
ans=[[i for i in range(1,10)]]
d=9
while d<k:
ans.append([])
for i in ans[-2]:
x=str(i)
y=int(x[0])
if y==1:
ans[-1].append(str(y)+x)
ans[-1].append(str(y+1)+x)
elif 2<=y<=8:
ans[-1].append(str(y-1)+x)
ans[-1].append(str(y)+x)
ans[-1].append(str(y+1)+x)
else:
ans[-1].append(str(y-1)+x)
ans[-1].append(str(y)+x)
z=int(x[-1])
if z==0:
ans[-1].append(x+str(z))
ans[-1].append(x+str(z+1))
elif 1<=z<=8:
ans[-1].append(x+str(z-1))
ans[-1].append(x+str(z))
ans[-1].append(x+str(z+1))
else:
ans[-1].append(x+str(z-1))
ans[-1].append(x+str(z))
ans[-1]=list(set(ans[-1]))
d+=len(ans[-1])
l=len(ans[-1])
v=sorted([int(i) for i in ans[-1]])
print((v[k-(d-l)-1])) | k=int(eval(input()))
ans=[[i for i in range(1,10)]]
d=9
while d<k:
ans.append([])
for i in ans[-2]:
x=str(i)
z=int(x[-1])
if z==0:
ans[-1].append(x+str(z))
ans[-1].append(x+str(z+1))
elif 1<=z<=8:
ans[-1].append(x+str(z-1))
ans[-1].append(x+str(z))
ans[-1].append(x+str(z+1))
else:
ans[-1].append(x+str(z-1))
ans[-1].append(x+str(z))
d+=len(ans[-1])
l=len(ans[-1])
v=sorted([int(i) for i in ans[-1]])
print((v[k-(d-l)-1])) | p02720 |
k=int(eval(input()))
ans=[[i for i in range(1,10)]]
d=9
while d<k:
ans.append([])
for i in ans[-2]:
x=str(i)
z=int(x[-1])
ans[-1].append(x+str(z))
if z<=8:
ans[-1].append(x+str(z+1))
if z>=1:
ans[-1].append(x+str(z-1))
d+=len(ans[-1])
l=len(ans[-1])
v=sorted([int(i) for i in ans[-1]])
print((v[k-(d-l)-1])) | k=int(eval(input()))
ans=[[i for i in range(1,10)]]
d=9
while d<k:
ans.append([])
for i in ans[-2]:
x=str(i)
z=int(x[-1])
ans[-1].append(x+str(z))
if z<=8:
ans[-1].append(x+str(z+1))
if z>=1:
ans[-1].append(x+str(z-1))
d+=len(ans[-1])
ans[-1].sort()
print((ans[-1][k-d-1])) | p02720 |
from collections import deque
k = int(eval(input()))
queue = [1, 2, 3, 4, 5, 6, 7, 8, 9]
queue = deque(queue)
cnt = 0
while cnt < k:
cnt += 1
a = queue.popleft()
hitoketa = a % 10
kouho = [hitoketa - 1, hitoketa, hitoketa + 1]
for b in kouho:
if b >= 0 and b <= 9:
queue.append(10 * a + b)
print(a)
| from collections import deque
k = int(eval(input()))
LL = [i for i in range(1, 10)]
LL = deque(LL)
for j in range(k):
num = LL.popleft()
amari = num % 10
kouho = [amari - 1, amari, amari + 1]
for nn in kouho:
if nn >= 0 and nn < 10:
LL.append(10 * num + nn)
print(num)
| p02720 |
import sys
N, K = list(map(int, sys.stdin.readline().split()))
if K == 0:
print((N*N))
sys.exit()
# b は K 以上
# a は b * c + K <= a < b * (c+1)
ans = 0
for i in range(1, N+1):
# print(N // i, (i - K), max(N % i - K, 0))
tmp = (N // i) * max(i - K, 0) + max(N % i + 1 - K, 0)
ans += tmp
print(ans) | import sys
N, K = list(map(int, sys.stdin.readline().split()))
if K == 0:
print((N*N))
sys.exit()
ans = 0
for b in range(K+1, N+1):
r = N // b
# tmp = (b - K) * r
# tmp2 = (N % b + 1 - K)
# print(b, tmp, tmp2)
tmp = (b - K) * r + max(0, N % b + 1 - K)
ans += tmp
print(ans) | p03420 |
import sys
n,k = list(map(int,input().split()))
#if k == 0:
# print(n**2)
# sys.exit
count = 0
for i in range(1,n+1):
tmp_count = max(0,i - k)
#print(i,n // i,tmp_count,(n // i)* tmp_count + max(0,(n % k)-k+1),max(0,(n % i)-k+1),n % i)
count += (n // i)* tmp_count + max(0,(n % i)-k+1)
if k == 0:
count -= n
print(count) | import sys
n,k = list(map(int,input().split()))
#if k == 0:
# print(n**2)
# sys.exit
count = 0
for i in range(1,n+1):
tmp_count = max(0,i - k)
#print(i,n // i,tmp_count,(n // i)* tmp_count + max(0,(n % k)-k+1),max(0,(n % i)-k+1),n % i)
count += (n // i)* tmp_count + max(0,(n % i)-k+1)
if k == 0:
print((n**2))
else:
print(count) | p03420 |
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
res = 0
for i in range(1, N + 1):
u = max(i - K, 0)
v = N // i
x = max(N % i - K + 1, 0)
res += u * v + x - (K == 0)
#print(i, u, v, x)
#print(res)
print(res) | import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
res = 0
for x in range(K + 1, N + 1):
res += (N // x) * (x - K) + max(0, N % x - K + (K > 0))
#print(x, res)
print(res) | p03420 |
n, k = list(map(int, input().split()))
if k == 0:
print((n**2))
exit()
ans = 0
for i in range(1, n+1):
if i <= k:
continue
q, r = divmod(n, i)
if r < k:
ans += (i-k)*q
else:
ans += (i-k)*q + (r-k+1)
print(ans)
| n, k = list(map(int, input().split()))
if k == 0:
ans = n**2
print(ans)
exit()
ans = 0
for b in range(1, n+1):
if b <= k:
continue
q, r = divmod(n, b)
if r < k:
ans += ((b-1)-k+1)*q
else:
ans += ((b-1)-k+1)*q + r-k+1
print(ans)
| p03420 |
def calc0(N, K):
r = 0
for a in range(1, N + 1):
for b in range(1, N + 1):
if a % b >= K:
print((a, b, a % b))
r += 1
return r
def calc1(N, K):
result = 0
for i in range(K, N):
for x in range(i + 1, N + 1):
if i > 0:
r = (N + x - i) // x
else:
r = (N + x - i) // x - 1
# print(i, x, r)
result += r
return result
def calc2(N, K):
if K == 0:
return N**2
result = 0
for x in range(1, N + 1):
for i in range(K, min(N, x)):
r = (N - i) // x + 1
result += r
return result
def calc2(N, K):
if K == 0:
return N**2
result = 0
for x in range(1, N + 1):
for i in range(K, min(N, x)):
r = (N - i) // x + 1
result += r
return result
def calc3(N, K):
if K == 0:
return N**2
result = 0
for x in range(1, N + 1):
st = N - min(N, x) + 1
ed = N - K
if (ed < x):
r = (ed - st + 1)
else:
r = 0
for j in range(st, ed + 1):
r += j // x + 1
print((st, ed, x, r))
result += r
return result
def calc(N, K):
if K == 0:
return N**2
result = 0
for b in range(1, N + 1):
if b <= K:
continue
n, m = divmod(N, b)
r1 = (b - K) * n
r2 = 0
if m >= K:
r2 = m - K + 1
result += r1 + r2
return result
N, K = [int(_) for _ in input().split()]
# print(calc2(N, K))
print((calc(N, K)))
| def calc(N, K):
if K == 0:
return N**2
result = 0
for b in range(K + 1, N + 1):
n, m = divmod(N, b)
result += (b - K) * n
if m >= K:
result += m - K + 1
return result
N, K = [int(_) for _ in input().split()]
print((calc(N, K)))
| p03420 |
n,k=list(map(int,input().split()))
ans=0
for b in range(k+1,n+1):
ans+=(n//b)*(b-k)
m=n%b
ans+=max(0,m-(k-1))
if k==0:ans-=n
print(ans) | n,k=list(map(int,input().split()))
ans=0
for b in range(k+1,n+1):
m=(n//b)
mm=n%b
ans+=m*(b-k)
ans+=max(0,mm-k+1)
print((ans-(n if k==0 else 0))) | p03420 |
n, k = list(map(int, input().split()))
ans = 0
if k == 0:
ans = n*n
else:
for i in range(1, n+1):
ans += n//i * max(i-k, 0)
a = n//i * max(i-k, 0)
b = 0
if i >= k and n % i != 0:
ans += max(0, (n%i+1)-k)
b = max(0, (n%i+1)-k)
print(ans)
| n, k = list(map(int, input().split()))
ans = 0
if k == 0:
ans = n * n
else:
for i in range(1, n + 1):
ans += n // i * max(i - k, 0)
if i >= k and n % i != 0:
ans += max(0, (n % i + 1) - k)
print(ans)
| p03420 |
N, K = list(map(int, input().split()))
ans = 0
for b in range(K + 1, N + 1):
p = N // b
q = p * (b - K) + max(N % b - K + 1, 0)
ans += q if K > 0 else q-1
print(ans)
| N,K=list(map(int,input().split()));print((sum(N//b*(b-K)+max(N%b+1-K,0)-(K<1)for b in range(K+1,N+1)))) | p03420 |
N, K = list(map(int, input().split()))
if K == 0:
print((N**2))
exit()
ans = 0
for div in range(K + 1, N + 1):
cnt = N // div
ans += cnt * (div - K)
ans += max(0, (N % div) - K + 1)
print(ans) | N, K = list(map(int, input().split()))
if K == 0:
print((N**2))
exit()
ans = 0
for d in range(K + 1, N + 1):
ans += (N // d) * (d - K)
ans += max(0, N % d - K + 1)
print(ans) | p03420 |
n, k = list(map(int, input().split(' ')))
result = 0
for i in range(1, n+1):
p = n//i
result += p*max(0,i-k)
result += max(0, n%i-k+1)
if k == 0:
result -= 1
print(result) | def main():
n, k = list(map(int, input().split(' ')))
result = 0
for i in range(1, n+1):
p = n//i
result += p*max(0,i-k)
result += max(0, n%i-k+1)
if k == 0:
result -= 1
print(result)
main() | p03420 |
def main():
n, k = list(map(int, input().split(' ')))
result = 0
for i in range(1, n+1):
p = n//i
result += p*max(0,i-k)
result += max(0, n%i-k+1)
if k == 0:
result -= 1
print(result)
main() | def main():
n, k = list(map(int, input().split(' ')))
result = 0
for i in range(1, n+1):
p = n//i
result += p*max(0,i-k)
result += max(0, n%i-k+1)
if k == 0:
result -= n
print(result)
main() | p03420 |
def main():
n, k = list(map(int, input().split(' ')))
result = 0
for i in range(1, n+1):
p = n//i
result += p*max(0,i-k)
result += max(0, n%i-k+1)
if k == 0:
result -= n
print(result)
main() | def main():
n, k = list(map(int, input().split(' ')))
result = 0
for i in range(1, n+1):
result += n//i*max(0,i-k) + max(0, n%i-k+1)
if k == 0:
result -= n
print(result)
main() | p03420 |
def main():
n, k = list(map(int, input().split(' ')))
result = 0
for i in range(1, n+1):
result += n//i*max(0,i-k) + max(0, n%i-k+1)
if k == 0:
result -= n
print(result)
main() | def main():
n, k = list(map(int, input().split(' ')))
result = [n//i*max(0,i-k) + max(0, n%i-k+1) for i in range(1, n+1)]
if k == 0:
print((sum(result)-n))
else:
print((sum(result)))
main() | p03420 |
n, k = list(map(int, input().split()))
ans = 0
for b in range(k + 1, n + 1):
ans += ((n // b) * max(0, b - k)) + max(0, (n % b) - k + 1)
if k == 0:
ans = n ** 2
print(ans)
| n, k = list(map(int, input().split()))
ans = 0
for b in range(k + 1, n + 1):
ans += ((n // b) * (b - k)) + max(0, (n % b) - k + 1)
if k == 0:
ans = n ** 2
print(ans)
| p03420 |
import math
n, k = list(map(int, input().split()))
res = 0
for b in range(1, n + 1):
res += math.floor(n / b) * max(0, b - k) + max(0, n % b - k + 1)
if k == 0:
res = n ** 2
print(res)
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
if k == 0:
print((n ** 2))
exit()
res = 0
for b in range(1, n + 1):
res += n // b * max(0, b - k)
res += max(0, n % b + 1 - k)
print(res)
if __name__ == '__main__':
resolve()
| p03420 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
if k == 0:
print((n ** 2))
exit()
res = 0
for b in range(1, n + 1):
res += n // b * max(0, b - k)
res += max(0, n % b + 1 - k)
print(res)
if __name__ == '__main__':
resolve()
| import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
if k == 0:
print((n ** 2))
exit()
res = 0
for b in range(1, n + 1):
res += (n // b) * max(0, (b - k))
res += max(0, (n % b) - (k - 1))
print(res)
if __name__ == '__main__':
resolve()
| p03420 |
n, k = [int(i) for i in input().split()]
ans = 0
if k == 0:
ans = n*n
else:
for b in range(k+1, n+1):
# number of perfect cycle
ans += max(n // b, 0) * (b-k)
r = n % b
ans += max(r - k+1, 0)
print(ans) | n, k = [int(i) for i in input().split()]
ans = 0
if k == 0:
ans = n*n
else:
for b in range(k+1, n+1):
# number of perfect cycle
ans += n // b * (b-k)
r = n % b
ans += max(r - k+1, 0)
print(ans) | p03420 |
n,k=list(map(int,input().split()))
a=0
for b in range(1,n+1):
if b>k:
a+=(b-k)*(n//b)+(n%b-k+1)*(n%b>k-1)-1*(k==0)
print(a) | n,k=list(map(int,input().split()))
a=0
for b in range(k+1,n+1):
a+=(b-k)*(n//b)+(n%b-k+1)*(n%b>k-1)-1*(k==0)
print(a)
| p03420 |
n,k = list(map(int,input().split()))
ans =0
if k==0:
print((n**2))
exit()
for i in range(k+1,n+1):
ans+=(n//i)*(i-k) + max(0,n%i-k+1)
print(ans) | def solve():
n,k = list(map(int,input().split()))
res = 0
for i in range(k+1,n+1):
res+=(i-k)*(n//i)
if n%i>=k:
if k==0:
res+=n%i
else:
res+=n%i-k+1
print(res)
if __name__=='__main__':
solve() | p03420 |
N,K = list(map(int,input().split()))
if K == 0:
print((N*N))
exit()
ans = 0
for b in range(1,N+1):
cycle,rem = divmod(N,b)
ans += cycle * max(0, b-K)
ans += max(0, rem+1 - K)
print(ans) | N,K = list(map(int,input().split()))
if K == 0:
print((N*N))
exit()
ans = 0
for b in range(K+1,N+1):
d,m = divmod(N,b)
ans += d*(b-K) + max(0,m+1-K)
print(ans) | p03420 |
def main():
N, K = list(map(int, input().split()))
cnt = 0
for b in range(1,N+1):
cnt += (N // b) * max(0, b - K)
cnt += max(0, (N % b) + 1 - K)
if K == 0:
cnt -= N
print(cnt)
if __name__ == "__main__":
main() | def num_divisors_cnt(n):
table = [0] * (n + 1)
for i in range(1, n+1):
for j in range(i, n + 1, i):
table[j] += 1
return table
def main():
N, K = list(map(int, input().split()))
ans = 0
for i in range(K+1,N+1):
cnt = i - K
cnt *= N // i
cnt += max((N % i) - K + 1,0)
ans += cnt
if K == 0:
ans -= N
print(ans)
if __name__ == "__main__":
main() | p03420 |
n, k = list(map(int, input().split()))
ans = 0
if k == 0:
print((n * n))
exit()
for i in range(k + 1, n + 1):
# 周期i
# 0 1 2 3 ... i - 1, 0,
# 1周期にi - kこk以上
# 1始まりなのがめんどい
# 最初1周期だけさせる
m = n
m -= i - 1
ans += i - k
full = m // i * (i - k)
amari = m % i # 周期の途中でnを超える
ans += full + max(0, amari - k)
print(ans)
| n, k = list(map(int, input().split()))
print((sum([n // i * (i - k) + max(0, n % i - k + 1)
for i in range(k + 1, n + 1)]) - (k == 0) * n))
| p03420 |
n,k = list(map(int,input().split()))
print((sum([(i-k)*(n//i)+max(0,n%i-max(0,k-1)) for i in range(k+1,n+1)]))) | n,k = list(map(int,input().split()))
print((n**2 if not k else sum([(i-k)*(n//i)+max(0,n%i-k+1) for i in range(k+1,n+1)]))) | p03420 |
N,K = list(map(int,input().split()))
ans = 0
for b in range(1,N+1) :
p = N//b
r = N % b
ans += max(0, b-K)*p + max(0, r-K+1)
if K == 0 :
ans -= 1
print(ans)
| N,K = list(map(int,input().split()))
ans = 0
for b in range(1,N+1) :
p = N//b
r = N % b
ans += max(0, b-K)*p + max(0, r-K+1)
if K == 0 :
ans -= N
print(ans)
| p03420 |
N,K=list(map(int,input().split()))
b = K + 1
s = 0
while b <= N:
c = N % b
s += (N//b)*(b-K) + max(0,c-K+1)
b += 1
print((s if K != 0 else N*N))
| N,K=list(map(int,input().split()))
b,s=K+1,0
while b <= N:
c=N%b
s+=(N//b)*(b-K)+max(0,c-K+1)
b+=1
print((s if K!=0 else N*N)) | p03420 |
N,K=list(map(int,input().split()))
b,s=K+1,0
while b <= N:
c=N%b
s+=(N//b)*(b-K)+max(0,c-K+1)
b+=1
print((s if K!=0 else N*N)) | N,K=list(map(int,input().split()))
s=0
for b in range(K+1,N+1):s+=(N//b)*(b-K)+max(0,N%b-K+1)
print((s if K!=0 else N*N)) | p03420 |
N,K=list(map(int,input().split()))
if K==0:
print((N**2))
exit(0)
ans=0
for i in range(K+1,N+1):
cur=0
base=i-(K-1)-1
cur+=(N//i)*base
rest=N%i
cur+=max(rest-(K-1),0)
ans+=cur
print(ans) | N,K=list(map(int,input().split()))
if K==0:
print((N**2))
exit(0)
ans=0
for i in range(K+1,N+1):
base=i-(K-1)-1
ans+=(N//i)*base
rest=N%i
ans+=max(rest-(K-1),0)
print(ans) | p03420 |
import itertools
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,MOD = list(map(int,input().split()))
if N == 1:
print((1))
exit()
graph = [set() for _ in range(N)]
for row in sys.stdin.readlines():
x,y = list(map(int,row.split()))
graph[x-1].add(y-1)
graph[y-1].add(x-1)
ldp = [None] * N
rdp = [None] * N
def dfs_1(v=0,parent=None):
# 子ごとに、そこを黒くして適切 or 完全白
graph[v].discard(parent)
ldp[v] = [1] * (len(graph[v])+1)
rdp[v] = [1] * (len(graph[v])+1)
vals = [dfs_1(w,v)+1 for w in graph[v]]
for i,x in enumerate(vals,1):
ldp[v][i] = ldp[v][i-1] * x % MOD
for i,x in enumerate(reversed(vals),1):
rdp[v][-i-1] = rdp[v][-i] * x % MOD
return ldp[v][-1]
dfs_1()
def dfs_2(v=0,x=1):
# それぞれの子以外の情報をマージして、子に渡さなければいけない
dp[v] = x * ldp[v][-1] % MOD
for w,p,q in zip(graph[v],ldp[v][:-1],rdp[v][1:]):
dfs_2(w,x*p*q%MOD+1)
dp = [None] * N
dfs_2()
print(('\n'.join(map(str,dp)))) | import itertools
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,MOD = list(map(int,input().split()))
if N == 1:
print((1))
exit()
graph = [set() for _ in range(N)]
for row in sys.stdin.readlines():
x,y = list(map(int,row.split()))
graph[x-1].add(y-1)
graph[y-1].add(x-1)
ldp = [None] * N
rdp = [None] * N
def dfs_1(v=0,parent=None):
# 子ごとに、そこを黒くして適切 or 完全白
graph[v].discard(parent)
ldp[v] = [1] * (len(graph[v])+1)
rdp[v] = [1] * (len(graph[v])+1)
vals = [dfs_1(w,v)+1 for w in graph[v]]
for i,x in enumerate(vals,1):
ldp[v][i] = ldp[v][i-1] * x % MOD
for i,x in enumerate(reversed(vals),1):
rdp[v][-i-1] = rdp[v][-i] * x % MOD
return ldp[v][-1]
dfs_1()
dp = [None] * N
q = [(0,1)]
while q:
v,x = q.pop()
dp[v] = x*ldp[v][-1]%MOD
for w,L,R in zip(graph[v],ldp[v][:-1],rdp[v][1:]):
q.append((w,x*L*R%MOD+1))
print(('\n'.join(map(str,dp)))) | p03181 |
import sys
from collections import deque
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
N, M = list(map(int, readline().split()))
G = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, readline().split()))
G[x-1].append((y-1, 2*i))
G[y-1].append((x-1, 2*i+1))
G0 = [None]*N
used = [0]*N
used[0] = 1
que = deque([0])
while que:
v = que.popleft()
g = []
for e in G[v]:
w, d = e
if used[w]:
continue
g.append(e)
used[w] = 1
que.append(w)
G0[v] = g
memo = [0]*(2*N+1)
def dfs0(v, p, e):
r = 1
for w, d in G0[v]:
r = r * (1 + dfs0(w, v, d)) % M
memo[e] = r
return r
lv = [0]*(2*N); rv = [0]*(2*N)
ans = [None]*N
def dfs1(v, p, par):
s = 1 + par
for w, d in G0[v]:
lv[d] = s
s = s * (1 + memo[d]) % M
s = 1
for w, d in reversed(G0[v]):
rv[d] = s
s = s * (1 + memo[d]) % M
for w, d in G0[v]:
memo[d ^ 1] = x = lv[d] * rv[d] % M
dfs1(w, v, x)
dfs0(0, -1, 2*N)
dfs1(0, -1, 0)
ans = []
for v in range(N):
r = 1
for w, d in G[v]:
r = r * (1 + memo[d]) % M
ans.append("%d\n" % r)
sys.stdout.writelines(ans) | import sys
from collections import deque
readline = sys.stdin.readline
N, M = list(map(int, readline().split()))
G = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, readline().split()))
G[x-1].append((y-1, 2*i))
G[y-1].append((x-1, 2*i+1))
G0 = [None]*N
V = [(0, -1)]
used = [0]*N
used[0] = 1
que = deque([0])
while que:
v = que.popleft()
g = []
for e in G[v]:
w, d = e
if used[w]:
continue
g.append(e)
V.append(e)
used[w] = 1
que.append(w)
G0[v] = g
memo = [0]*(2*N+1)
for v, e in reversed(V):
r = 1
for w, d in G0[v]:
r = r * (1 + memo[d]) % M
memo[e] = r
lv = [0]*(2*N); rv = [0]*(2*N)
for v, e in V:
s = 1 + memo[e ^ 1]
for w, d in G0[v]:
lv[d] = s
s = s * (1 + memo[d]) % M
s = 1
for w, d in reversed(G0[v]):
rv[d] = s
s = s * (1 + memo[d]) % M
for w, d in G0[v]:
memo[d ^ 1] = lv[d] * rv[d] % M
ans = []
for v in range(N):
r = 1
for w, d in G[v]:
r = r * (1 + memo[d]) % M
ans.append("%d\n" % r)
sys.stdout.writelines(ans) | p03181 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N, MOD = list(map(int, input().split()))
#計算量 log(m)くらい
def modinv(a, m): #mod. m でのaの逆元 a^{-1}を計算する
b = m
u = 1
v = 0
while b:
t = a//b
a -= t * b
a, b = b, a
u -= t * v
u, v = v, u
u %= m
if u < 0:
u += m
return u
G = [[] for _ in range(N + 1)]
for _ in range(N - 1):
x, y = list(map(int, input().split()))
G[x].append(y)
G[y].append(x)
DP1 = [-1] * (N + 1)
DP1[0] = 1
parent = [-1] * (N + 1)
parent[1] = 0
def dfs(x, p):
tmp = 1
for next_ in G[x]:
if next_ == p:
continue
parent[next_] = x
tmp *= (dfs(next_, x) + 1)
DP1[x] = tmp
return tmp
dfs(1, 0)
# print (DP1)
DP2 = [-1] * (N + 1)
DP2[0] = 1
DP2[1] = 1
stack = [1]
while stack:
x = stack.pop()
for next_ in G[x]:
if DP2[next_] != -1:
continue
tmp = DP1[x]
tmp //= (DP1[next_] + 1)
tmp *= DP2[parent[next_]]
tmp += 1 #白色の分
DP2[next_] = tmp
stack.append(next_)
# print (DP2)
for i in range(1, N + 1):
print((DP1[i] % MOD * (DP2[i] % MOD) % MOD)) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N, MOD = list(map(int, input().split()))
#計算量 log(m)くらい
def modinv(a, m): #mod. m でのaの逆元 a^{-1}を計算する
b = m
u = 1
v = 0
while b:
t = a//b
a -= t * b
a, b = b, a
u -= t * v
u, v = v, u
u %= m
if u < 0:
u += m
return u
G = [[] for _ in range(N + 1)]
for _ in range(N - 1):
x, y = list(map(int, input().split()))
G[x].append(y)
G[y].append(x)
DP1 = [-1] * (N + 1)
DP1[0] = 1
parent = [-1] * (N + 1)
parent[1] = 0
def dfs(x, p):
tmp = 1
for next_ in G[x]:
if next_ == p:
continue
parent[next_] = x
tmp *= (dfs(next_, x) + 1)
tmp %= MOD
DP1[x] = tmp
return tmp
dfs(1, 0)
# print (DP1)
DP2 = [-1] * (N + 1)
DP2[0] = 1
DP2[1] = 1
stack = [1]
while stack:
x = stack.pop()
for next_ in G[x]:
if DP2[next_] != -1:
continue
tmp = 1
for y in G[x]:
if y != next_ and y != parent[x]:
tmp *= (DP1[y] + 1)
tmp %= MOD
tmp *= DP2[parent[next_]]
tmp += 1 #白色の分
DP2[next_] = tmp % MOD
stack.append(next_)
# print (DP2)
for i in range(1, N + 1):
print((DP1[i] * DP2[i] % MOD)) | p03181 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N, MOD = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(N - 1):
x, y = list(map(int, input().split()))
G[x].append(y)
G[y].append(x)
G[0].append(1)
G[1].append(0)
DP1 = [-1] * (N + 1)
DP1[0] = 0
parent = [-1] * (N + 1)
parent[1] = 0
def dfs(x, p):
tmp = 1
for next_ in G[x]:
if next_ == p:
continue
parent[next_] = x
tmp *= (dfs(next_, x) + 1)
tmp %= MOD
DP1[x] = tmp
return tmp
dfs(1, 0)
# print (DP1)
DP2 = [1] * (N + 1)
stack = [1]
#next_とyとで2重ループになってO(N^2) (星型のとき)
while stack:
x = stack.pop()
# 累積積のパート
#ここが同じ値を返すかチェックする
n = len(G[x])
lst1 = [1] * (n + 1)
lst2 = [1] * (n + 1)
for i in range(n):
#親のときだけは違うルールで対処
if G[x][i] == parent[x]:
lst1[i + 1] = lst1[i] * DP2[x] % MOD
else:
lst1[i + 1] = lst1[i] * (DP1[G[x][i]] + 1) % MOD
if G[x][n - 1 - i] == parent[x]:
lst2[n - i - 1] = lst2[n - i] * DP2[x] % MOD
else:
lst2[n - i - 1] = lst2[n - i] * (DP1[G[x][n - 1 - i]] + 1) % MOD
for i in range(n):
if G[x][i] == parent[x]:
continue
tmp = lst1[i] * lst2[i + 1] % MOD
tmp += 1 #白色の分
DP2[G[x][i]] = tmp % MOD
stack.append(G[x][i])
# print (DP2)
for i in range(1, N + 1):
print(((DP1[i] * DP2[i]) % MOD))
# print (DP1)
# print (DP2) | import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10 ** 7)
N, MOD = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(N - 1):
x, y = list(map(int, input().split()))
G[x].append(y)
G[y].append(x)
G[0].append(1)
G[1].append(0)
DP1 = [0] * (N + 1)
parent = [-1] * (N + 1)
parent[1] = 0
order = []
order_append = order.append
stack = [1]
stack_pop = stack.pop
stack_append = stack.append
while stack:
x = stack_pop()
order_append(x)
for next_ in G[x]:
if next_ == parent[x]:
continue
parent[next_] = x
stack_append(next_)
for v in order[::-1]:
tmp = 1
for next_ in G[v]:
tmp *= DP1[next_] + 1
tmp %= MOD
DP1[v] = tmp
# print (DP1)
DP2 = [1] * (N + 1)
for x in order:
# 累積積のパート
#ここが同じ値を返すかチェックする
n = len(G[x])
lst1 = [1] * (n + 1)
lst2 = [1] * (n + 1)
for i in range(n):
#親のときだけは違うルールで対処
if G[x][i] == parent[x]:
lst1[i + 1] = lst1[i] * DP2[x] % MOD
else:
lst1[i + 1] = lst1[i] * (DP1[G[x][i]] + 1) % MOD
if G[x][n - 1 - i] == parent[x]:
lst2[n - i - 1] = lst2[n - i] * DP2[x] % MOD
else:
lst2[n - i - 1] = lst2[n - i] * (DP1[G[x][n - 1 - i]] + 1) % MOD
for i in range(n):
if G[x][i] == parent[x]:
continue
tmp = lst1[i] * lst2[i + 1] % MOD
tmp += 1 #白色の分
DP2[G[x][i]] = tmp
# stack.append(G[x][i])
# print (DP2)
for i in range(1, N + 1):
print(((DP1[i] * DP2[i]) % MOD))
# print (DP1)
# print (DP2) | p03181 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def solve():
N, MOD = list(map(int, input().split()))
adjL = [[] for _ in range(N)]
for _ in range(N-1):
x, y = list(map(int, input().split()))
x, y = x-1, y-1
adjL[x].append(y)
adjL[y].append(x)
dp = [[] for _ in range(N)]
outdegs = [0] * N
iPars = [-1] * N
def dfsDP(v, vPar):
outdeg = outdegs[v] = len(adjL[v])
dp[v] = [0] * outdeg
res = 1
for i, v2 in enumerate(adjL[v]):
if v2 == vPar:
iPars[v] = i
continue
dp[v][i] = dfsDP(v2, v)
res = res * dp[v][i] % MOD
return (res + 1) % MOD
anss = [0] * N
def dfsAns(v, vPar, resPar):
if vPar != -1:
dp[v][iPars[v]] = resPar
outdeg = outdegs[v]
dpL = [1] * (outdeg+1)
for i in range(outdeg):
v2 = adjL[v][i]
dpL[i+1] = dpL[i] * dp[v][i] % MOD
dpR = [1] * (outdeg+1)
for i in reversed(list(range(outdeg))):
v2 = adjL[v][i]
dpR[i] = dpR[i+1] * dp[v][i] % MOD
anss[v] = dpL[-1]
for i, v2 in enumerate(adjL[v]):
if v2 == vPar: continue
dfsAns(v2, v, (dpL[i] * dpR[i+1] + 1) % MOD)
dfsDP(0, -1)
dfsAns(0, -1, 0)
print(('\n'.join(map(str, anss))))
solve()
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
N, MOD = list(map(int, input().split()))
adjL = [[] for _ in range(N)]
for _ in range(N-1):
x, y = list(map(int, input().split()))
x, y = x-1, y-1
adjL[x].append(y)
adjL[y].append(x)
def ReRooting(adjL):
def merge(val1, val2):
return val1 * val2 % MOD
def calcValue(val1):
return (val1 + 1) % MOD
numV = len(adjL)
vRoot = 0
useds = [False] * numV
useds[vRoot] = True
vs = [vRoot]
pars = [-1] * numV
stack = [vRoot]
while stack:
v = stack.pop()
for v2 in adjL[v]:
if not useds[v2]:
useds[v2] = True
vs.append(v2)
pars[v2] = v
stack.append(v2)
anss = [0] * numV
dpUpFrom, dpDownTo, accLs, accRs = [1]*numV, [1]*numV, [1]*numV, [1]*numV
for v in reversed(vs):
vPar = pars[v]
tmp = 1
for v2 in adjL[v]:
if v2 == vPar: continue
accLs[v2] = tmp
tmp = merge(tmp, dpUpFrom[v2])
tmp = 1
for v2 in reversed(adjL[v]):
if v2 == vPar: continue
accRs[v2] = tmp
tmp = merge(tmp, dpUpFrom[v2])
anss[v] = tmp
dpUpFrom[v] = calcValue(tmp)
for v in vs:
vPar = pars[v]
dpDownToV = dpDownTo[v]
anss[v] = merge(anss[v], dpDownToV)
for v2 in adjL[v]:
if v2 == vPar: continue
tmp = merge(accLs[v2], accRs[v2])
tmp = merge(tmp, dpDownToV)
dpDownTo[v2] = calcValue(tmp)
return anss
anss = ReRooting(adjL)
print(('\n'.join(map(str, anss))))
| p03181 |
import sys
sys.setrecursionlimit(1000000)
def dfs1(u, pu):
dp[u] = 1
for v in tree[u]:
if v != pu:
dfs1(v, u)
dp[u] *= (dp[v] + 1)
dp[u] %= MOD
def dfs2(u, pu, pval):
resp[u] = (dp[u] * pval) % MOD
chlds = [v for v in tree[u] if v != pu]
cumulr = [1] * len(chlds)
for i in range(len(chlds) - 2, -1, -1):
cumulr[i] = cumulr[i + 1] * (1 + dp[chlds[i + 1]]) % MOD
pref = pval
for i in range(len(chlds)):
v = chlds[i]
vval = (1 + pref * cumulr[i]) % MOD
dfs2(v, u, vval)
pref *= (dp[v] + 1)
pref %= MOD
n, MOD = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = [int(u) - 1 for u in input().split()]
tree[u].append(v)
tree[v].append(u)
dp = [0] * n
resp = [0] * n
dfs1(0, -1)
dfs2(0, -1, 1)
for i in range(n):
print((resp[i]))
|
n, MOD = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = [int(u) - 1 for u in input().split()]
tree[u].append(v)
tree[v].append(u)
cola = [(0, -1)]
qind = 0
while qind < len(cola):
u, pu = cola[qind]
qind += 1
for v in tree[u]:
if v != pu:
cola.append((v, u))
dp = [1] * n
for i in range(n - 1, -1, -1):
u, pu = cola[i]
for v in tree[u]:
if v != pu:
dp[u] *= (dp[v] + 1)
dp[u] %= MOD
resp = [0] * n
pval = [1] * n
for j in range(n):
u, pu = cola[j]
resp[u] = (dp[u] * pval[u]) % MOD
chlds = [v for v in tree[u] if v != pu]
cumulr = [1] * len(chlds)
for i in range(len(chlds) - 2, -1, -1):
cumulr[i] = cumulr[i + 1] * (1 + dp[chlds[i + 1]]) % MOD
pref = pval[u]
for i in range(len(chlds)):
v = chlds[i]
pval[v] = (1 + pref * cumulr[i]) % MOD
pref *= (dp[v] + 1)
pref %= MOD
for i in range(n):
print((resp[i]))
| p03181 |
from functools import reduce
from itertools import accumulate,chain
def rerooting(N, adj, merge, identity, finalize):
"""
merge: (T,T) -> T, (T, merge)はモノイド
identity: 単位元
finalize: T -> T
以下の形で書けるdpは対応可能
dp[u,v] = finalize(merge(dp[v,k] for k in adj[v] if k != u))
ただし(u,v)は辺
"""
order = [None]*N
parent = [None]*N
parent[0] = -1
stack = [0]
for i in range(N):
v = stack.pop()
order[i] = v
for u in adj[v]:
if parent[u] is None:
parent[u] = v
stack.append(u)
# from leaf to parent
dp_down = [None]*N
for v in reversed(order[1:]):
p = parent[v]
dp_down[v] = finalize(reduce(merge,
(dp_down[c] for c in adj[v] if c != p),
identity))
# from parent to leaf
dp_up = [None]*N
dp_up[0] = identity
for v in order:
p = parent[v]
if len(adj[v]) == 1 and adj[v][0] == p:
continue
left = tuple(accumulate(
chain((dp_up[v],),(dp_down[u] for u in adj[v] if u != p)),
merge))
right = tuple(accumulate(
chain((identity,),(dp_down[u] for u in reversed(adj[v]) if u != p)),
merge))
i = 0
for u in adj[v]:
if u != p:
dp_up[u] = finalize(merge(left[i],right[-i-2]))
i += 1
for v,l in enumerate(adj):
order[v] = reduce(merge,
(dp_down[u] for u in adj[v] if u != parent[v]),
identity)
order[v] = finalize(merge(order[v], dp_up[v]))
return order
def solve(N,M,E):
adj = [[] for _ in range(N)]
for a,b in E:
adj[a].append(b)
adj[b].append(a)
def merge(x,y):
return (x*y)%M
def finalize(x):
return x+1
res = rerooting(N,adj,merge,1,finalize)
return [v-1 for v in res]
if __name__ == '__main__':
N,M = map(int,input().split())
E = [tuple(map(lambda x: int(x)-1, input().split())) for _ in range(N-1)]
print(*solve(N,M,E),sep='\n')
|
from functools import reduce
from itertools import accumulate,chain
def rerooting(N, adj, merge, identity, finalize):
"""
merge: (T,T) -> T, (T, merge)はモノイド
identity: 単位元
finalize: T -> T
以下の形で書けるdpは対応可能
dp[u,v] = finalize(merge(dp[v,k] for k in adj[v] if k != u))
ただし(u,v)は辺
"""
order = [None]*N
parent = [None]*N
parent[0] = -1
stack = [0]
for i in range(N):
v = stack.pop()
order[i] = v
for u in adj[v]:
if parent[u] is None:
parent[u] = v
stack.append(u)
# from leaf to parent
dp_down = [None]*N
for v in reversed(order[1:]):
p = parent[v]
dp_down[v] = finalize(reduce(merge,
(dp_down[c] for c in adj[v] if c != p),
identity))
# from parent to leaf
dp_up = [None]*N
dp_up[0] = identity
for v in order:
p = parent[v]
if len(adj[v]) == 1 and adj[v][0] == p:
continue
temp = (dp_up[v],)+tuple(dp_down[u] for u in adj[v] if u != p)+(identity,)
left = tuple(accumulate(temp,merge))
right = tuple(accumulate(reversed(temp),merge))
i = 0
for u in adj[v]:
if u != p:
dp_up[u] = finalize(merge(left[i],right[-i-3]))
i += 1
for v,l in enumerate(adj):
order[v] = reduce(merge,
(dp_down[u] for u in adj[v] if u != parent[v]),
identity)
order[v] = finalize(merge(order[v], dp_up[v]))
return order
def solve(N,M,E):
adj = [[] for _ in range(N)]
for a,b in E:
adj[a].append(b)
adj[b].append(a)
def merge(x,y):
return (x*y)%M
def finalize(x):
return x+1
res = rerooting(N,adj,merge,1,finalize)
return [v-1 for v in res]
if __name__ == '__main__':
N,M = map(int,input().split())
E = [tuple(map(lambda x: int(x)-1, input().split())) for _ in range(N-1)]
print(*solve(N,M,E),sep='\n')
| p03181 |
class Graph:
def __init__(self, n_vertices, edges, directed=True, weighted=False):
self.n_vertices = n_vertices
self.edges = edges
self.directed = directed
self.weighted = weighted
@property
def adj(self):
try:
return self._adj
except AttributeError:
adj = [[] for _ in range(self.n_vertices)]
def d_w(e):
adj[e[0]].append((e[1],e[2]))
def ud_w(e):
adj[e[0]].append((e[1],e[2]))
adj[e[1]].append((e[0],e[2]))
def d_uw(e):
adj[e[0]].append(e[1])
def ud_uw(e):
adj[e[0]].append(e[1])
adj[e[1]].append(e[0])
helper = (ud_uw, d_uw, ud_w, d_w)[self.directed+self.weighted*2]
for e in self.edges:
helper(e)
self._adj = adj
return adj
class RootedTree(Graph):
def __init__(self, n_vertices, edges, root_vertex):
self.root = root_vertex
super().__init__(n_vertices, edges, False, False)
@property
def parent(self):
try:
return self._parent
except AttributeError:
adj = self.adj
parent = [None]*self.n_vertices
parent[self.root] = -1
stack = [self.root]
for i in range(self.n_vertices):
v = stack.pop()
for u in adj[v]:
if parent[u] is None:
parent[u] = v
stack.append(u)
self._parent = parent
return parent
@property
def children(self):
try:
return self._children
except AttributeError:
children = [None]*self.n_vertices
for v,(l,p) in enumerate(zip(self.adj,self.parent)):
children[v] = [u for u in l if u != p]
self._children = children
return children
@property
def dfs_order(self):
try:
return self._dfs_order
except AttributeError:
order = [None]*self.n_vertices
children = self.children
stack = [self.root]
for i in range(self.n_vertices):
v = stack.pop()
order[i] = v
for u in children[v]:
stack.append(u)
self._dfs_order = order
return order
from functools import reduce
from itertools import accumulate,chain
def rerooting(rooted_tree, merge, identity, finalize):
"""
merge: (T,T) -> T, (T, merge)はモノイド
identity: 単位元
finalize: T -> T
以下の形で書けるdpは対応可能
dp[u,v] = finalize(merge(dp[v,k] for k in adj[v] if k != u))
ただし(u,v)は辺
"""
N = rooted_tree.n_vertices
parent = rooted_tree.parent
children = rooted_tree.children
order = rooted_tree.dfs_order
# from leaf to parent
dp_down = [None]*N
for v in reversed(order[1:]):
dp_down[v] = finalize(reduce(merge,
(dp_down[c] for c in children[v]),
identity))
# from parent to leaf
dp_up = [None]*N
dp_up[0] = identity
for v in order:
if len(children[v]) == 0:
continue
temp = (dp_up[v],)+tuple(dp_down[u] for u in children[v])+(identity,)
left = tuple(accumulate(temp,merge))
right = tuple(accumulate(reversed(temp[2:]),merge))
for u,l,r in zip(children[v],left,reversed(right)):
dp_up[u] = finalize(merge(l,r))
res = [None]*N
for v,l in enumerate(children):
res[v] = reduce(merge,
(dp_down[u] for u in children[v]),
identity)
res[v] = finalize(merge(res[v], dp_up[v]))
return res
def solve(N,M,E):
tree = RootedTree(N,E,0)
def merge(x,y):
return (x*y)%M
def finalize(x):
return x+1
res = rerooting(tree,merge,1,finalize)
return [v-1 for v in res]
if __name__ == '__main__':
N,M = map(int,input().split())
E = [tuple(map(lambda x: int(x)-1, input().split())) for _ in range(N-1)]
print(*solve(N,M,E),sep='\n')
| class Graph:
def __init__(self, n_vertices, edges, directed=True):
self.n_vertices = n_vertices
self.edges = edges
self.directed = directed
@property
def adj(self):
try:
return self._adj
except AttributeError:
adj = [[] for _ in range(self.n_vertices)]
if self.directed:
for u,v in self.edges:
adj[u].append(v)
else:
for u,v in self.edges:
adj[u].append(v)
adj[v].append(u)
self._adj = adj
return adj
class RootedTree(Graph):
def __init__(self, n_vertices, edges, root_vertex):
self.root = root_vertex
super().__init__(n_vertices, edges, False)
@property
def parent(self):
try:
return self._parent
except AttributeError:
adj = self.adj
parent = [None]*self.n_vertices
parent[self.root] = -1
stack = [self.root]
for _ in range(self.n_vertices):
v = stack.pop()
for u in adj[v]:
if parent[u] is None:
parent[u] = v
stack.append(u)
self._parent = parent
return parent
@property
def children(self):
try:
return self._children
except AttributeError:
children = [None]*self.n_vertices
for v,(l,p) in enumerate(zip(self.adj,self.parent)):
children[v] = [u for u in l if u != p]
self._children = children
return children
@property
def dfs_order(self):
try:
return self._dfs_order
except AttributeError:
order = [None]*self.n_vertices
children = self.children
stack = [self.root]
for i in range(self.n_vertices):
v = stack.pop()
order[i] = v
for u in children[v]:
stack.append(u)
self._dfs_order = order
return order
from functools import reduce
from itertools import accumulate,chain
def rerooting(rooted_tree, merge, identity, finalize):
"""
merge: (T,T) -> T, (T, merge)はモノイド
identity: 単位元
finalize: T -> T
以下の形で書けるdpは対応可能
dp[u,v] = finalize(merge(dp[v,k] for k in adj[v] if k != u), v)
ただし(u,v)は辺
"""
N = rooted_tree.n_vertices
parent = rooted_tree.parent
children = rooted_tree.children
order = rooted_tree.dfs_order
# from leaf to parent
dp_down = [None]*N
for v in reversed(order[1:]):
dp_down[v] = finalize(reduce(merge,
(dp_down[c] for c in children[v]),
identity), v)
# from parent to leaf
dp_up = [None]*N
dp_up[0] = identity
for v in order:
if len(children[v]) == 0:
continue
temp = (dp_up[v],)+tuple(dp_down[u] for u in children[v])+(identity,)
left = accumulate(temp[:-2],merge)
right = tuple(accumulate(reversed(temp[2:]),merge))
for u,l,r in zip(children[v],left,reversed(right)):
dp_up[u] = finalize(merge(l,r), v)
res = [None]*N
for v,l in enumerate(children):
res[v] = reduce(merge,
(dp_down[u] for u in children[v]),
identity)
res[v] = finalize(merge(res[v], dp_up[v]), v)
return res
def solve(N,M,E):
tree = RootedTree(N,E,0)
def merge(x,y):
return (x*y)%M
def finalize(x,v):
return x+1
res = rerooting(tree,merge,1,finalize)
return [v-1 for v in res]
if __name__ == '__main__':
N,M = map(int,input().split())
E = [tuple(map(lambda x: int(x)-1, input().split())) for _ in range(N-1)]
print(*solve(N,M,E),sep='\n')
| p03181 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.