์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |
- 2024-08-20
- ๊ฐ์ฒด์งํฅํ๋ก๊ทธ๋๋ฐ
- ์ฝ๋์
- http method
- Python
- menutab
- Factory Method Pattern
- AndroidStudio
- ์ฑ์ฉํ์ ํ
- ์ด๋ ธํ ์ด์
- url
- swagger
- udp
- URN
- datepicker
- OOP
- Kotlin
- Dialog
- FACTORY
- IOC
- reflection
- 2024-08-21
- uri
- ํ๋ IT&E
- ๊ธฐ์ด100์
- Android Studio
- tcp
- fontstyle
- di
- OpenAPI
dingdong coding
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ๋ณธ๋ฌธ
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ
๐ถ ๊ฐ๋ฐ๊ฐ๋ฐ ๐พ 2022. 4. 29. 14:10
• ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ : ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ์ ํ ์ฌ์ฉ์ฌ์ฌ ์ํ ์๊ฐ์ ๋น์ฝ์ ์ผ๋ก ์ฆ๊ฐ์ํค๋ ๋ฐฉ๋ฒ
• ์ด๋ฏธ ๊ณ์ฐ๋ ๊ฒฐ๊ณผ(์์ ๋ฌธ์ )๋ ๋ณ๋์ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ ์ฅํ์ฌ ๋ค์ ๊ณ์ฐํ์ง ์๋๋ก ํ๋ค.
• ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๊ตฌํ์ ์ผ๋ฐ์ ์ผ๋ก ๋ ๊ฐ์ง ๋ฐฉ์(ํ๋ค์ด, ๋ณดํ ์ )์ผ๋ก ๊ตฌ์ฑ๋๋ค.
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๋์ ๊ณํ๋ฒ์ด๋ผ๊ณ ๋ ๋ถ๋ฅธ๋ค.
์ผ๋ฐ์ ์ธ ํ๋ก๊ทธ๋๋ฐ ๋ถ์ผ์์ ๋์ (Dynamic)์ด๋
: ์๋ฃ๊ตฌ์กฐ์์ ๋์ ํ ๋น(Dynamic Allocation)์ 'ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ ๋์ค์ ์คํ์ ํ์ํ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ ๊ธฐ๋ฒ'
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์์ '๋ค์ด๋๋ฏน'์ ๋ณ๋ค๋ฅธ ์๋ฏธ์์ด ์ฌ์ฉ๋ ๋จ์ด
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๋ค์ ์กฐ๊ฑด์ ๋ง์กฑํ ๋ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.
1. ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ (Optimal Substructure)
: ํฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋ ์ ์์ผ๋ฉฐ ์์ ๋ฌธ์ ์ ๋ต์ ๋ชจ์์ ํฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
2. ์ค๋ณต๋๋ ๋ถ๋ถ ๋ฌธ์ (Overlapping Subproblem)
: ๋์ผํ ์์ ๋ฌธ์ ๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ํด๊ฒฐํด์ผ ํ๋ค.
ex) ํผ๋ณด๋์น ์์ด
๋ฉ๋ชจ์ด์ ์ด์ (Memoization)
: ๋ฉ๋ชจ์ด์ ์ด์ ์ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ ์ค ํ๋
: ํ ๋ฒ ๊ณ์ฐํ ๊ฒฐ๊ณผ๋ฅผ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ฉ๋ชจํ๋ ๊ธฐ๋ฒ
• ๊ฐ์ ๋ฌธ์ ๋ฅผ ๋ค์ ํธ์ถํ๋ฉด ๋ฉ๋ชจํ๋ ๊ฒฐ๊ณผ๋ฅผ ๊ทธ๋๋ก ๊ฐ์ ธ์จ๋ค.
• ๊ฐ์ ๊ธฐ๋กํด ๋๋๋ค๋ ์ ์์ ์บ์ฑ(Caching)์ด๋ผ๊ณ ๋ ํ๋ค.
• ํ๋ค์ด(๋ฉ๋ชจ์ด์ ์ด์ ) ๋ฐฉ์์ ํํฅ์์ด๋ผ๊ณ ๋ ํ๋ฉฐ ๋ณดํ ์ ๋ฐฉ์์ ์ํฅ์์ด๋ผ๊ณ ๋ ํ๋ค.
• ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ์ ํ์ ์ธ ํํ๋ ๋ณดํ ์ ๋ฐฉ์
• ๊ฒฐ๊ณผ ์ ์ฅ์ฉ ๋ฆฌ์คํธ๋ DP ํ ์ด๋ธ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค.
• ์๋ฐํ ๋งํ๋ฉด ๋ฉ๋ชจ์ด์ ์ด์ ์ ์ด์ ์ ๊ณ์ฐ๋ ๊ฒฐ๊ณผ๋ฅผ ์ผ์์ ์ผ๋ก ๊ธฐ๋กํด ๋๋ ๋์ ๊ฐ๋ ์ ์๋ฏธ
• ๋ฐ๋ผ์ ๋ฉ๋ชจ์ด์ ์ด์ ์ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๊ตญํ๋ ๊ฐ๋ ์ ์๋๋ค.
• ํ ๋ฒ ๊ณ์ฐ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ด์๋๊ธฐ๋ง ํ๊ณ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ์ํด ํ์ฉํ์ง ์์ ์๋ ์๋ค.
• ์ฃผ์ด์ง ๋ฌธ์ ๊ฐ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ์ ํ์์ ํ์ ํ๋ ๊ฒ์ด ์ค์ํ๋ค.
• ๊ฐ์ฅ ๋จผ์ ๊ทธ๋ฆฌ๋, ๊ตฌํ, ์์ ํ์ ๋ฑ์ ์์ด๋์ด๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋์ง ๊ฒํ ํ ์ ์๋ค.
• ๋ค๋ฅธ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํ์ด ๋ฐฉ๋ฒ์ด ๋ ์ค๋ฅด์ง ์์ผ๋ฉด ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๊ณ ๋ คํด๋ณด์
• ์ผ๋จ ์ฌ๊ทํจ์๋ก ๋นํจ์จ์ ์ธ ์์ ํ์ ํ๋ก๊ทธ๋จ์ ์์ฑํ ๋ค์ (ํ๋ค์ด) ์์ ๋ฌธ์ ์์ ๊ตฌํ ๋ต์ด ํฐ ๋ฌธ์ ์์ ๊ทธ๋๋ก ์ฌ์ฉ๋ ์ ์์ผ๋ฉด, ์ฝ๋๋ฅผ ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ์ ์๋ค.
• ์ผ๋ฐ์ ์ธ ์ฝ๋ฉ ํ ์คํธ ์์ค์์๋ ๊ธฐ๋ณธ ์ ํ์ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ๋ฌธ์ ๊ฐ ์ถ์ ๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
** ์ ํ์ ์ธ์๋ณด๊ธฐ **
1. 1๋ก ๋ง๋ค๊ธฐ (์ค์ ๋ฌธ์ )
2. ๊ฐ๋ฏธ์ ์ฌ (์ค์ ๋ฌธ์ )
3. ๋ฐ๋ฅ๊ณต์ฌ (์ค์ ๋ฌธ์ )
4. ํจ์จ์ ์ธ ํํ๊ตฌ์ฑ (์ค์ ๋ฌธ์ )
[ ์ค์ ๋ฌธ์ ] 1๋ก ๋ง๋ค๊ธฐ
โป ๋ฌธ์
์ ์ X๊ฐ ์ฃผ์ด์ง ๋ ์ ์ X์ ์ฌ์ฉํ ์ ์๋ ์ฐ์ฐ์ 4๊ฐ์ง์ด๋ค.
a. X๊ฐ 5๋ก ๋๋์ด๋จ์ด์ง๋ฉด, 5๋ก ๋๋๋ค.
b. X๊ฐ 3์ผ๋ก ๋๋์ด๋จ์ด์ง๋ฉด, 3์ผ๋ก ๋๋๋ค.
c. X๊ฐ 2๋ก ๋๋์ด๋จ์ด์ง๋ฉด, 2๋ก ๋๋๋ค.
d. X์์ 1์ ๋บ๋ค.
์ ์ X๊ฐ ์ฃผ์ด์ก์ ๋, ์ฐ์ฐ 4๊ฐ๋ฅผ ์ ์ ํ ์ฌ์ฉํด์ 1์ ๋ง๋ค๋ ค๊ณ ํ๋ค.
์ฐ์ฐ์ ์ฌ์ฉํ๋ ํ์์ ์ต์๊ฐ์ ์ถ๋ ฅํ์์ค.
์๋ฅผ ๋ค์ด ์ ์๊ฐ 26์ด๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ณ์ฐํด์ 3๋ฒ์ ์ฐ์ฐ์ด ์ต์๊ฐ์ด๋ค.
1. 26 - 1 = 25 (d)
2. 25 / 5 = 5 (a)
3. 5 / 5 = 1 (a)
์ ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ์ ์ X๊ฐ ์ฃผ์ด์ง๋ค. ( 1≤X≤30,000 )
์ถ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ์ฐ์ฐ์ ํ๋ ํ์์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
# 1๋ก ๋ง๋ค๊ธฐ
x = int(input())
# ์์ ๊ณ์ฐ๋ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ DP ํ
์ด๋ธ ์ด๊ธฐํ
d = [0] * 3001
# ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ(Dynamic Programming) ์งํ (๋ณดํ
์
)
for i in range(2, x + 1):
# ํ์ฌ์ ์์์ 1์ ๋นผ๋ ๊ฒฝ์ฐ
d[i] = d[i - 1] + 1
# ํ์ฌ์ ์๊ฐ 2๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฒฝ์ฐ
if i % 2 == 0:
d[i] = min(d[i], d[i // 2] + 1)
# ํ์ฌ์ ์๊ฐ 3์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฒฝ์ฐ
if i % 3 == 0:
d[i] = min(d[i], d[i // 3] + 1)
# ํ์ฌ์ ์๊ฐ 5๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฒฝ์ฐ
if i % 5 == 0:
d[i] = min(d[i], d[i // 5] + 1)
print(d[x])
[ ์ค์ ๋ฌธ์ ] ๊ฐ๋ฏธ ์ ์ฌ
โป ๋ฌธ์
๊ฐ๋ฏธ ์ ์ฌ๋ ๋ถ์กฑํ ์๋์ ์ถฉ๋นํ๊ณ ์ ๋ฉ๋๊ธฐ ๋ง์์ ์๋์ฐฝ๊ณ ๋ฅผ ๋ชฐ๋ ๊ณต๊ฒฉํ๋ ค๊ณ ํ๋ค. ๋ฉ๋๊ธฐ ๋ง์์๋ ์ฌ๋ฌ ๊ฐ์ ์๋ ์ฐฝ๊ณ ๊ฐ ์๋๋ฐ ์๋์ฐฝ๊ณ ๋ ์ผ์ง์ ์ผ๋ก ์ด์ด์ ธ ์๋ค. ๊ฐ ์๋์ฐฝ๊ณ ์๋ ์ ํด์ง ์์ ์๋์ ์ ์ฅํ๊ณ ์์ผ๋ฉฐ ๊ฐ๋ฏธ ์ ์ฌ๋ ์๋ ์ฐฝ๊ณ ๋ฅผ ์ ํ์ ์ผ๋ก ์ฝํํ๋ ค ์๋์ ๋นผ์์ ์์ ์ด๋ค.
์ด๋ ๋ฉ๋๊ธฐ ์ ์ฐฐ๋ณ๋ค์ ์ผ์ง์ ์์ ์กด์ฌํ๋ ์๋์ฐฝ๊ณ ์ค์์ ์๋ก ์ธ์ ํ ์๋์ฐฝ๊ณ ๊ฐ ๊ณต๊ฒฉ๋ฐ์ผ๋ฉด ๋ฐ๋ก ์์์ฑ ์ ์๋ค. ๋ฐ๋ผ์ ๊ฐ๋ฏธ ์ ์ฌ๊ฐ ์ ์ฐฐ๋ณ์๊ฒ ๋คํค์ง ์๊ณ ์๋์ฐฝ๊ณ ๋ฅผ ์ฝํํ๊ธฐ ์ํด์๋ ์ต์ํ ํ ์นธ ์ด์ ๋จ์ด์ง ์๋ ์ฐฝ๊ณ ๋ฅผ ์ฝํํด์ผ ํ๋ค. ์๋ฅผ ๋ค์ด ์๋ํ๊ณ 4๊ฐ๊ฐ ๋ค์๊ณผ ๊ฐ์ด ์กด์ฌํ๋ค๊ณ ๊ฐ์ ํ์.
{ 1, 3, 1, 5 }
์ด ๋ ๊ฐ๋ฏธ ์ ์ฌ๋ ๋ ๋ฒ์งธ ์๋์ฐฝ๊ณ ์ ๋ค ๋ฒ์งธ ์๋ ์ฐฝ๊ณ ๋ฅผ ์ ์ฑ ํ์ ๋ ์ต๋๊ฐ์ธ ์ด 8๊ฐ์ ์๋์ ๋นผ์์ ์ ์๋ค. ๊ฐ๋ฏธ ์ ์ฌ๋ ์๋์ฐจ๊ณ ๊ฐ ์ด๋ ๊ฒ ์ผ์ง์ ์์ผ ๋ ์ต๋ํ ๋ง์ ์๋์ ์ป๊ธฐ๋ฅผ ์ํ๋ค.
๊ฐ๋ฏธ ์ ์ฌ๋ฅผ ์ํด ์๋์ฐฝ๊ณ N๊ฐ์ ๋ํ ์ ๋ณด๊ฐ ์ฃผ์ด์ก์ ๋ ์ป์ ์ ์๋ ์๋์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ์๋์ฐฝ๊ณ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. ( 3≤N≤100 )
- ๋์งธ ์ค์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ๊ฐ ์๋์ฐฝ๊ณ ์ ์ ์ฅ๋ ์๋์ ๊ฐ์ K๊ฐ ์ฃผ์ด์ง๋ค. ( 0≤K≤1,000 )
์ถ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ๊ฐ๋ฏธ ์ ์ฌ๊ฐ ์ป์ ์ ์๋ ์๋์ ์ต๋๊ฐ์ ์ถ๋ ฅํ์์ค.
# ๊ฐ๋ฏธ ์ ์ฌ
# ์ ์ N์ ์
๋ ฅ๋ฐ๊ธฐ
n = int(input())
# ๋ชจ๋ ์๋ ์ ๋ณด ์
๋ ฅ๋ฐ๊ธฐ
k = list(map(int, input().split()))
# ์์ ๊ณ์ฐ๋ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ DP ํ
์ด๋ธ ์ด๊ธฐํ
d = [0] * 100
# ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ (Dynamic Programming) ์งํ (๋ณดํ
์
)
d[0] = k[0]
d[1] = max(k[0], k[1])
for i in range (2, n):
d[i] = max(d[i-1], d[i-2] + k[i])
# ๊ณ์ฐ๋ ๊ฒฐ๊ณผ ์ถ๋ ฅ
print(d[n-1])
[ ์ค์ ๋ฌธ์ ] ๋ฐ๋ฅ ๊ณต์ฌ
โป ๋ฌธ์
๊ฐ๋ก์ ๊ธธ์ด๊ฐ N, ์ธ๋ก์ ๊ธธ์ด๊ฐ 2์ธ ์ง์ฌ๊ฐํ ํํ์ ์์ ๋ฐ๋ฅ์ด ์๋ค. ํ์ผ์ด๋ ์ด ์์ ๋ฐ๋ฅ์ 1 X 2์ ๋ฎ๊ฐ, 2 X 1์ ๋ฎ๊ฐ, 2 X 2์ ๋ฎ๊ฐ๋ฅผ ์ด์ฉํด ์ฑ์ฐ๊ณ ์ ํ๋ค.
์ด๋ ๋ฐ๋ฅ์ ์ฑ์ฐ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์๋ฅผ ๋ค์ด 2 X 3 ํฌ๊ธฐ์ ๋ฐ๋ฅ์ ์ฑ์ฐ๋ ๊ฒฝ์ฐ์ ์๋ 5๊ฐ์ง ์ด๋ค.
์ ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์๋ N์ด ์ฃผ์ด์ง๋ค. ( 0≤N≤1,000 )
์ถ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ 2 X N ํฌ๊ธฐ์ ๋ฐ๋ฅ์ ์ฑ์ฐ๋ ๋ฐฉ๋ฒ์ ์๋ฅผ 796,796์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ์ถ๋ ฅํ๋ค.
n = int(input())
d = [0] * 1001
d[1] = 1
d[2] = 3
for i in range(3, n+1):
d[i] = (d[i-1] + 2 * d[i-2]) % 796796
# ๊ณ์ฐ๋ ๊ฒฐ๊ณผ ์ถ๋ ฅ
print(d[n])
[ ์ค์ ๋ฌธ์ ] ํจ์จ์ ์ธ ํํ ๊ตฌ์ฑ
โป ๋ฌธ์
N๊ฐ์ง ์ข ๋ฅ์ ํํ๊ฐ ์๋ค. ์ด ํํ๋ค์ ๊ฐ์๋ฅผ ์ต์ํ์ผ๋ก ์ด์ฉํด์ ๊ทธ ๊ฐ์น์ ํฉ์ด M์์ด ๋๋๋ก ํ๋ ค๊ณ ํ๋ค.
์ด๋ ๊ฐ ํํ๋ ๋ช ๊ฐ๋ผ๋ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ์ฌ์ฉํ ํํ์ ๊ตฌ์ฑ์ ๊ฐ์ง๋ง ์์๋ง ๋ค๋ฅธ ๊ฒ์ ๊ฐ์ ๊ฒฝ์ฐ๋ก ๊ตฌ๋ถํ๋ค.
์๋ฅผ ๋ค์ด 2์, 3์ ๋จ์์ ํํ๊ฐ ์์ ๋๋ 15์์ ๋ง๋ค๊ธฐ ์ํด 3์์ 5๊ฐ ์ฌ์ฉํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ต์ํ์ ๊ฐ์์ด๋ค.
์ ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์๋ N, M์ด ์ฃผ์ด์ง๋ค. ( 1≤N≤100, 1≤M≤10,000 )
- ์ดํ N๊ฐ์ ์ค์๋ ๊ฐ ํํ์ ๊ฐ์น๊ฐ ์ฃผ์ด์ง๋ค. ํํ ๊ฐ์น๋ 10,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ M์์ ๋ง๋ค๊ธฐ ์ํ ์ต์ํ์ ํํ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
- ๋ถ๊ฐ๋ฅํ ๋๋ -1์ ์ถ๋ ฅํ๋ค.
# ํจ์จ์ ์ธ ํํ ๊ตฌ์ฑ
# ์ ์ N, M์ ์
๋ ฅ๋ฐ๊ธฐ
n, m = map(int, input().split())
# N๊ฐ์ ํํ ๋จ์ ์ ๋ณด๋ฅผ ์
๋ ฅ๋ฐ๊ธฐ
array = []
for i in range(n):
array.append(int(input()))
# ํ ๋ฒ ๊ณ์ฐ๋ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ DP ํ
์ด๋ธ ์ด๊ธฐํ
d = [10001] * (m + 1) # ๊ฐ์น์ ํฉ + 1 : ์ธ๋ฑ์ค 0 ํฌํจ
# ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ(Dynamic Programming) ์งํ (๋ณดํ
์
)
d[0] = 0
for i in range(n): # ํํ ์ข
๋ฅ์ ์
for j in range(array[i], m + 1): # ํํ์ ์ข
๋ฅ ๋ถํฐ d ๋ฐฐ์ด์ ํฌ๊ธฐ ๋ฐ๋ณต ๊ฐ์น์ ํฉ + 1
if d[j - array[i]] != 10001: # (i-k)์์ ๋ง๋๋ ๋ฐฉ๋ฒ์ด ์กด์ฌํ๋ ๊ฒฝ์ฐ
d[j] = min(d[j], d[j - array[i]] + 1)
# ๊ณ์ฐ๋ ๊ฒฐ๊ณผ ์ถ๋ ฅ
if d[m] == 10001: # ์ต์ข
์ ์ผ๋ก M์์ ๋ง๋๋ ๋ฐฉ๋ฒ์ด ์๋ ๊ฒฝ์ฐ
print(-1)
else:
print(d[m])
๊ฐ์ ๋ฐ ์ถ์ฒ
'๐ตCoding Test > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ๊ธฐํ ๊ทธ๋ํ ์ด๋ก (0) | 2022.06.15 |
---|---|
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ์ต๋จ ๊ฒฝ๋ก (0) | 2022.05.02 |
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ์ด์ง ํ์ (0) | 2022.03.23 |
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ์ ๋ ฌ (0) | 2022.03.23 |
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] DFS/BFS (0) | 2022.03.21 |