๋ฌธ์
ํผ๋ณด๋์น ์๋ 0๊ณผ 1๋ก ์์ํ๋ค. 0๋ฒ์งธ ํผ๋ณด๋์น ์๋ 0์ด๊ณ , 1๋ฒ์งธ ํผ๋ณด๋์น ์๋ 1์ด๋ค. ๊ทธ ๋ค์ 2๋ฒ์งธ ๋ถํฐ๋ ๋ฐ๋ก ์ ๋ ํผ๋ณด๋์น ์์ ํฉ์ด ๋๋ค.
์ด๋ฅผ ์์ผ๋ก ์จ๋ณด๋ฉด Fn = Fn-1 + Fn-2 (n ≥ 2)๊ฐ ๋๋ค.
n=17์ผ๋ ๊น์ง ํผ๋ณด๋์น ์๋ฅผ ์จ๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597
n์ด ์ฃผ์ด์ก์ ๋, n๋ฒ์งธ ํผ๋ณด๋์น ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ n์ด ์ฃผ์ด์ง๋ค. n์ 20๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์ ๋๋ 0์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ n๋ฒ์งธ ํผ๋ณด๋์น ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ
ํด์ค ์ฝ๋
n = int(input())
def fib(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
print(fib(n))
๋ฌธ์
๋ธ๋ฃจํธํฌ์ค - 2798๋ฒ ๋ธ๋์ญ(๋ฐฑ์ค)
๋ธ๋ฃจํธ ํฌ์ค : Brute Force ๋ก์, ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํ์ํ๋ฉด์ ์๊ตฌ์กฐ๊ฑด์ ์ถฉ์กฑ๋๋ ๊ฒฐ๊ณผ๋ง์ ๊ฐ์ ธ์ค๋ ๋ฌธ์ ์ด๋ค
๋ธ๋ฃจํธํฌ์ค ์๊ณ ๋ฆฌ์ฆ์ ํน์ง์ ๋ชจ๋ ์์ญ์ ์ ์ฒด ํ์ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ ์ฒด ํ์ํ๋ ๋ฐฉ๋ฒ์ผ๋ก๋ ์ ํ ๊ตฌ์กฐ๋ฅผ ์ ์ฒด์ ์ผ๋ก ํ์ํ๋ ์์ฐจ ํ์,
๋น์ ํ ๊ตฌ์กฐ๋ฅผ ์ ์ฒด์ ์ผ๋ก ํ์ํ๋ ๊น์ด ์ฐ์ ํ์(DFS), ๋๋น ์ฐ์ ํ์(BFS) ์๋ค.
์นด์ง๋ ธ์์ ์ ์ผ ์ธ๊ธฐ ์๋ ๊ฒ์ ๋ธ๋์ญ์ ๊ท์น์ ์๋นํ ์ฝ๋ค. ์นด๋์ ํฉ์ด 21์ ๋์ง ์๋ ํ๋ ๋ด์์, ์นด๋์ ํฉ์ ์ต๋ํ ํฌ๊ฒ ๋ง๋๋ ๊ฒ์์ด๋ค. ๋ธ๋์ญ์ ์นด์ง๋ ธ๋ง๋ค ๋ค์ํ ๊ท์ ์ด ์๋ค.
ํ๊ตญ ์ต๊ณ ์ ๋ธ๋์ญ ๊ณ ์ ๊น์ ์ธ์ ์๋ก์ด ๋ธ๋์ญ ๊ท์น์ ๋ง๋ค์ด ์๊ทผ, ์ฐฝ์์ด์ ๊ฒ์ํ๋ ค๊ณ ํ๋ค.
๊น์ ์ธ ๋ฒ์ ์ ๋ธ๋์ญ์์ ๊ฐ ์นด๋์๋ ์์ ์ ์๊ฐ ์ฐ์ฌ ์๋ค. ๊ทธ ๋ค์, ๋๋ฌ๋ N์ฅ์ ์นด๋๋ฅผ ๋ชจ๋ ์ซ์๊ฐ ๋ณด์ด๋๋ก ๋ฐ๋ฅ์ ๋๋๋ค. ๊ทธ๋ฐ ํ์ ๋๋ฌ๋ ์ซ์ M์ ํฌ๊ฒ ์ธ์น๋ค.
์ด์ ํ๋ ์ด์ด๋ ์ ํ๋ ์๊ฐ ์์ N์ฅ์ ์นด๋ ์ค์์ 3์ฅ์ ์นด๋๋ฅผ ๊ณจ๋ผ์ผ ํ๋ค. ๋ธ๋์ญ ๋ณํ ๊ฒ์์ด๊ธฐ ๋๋ฌธ์, ํ๋ ์ด์ด๊ฐ ๊ณ ๋ฅธ ์นด๋์ ํฉ์ M์ ๋์ง ์์ผ๋ฉด์ M๊ณผ ์ต๋ํ ๊ฐ๊น๊ฒ ๋ง๋ค์ด์ผ ํ๋ค.
N์ฅ์ ์นด๋์ ์จ์ ธ ์๋ ์ซ์๊ฐ ์ฃผ์ด์ก์ ๋, M์ ๋์ง ์์ผ๋ฉด์ M์ ์ต๋ํ ๊ฐ๊น์ด ์นด๋ 3์ฅ์ ํฉ์ ๊ตฌํด ์ถ๋ ฅํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์นด๋์ ๊ฐ์ N(3 ≤ N ≤ 100)๊ณผ M(10 ≤ M ≤ 300,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ ์นด๋์ ์ฐ์ฌ ์๋ ์๊ฐ ์ฃผ์ด์ง๋ฉฐ, ์ด ๊ฐ์ 100,000์ ๋์ง ์๋ ์์ ์ ์์ด๋ค.
ํฉ์ด M์ ๋์ง ์๋ ์นด๋ 3์ฅ์ ์ฐพ์ ์ ์๋ ๊ฒฝ์ฐ๋ง ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ M์ ๋์ง ์์ผ๋ฉด์ M์ ์ต๋ํ ๊ฐ๊น์ด ์นด๋ 3์ฅ์ ํฉ์ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ
ํด์ค ์ฝ๋
์ฒซ๋ฒ์งธ ๋ฐ๋ ์๋ ์ ์ฒด ์นด๋์ ๊ฐ์์ด๋ฉฐ,
๋ค์์ผ๋ก ๋ฐ๋ ์๋ ์์ ๋ฐ์ ์์ ๊ฐ์ ๋ฆฌ๋ฐ์ ์ ํด์ฃผ๋ ๊ฐ์ด๋ฉฐ,
๋ค์์ผ๋ก ์ ์ฒด ์นด๋์ ๊ฐ์๋งํผ ์๋ฅผ ์ ๋ ฅํด์ค์ผํ๋ค **
๋ํ ์์ ๋์จ ์๋ค์ค์ 3๊ฐ๋ฅผ ์กฐํฉํ์ฌ ํฉ์ด ๊ฐ์ฅ ๊ทผ์ ํ ๊ฒ๋ค์
๊ฒฐ๊ณผ๊ฐ์ผ๋ก ๋ฝ์์ค์ผ ํ๋ค.
์ฆ 3๊ฐ์ง ์ ๋์ ์ผ์ ํด์ผํ๋ค
n, m = map(int, input().split()) # ํ์ค์์ ๊ฐ์ด ๋ฐ๋ ์ฝ๋
card = list(map(int, input().split()))
res = set() # ์งํฉ์ผ๋ก ๋ฐ์ผ๋ฉฐ, ์ค๋ณต์ ํ๋ฝํ์ง ์๋๋ค
i = 0
while i < n-2: #0์ ์์, n=3์ธ ๊ฒฝ์ฐ 3๊ฐ๋ฅผ ๋ฝ๋ ๊ฒฝ์ฐ์ด๋ฏ๋ก, ์ ์ฒด ์นด๋ ์๊ฐ 3์ฅ์ด๋ฏ๋ก -> 1๋ฒ๋ง ๊ฐ๋ฅํ๋ค ์ฆ i < n-2๋ 0๋ง ๊ฐ๋ฅํ๋ค(๊ฐ๊ฑฐ๋ ์์ง ์์)
j = i + 1
while j < n-1:
k = j+1
while k < n :
if card[i] + card[j] + card[k] <= m:
res.add(card[i] + card[j] + card[k])
k += 1 # ๋๋จ๋ถํฐ ํ๋์ฉ ์ฌ๋ฆฌ๊ธฐ, ์ง์ญ๋ณ์๋ก ์ด์ฉ
j += 1 # ์ค๊ฐ ์๋ฆฌ์
i += 1
print(n,m)
print(res)
print(max(res))
print()
#1. sorted()
์ ๋ ฌ ๋ฉ์๋๋ก์, ํ๋ฒ ์ฌ์ฉํ๋ฉด ๋ค์ ๋๋ฆฌ์ง ๋ชปํ๋ค, ์งํฉ์ ๋ชฉ๋ก์ธ ๋ฆฌ์คํธ๋ก ๋ฐํํ๋ค
sorted๋ก ๋ฎ์ด์ ๊ฐ์ ์ถ๋ ฅํ๊ณ , ๋ค์ ๊ฐ์ ์ถ๋ ฅํ๋ฉด
๋ชฉ๋ก์ ๋ฆฌ์คํธ๋ก ๋ฐํํด์ ๋ฝ๋ ์ด์ง ๋ค๋ฅธ ๋ฐฉ๋ฒ
'๐๏ธ์ํํธ์จ์ด > ๐ปpython' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Python - ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ์ ๋ณต 2ํ (0) | 2022.04.20 |
---|---|
Python - ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ์ ๋ณตํ๊ธฐ 1ํ (0) | 2022.04.18 |
[๋ฐฑ์ค] 1978๋ฒ. ์์ ์ฐพ๊ธฐ (0) | 2022.04.08 |
[๋ฐฑ์ค] 1316๋ฒ. ๊ทธ๋ฃน ๋จ์ด ์ฒด์ปค (0) | 2022.04.08 |
[ํ๋ก๊ทธ๋๋จธ์ค/Programmers] ํคํจ๋ ๋๋ฅด๊ธฐ(ํ์ด์ฌ, C++) - 1ํ์ฐจ(์ด2ํ์ฐจ) (0) | 2022.01.05 |