[BOJ][๐ก5][๋ฐฑ์ค#01011] Fly me to the Alpha Centauri
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
์ฐํ์ด๋ ์ด๋ฆฐ ์์ , ์ง๊ตฌ ์ธ์ ๋ค๋ฅธ ํ์ฑ์์๋ ์ธ๋ฅ๋ค์ด ์ด์๊ฐ ์ ์๋ ๋ฏธ๋๊ฐ ์ค๋ฆฌ๋ผ ๋ฏฟ์๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ๊ฐ ์ง๊ตฌ๋ผ๋ ์ธ์์ ๋ฐ์ ๋ด๋ ค ๋์ ์ง 23๋ ์ด ์ง๋ ์ง๊ธ, ์ธ๊ณ ์ต์ฐ์ ASNA ์ฐ์ฃผ ๋นํ์ฌ๊ฐ ๋์ด ์๋ก์ด ์ธ๊ณ์ ๋ฐ์ ๋ด๋ ค ๋๋ ์๊ด์ ์๊ฐ์ ๊ธฐ๋ค๋ฆฌ๊ณ ์๋ค. ๊ทธ๊ฐ ํ์นํ๊ฒ ๋ ์ฐ์ฃผ์ ์ Alpha Centauri๋ผ๋ ์๋ก์ด ์ธ๋ฅ์ ๋ณด๊ธ์๋ฆฌ๋ฅผ ๊ฐ์ฒํ๊ธฐ ์ํย ๋๊ท๋ชจ ์ํ ์ ์ง ์์คํ ์ ํ์ฌํ๊ณ ์๊ธฐ ๋๋ฌธ์, ๊ทธ ํฌ๊ธฐ์ ์ง๋์ด ์์ฒญ๋ ์ด์ ๋ก ์ต์ ๊ธฐ์ ๋ ฅ์ ์ด ๋์ํ์ฌ ๊ฐ๋ฐํ ๊ณต๊ฐ์ด๋ ์ฅ์น๋ฅผ ํ์ฌํ์๋ค. ํ์ง๋ง ์ด ๊ณต๊ฐ์ด๋ ์ฅ์น๋ ์ด๋ ๊ฑฐ๋ฆฌ๋ฅผ ๊ธ๊ฒฉํ๊ฒ ๋๋ฆด ๊ฒฝ์ฐ ๊ธฐ๊ณ์ ์ฌ๊ฐํ ๊ฒฐํจ์ด ๋ฐ์ํ๋ ๋จ์ ์ด ์์ด์, ์ด์ ์๋์๊ธฐ์ k๊ด๋ ์ ์ด๋ํ์์ ๋๋ k-1 , k ํน์ k+1 ๊ด๋ ๋ง์ ๋ค์ ์ด๋ํ ์ ์๋ค. ์๋ฅผ ๋ค์ด, ์ด ์ฅ์น๋ฅผ ์ฒ์ ์๋์ํฌ ๊ฒฝ์ฐ -1 , 0 , 1 ๊ด๋ ์ ์ด๋ก ์ ์ด๋ํ ์ ์์ผ๋ ์ฌ์ค์ ์์ ํน์ 0 ๊ฑฐ๋ฆฌ๋งํผ์ ์ด๋์ ์๋ฏธ๊ฐ ์์ผ๋ฏ๋ก 1 ๊ด๋ ์ ์ด๋ํ ์ ์์ผ๋ฉฐ, ๊ทธ ๋ค์์๋ 0 , 1 , 2 ๊ด๋ ์ ์ด๋ํ ์ ์๋ ๊ฒ์ด๋ค. ( ์ฌ๊ธฐ์ ๋ค์ 2๊ด๋ ์ ์ด๋ํ๋ค๋ฉด ๋ค์ ์๊ธฐ์ 1, 2, 3 ๊ด๋ ์ ์ด๋ํ ์ ์๋ค. )
๊น์ฐํ์ ๊ณต๊ฐ์ด๋ ์ฅ์น ์๋์์ ์๋์ง ์๋ชจ๊ฐ ํฌ๋ค๋ ์ ์ ์ ์๊ณ ์๊ธฐ ๋๋ฌธ์ x์ง์ ์์ย y์ง์ ์ ํฅํด ์ต์ํ์ ์๋ ํ์๋ก ์ด๋ํ๋ ค ํ๋ค. ํ์ง๋ง y์ง์ ์ ๋์ฐฉํด์๋ ๊ณต๊ฐ ์ด๋์ฅ์น์ ์์ ์ฑ์ ์ํ์ฌ y์ง์ ์ ๋์ฐฉํ๊ธฐ ๋ฐ๋ก ์ง์ ์ ์ด๋๊ฑฐ๋ฆฌ๋ ๋ฐ๋์ 1๊ด๋ ์ผ๋ก ํ๋ ค ํ๋ค. ๊น์ฐํ์ ์ํด x์ง์ ๋ถํฐ ์ ํํ y์ง์ ์ผ๋ก ์ด๋ํ๋๋ฐ ํ์ํ ๊ณต๊ฐ ์ด๋ ์ฅ์น ์๋ ํ์์ย ์ต์๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
์ ๋ ฅ
์ ๋ ฅ์ ์ฒซ ์ค์๋ ํ ์คํธ์ผ์ด์ค์ ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ๊ฐ์ ํ ์คํธ ์ผ์ด์ค์ ๋ํด ํ์ฌ ์์นย x ์ ๋ชฉํ ์์น y ๊ฐ ์ ์๋ก ์ฃผ์ด์ง๋ฉฐ, x๋ ํญ์ y๋ณด๋ค ์์ ๊ฐ์ ๊ฐ๋๋ค. (0 โค x < y < 231)
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ๋ํด x์ง์ ์ผ๋ก๋ถํฐ y์ง์ ๊น์ง ์ ํํ ๋๋ฌํ๋๋ฐ ํ์ํ ์ต์ํ์ย ๊ณต๊ฐ์ด๋ ์ฅ์น ์๋ ํ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์
์ ๋ ฅ
3
0 3
1 5
45 50
์ถ๋ ฅ
3
3
4
My Sol
tcs = int(input())
for tc in range(tcs):
A, B = map(int, input().split())
d = B-A
move = 0
flag = 0
v = 0
while d > 0:
if flag == 0:
v += 1
flag += 1
elif flag == 1:
flag -= 1
d -= v
move += 1
print(move)
๊ทธ๋ฆผ์ ์กฐ๊ธ์ฉ ๊ทธ๋ ค๋ณด๋ฉด ์ ์ ์๋ค.
์กฐ์กํ์ง๋ง ๋ด๊ฐ ๊ทธ๋ฆฐ ๊ทธ๋ฆผ์ด๋ค. ๋์ด๊ฐ๋ ์ด๋ ๊ฑฐ๋ฆฌ๋ ๊ณง ์ด๋ ์๋๋ผ๊ณ ์๊ฐํ๋ฉด ๋๊ณ , ์ฆ๊ฐ์ ๋จ์๋ 1์ด๋ฏ๋ก 1๋จ์์ ๋ธ๋ญ์ผ๋ก ์๊ฐํ ์ ์๋ค. ์ด๋ ์๋๋ ์ด๋ ๊ฑฐ๋ฆฌ์ ์ค๊ฐ์ฏค๊น์ง ๊ณ์ ๊ฐ์ํ๋ค๊ฐ ์ค๋ฐ๋ถํฐ๋ ์ค์ด๋ค์ด์ผ ๋์ฐฉํ ๋ 1์ ์๋๋ก ๋์ฐฉํ ์ ์๋ค.
์ฆ, x์ถ์ ์ต์ ์ด๋ ํ์์ด๊ณ , y์ถ์ ์๋์ด๋ค. ๊ทธ๋ ๋ค๋ฉด ์์์ง ๋ฉด์ ์? ์ค์ ์ด๋ ๊ฑฐ๋ฆฌ์ด๋ค. ์ฆ, ์ด ์์ด๋๊ฑฐ๋ฆฌ๊ฐ 15๊ฐ ๋์ด์ผ ํ๋ค๋ฉด, 1 2 3 3 3 2 1์ ์๋๋ก ์ด๋ํ ๊ฒ์ด๊ณ , ์ด 7๋ฒ ์ด๋ํ ๊ฒ์ด๋ค. ์ธต์ ๋์ด ์ฐจ์ด๊ฐ 1์ด ๋์ผ๋ฉด ์ ๋๋ฏ๋ก, ํผ๋ผ๋ฏธ๋์ ์ต๊ณ ์ธต์ ์์๋ค๋ฉด ๋ค์ ์ด๋ํ์๋ฅผ ํ ๋ฒ ์ฆ๊ฐ์์ผ ์์๊ฐ์ผ ํ๋ค๋ ๋ง์ด๋ค.
๊ทธ๋ ๋ค๋ฉด ์ด ์ด๋๊ฑฐ๋ฆฌ๋ฅผ ํ์๋ง๋ค ๋นผ์ฃผ๋ฉด์ ํ์๋ฅผ ๊ณ์ ์นด์ดํธํด๊ฐ๋ฉด ๋๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. ์๋(v)์ ์์ง์ ํ์(move)์ ๋ํ ๋ณ์๋ฅผ ๊ฐ๊ฐ ์ด๊ธฐํํ์๋ค. ์ค์ํ ๊ฒ์ ์ธต์ 1 1, 2 2, 3 3, ์ด๋ ๊ฒ ์์๊ฐ๋ฏ๋ก flag ๋ณ์๋ฅผ ์ค์ ํ์ฌ ์๋๋ฅผ ๋์ผ์ง ๋ง์ง๋ฅผ ๊ฒฐ์ ํ์๋ค. ๊ทธ๋ฆฌ๊ณ ์๋๋งํผ d๋ฅผ ๋นผ์ฃผ๊ณ ํ์๋ฅผ ๋๋ฆฌ๋ฉฐ ํด๋น ๋ฐ๋ณต์ ํ์ถํ๋ฉด ๋๋ค.
์๋์ ์๊ฐ ์์ ๊ทธ๋ํ์ ๋ฉด์ ์ด ๊ฑฐ๋ฆฌ๊ฐ ๋๋ค๋ ์ฌ์ค์ ์ด์ฉํ๋ค๋ฉด ์ฝ๊ฒ ์ ๊ทผํ ์ ์๋ ๋ฌธ์ ์๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
t = int(input())
for _ in range(t):
x, y = map(int,input().split())
distance = y - x
count = 0 # ์ด๋ ํ์
move = 1 # count๋ณ ์ด๋ ๊ฐ๋ฅํ ๊ฑฐ๋ฆฌ
move_plus = 0 # ์ด๋ํ ๊ฑฐ๋ฆฌ์ ํฉ
while move_plus < distance :
count += 1
move_plus += move # count ์์ ํด๋นํ๋ move๋ฅผ ๋ํจ
if count % 2 == 0 : # count๊ฐ 2์ ๋ฐฐ์์ผ ๋,
move += 1
print(count)
์ด๋ ๊ฒ ํ์์ ํ๋ํ๋ ์ฐ์ด๋ณด๋ฉด์ ์ด๋ ํ์๊ฐ ๋์ด๋๋ ๊ท์น์ ์ฐพ์ ์ฝ๋๋ก ํํํ์๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ