๐ก ์กฐ๊ฑด
- N๋ช
์ ์ฐธ๊ฐ์๋ ๋ฒํธ๊ฐ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ๋ฐฐ์ ๋ฐ๋๋ค.
๊ทธ๋ฌ๊ณ ๋ ํ์ ์๋ก ์ธ์ ํ ๋ฒํธ๋ผ๋ฆฌ ์คํ๋ฅผ ํ๋ค. ์ด๊ธด ์ฌ๋์ ๋ค์ ๋ผ์ด๋์ ์ง์ถํ๊ณ , ์ง ์ฌ๋์ ๊ทธ ๋ผ์ด๋์์ ๋จ์ด์ง๋ค.
- ๊ทธ ๋ผ์ด๋์ ์ฐธ๊ฐ์๊ฐ ํ์๋ช
์ด๋ผ๋ฉด, ๋ง์ง๋ง ๋ฒํธ๋ฅผ ๊ฐ์ง ์ฐธ๊ฐ์๋ ๋ค์ ๋ผ์ด๋๋ก ์๋ ์ง์ถํ๋ค. ๋ค์ ๋ผ์ด๋์์ ๋ค์ ์ฐธ๊ฐ์์ ๋ฒํธ๋ฅผ 1๋ฒ๋ถํฐ ๋งค๊ธด๋ค.
- ๋ฒํธ๋ฅผ ๋งค๊ธฐ๋ ์์๋ ์ฒ์ ๋ฒํธ์ ์์๋ฅผ ์ ์งํ๋ฉด์ 1๋ฒ๋ถํฐ ๋งค๊ธด๋ค.
์ด ๋ง์ 1๋ฒ๊ณผ 2๋ฒ์ด ์คํ๋ฅผ ํด์ 1๋ฒ์ด ์ง์ถํ๊ณ , 3๋ฒ๊ณผ 4๋ฒ์ด ์คํ๋ฅผ ํด์ 4๋ฒ์ด ์ง์ถํ๋ค๋ฉด, 4๋ฒ์ ๋ค์ ๋ผ์ด๋์์ ๋ฒํธ 2๋ฒ์ ๋ฐฐ์ ๋ฐ๋๋ค.
๋ฒํธ๋ฅผ ๋ค์ ๋ฐฐ์ ๋ฐ์ ํ์ ํ ๋ช
๋ง ๋จ์ ๋๊น์ง ๋ผ์ด๋๋ฅผ ๊ณ์ ํ๋ค.
- ์ผ๋จ ๊น์ง๋ฏผ๊ณผ ์ํ์๋ ์๋ก ๋๊ฒฐํ๊ธฐ ์ ๊น์ง ํญ์ ์ด๊ธด๋ค๊ณ ๊ฐ์ ํ๋ค.
1 ๋ผ์ด๋์์ ๊น์ง๋ฏผ์ ๋ฒํธ์ ์ํ์์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง ๋, ๊ณผ์ฐ ๊น์ง๋ฏผ๊ณผ ์ํ์๊ฐ ๋ช ๋ผ์ด๋์์ ๋๊ฒฐํ๋์ง ์ถ๋ ฅํ๋ ๋ฌธ์
- ์ฐธ๊ฐ์์ ์ N๊ณผ 1 ๋ผ์ด๋์์ ๊น์ง๋ฏผ์ ๋ฒํธ์ ์ํ์์ ๋ฒํธ๊ฐ ์์๋๋ก ์ฃผ์ด์ง๋ค.
N์ 2๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 100,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๊ณ , ๊น์ง๋ฏผ์ ๋ฒํธ์ ์ํ์์ ๋ฒํธ๋ N๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๊ณ , ์๋ก ๋ค๋ฅด๋ค.
์ฒซ์งธ ์ค์ ๊น์ง๋ฏผ๊ณผ ์ํ์๊ฐ ๋๊ฒฐํ๋ ๋ผ์ด๋ ๋ฒํธ๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ์๋ก ๋๊ฒฐํ์ง ์์ ๋๋ -1์ ์ถ๋ ฅํ๋ค.
- ๋ธ๋ฃจํธํฌ์ค ์๊ณ ๋ฆฌ์ฆ ์ ํ์ ๋ฌธ์
๐ฅ ์์ค ์ฝ๋
from sys import stdin, setrecursionlimit
setrecursionlimit(10 ** 6)
data = list(map(int, stdin.readline().split()))
team = [0 for _ in range(1, data[0] + 1)]
for i in data[1:]:
team[i - 1] = 1
def solve(round, length):
global team
temp = []
for i in range(0, length // 2 * 2, 2):
t1, t2 = i, i + 1
if team[t1] and team[t2]:
return round
elif team[t1] or team[t2]:
temp.append(1)
else:
temp.append(0)
if length % 2 != 0:
temp.append(team[-1])
team = temp[:]
if length % 2 != 0:
return solve(round + 1, length // 2 + 1)
else:
return solve(round + 1, length // 2)
print(solve(1, data[0]))
๐ ์์ ๋ฐ ์คํ๊ฒฐ๊ณผ
์์
65536 1000 35000
์คํ๊ฒฐ๊ณผ
16
โจ๏ธ ๋ฌธ์ ํ์ด
- ์ด ์ฐธ๊ฐ์์ ์๋งํผ team list ๋ฅผ ๋ง๋ ๋ค. ์ด ๋ฆฌ์คํธ์ ๊น์ง๋ฏผ๊ณผ ์ํ์์ ๋ฒํธ๋ฅผ ํ์ํ๋ค.
- solve ํจ์์์ ๊น์ง๋ฏผ๊ณผ ์ํ์์ผ ๋ temp ๋ฆฌ์คํธ์ 1์ ์ถ๊ฐํ๊ณ ์๋ ๊ฒฝ์ฐ, 0์ ์ถ๊ฐํ๋ค.
- ๋ถ์ ์น์ธ ๊ฒฝ์ฐ, ๋งจ ๋ง์ง๋ง ์ธ์์ temp์ ์ถ๊ฐํ๋ค.
- ์ ์ ๋ฐ์ผ๋ก ์ค์ด๋๋ ํ์ ์ฌ๊ท๋ก ๊ตฌํํด์ ์ํํ๋ค.
- team ๋ฆฌ์คํธ์ ๊ฐ์ด ๋ ๋ค 1 ์ด๋ฉด ๋ผ์ด๋๋ฅผ returnํ๋ค.