๋ฐ์ํ
์ปดํจํฐ๋ฅผ ํ์ฉํด๋ ์ด๋ ค์ด ๋ฌธ์
- ์ต์ ์ ํด๋ฅผ ๊ตฌํ๊ธฐ์ ์๊ฐ์ด ๋งค์ฐ ๋ง์ด ํ์ํ ๋ฌธ์
- ์ต์ ์ ํด๋ฅผ ๊ตฌํ๊ธฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ๋งค์ฐ ๋ง์ด ํ์ํ ๋ฌธ์
์ปดํจํฐ๋ ์ฐ์ฐ ์๋์ ํ๊ณ๊ฐ ์๊ณ , ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฌ์ฉํ ์ ์๋ ๋ฐ์ดํฐ์ ๊ฐ์๋ ํ์ ์ ์ด๋ผ ๋ง์ ์ ์ฝ ๋ฐ์
โ ์ฐ์ฐ ์๋์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ต๋ํ์ผ๋ก ํ์ฉํ ์ ์๋ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ ์์ฑ ํ์
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ(Dynamic Programming)
- ๋์ ๊ณํ๋ฒ
- ํฐ ๋ฌธ์ ๋ฅผ ์๊ฒ ๋๋๊ณ , ๊ฐ์ ๋ฌธ์ ๋ผ๋ฉด ํ ๋ฒ์ฉ๋ง ํ์ด ๋ฌธ์ ๋ฅผ ํจ์จ์ ์ผ๋ก ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ฒ
- ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฝ๊ฐ ๋ ์ฌ์ฉํ๋ฉด ์ฐ์ฐ ์๋๋ฅผ ๋น์ฝ์ ์ผ๋ก ์ฆ๊ฐ์ํฌ ์ ์๋ ๋ฐฉ๋ฒ
- ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๋ค์ ์กฐ๊ฑด์ ๋ง์กฑํ ๋๋ง ์ฌ์ฉ ๊ฐ๋ฅ
- ํฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋ ์ ์๋ค.
- ์์ ๋ฌธ์ ์์ ๊ตฌํ ์ ๋ต์ ๊ทธ๊ฒ์ ํฌํจํ๋ ํฐ ๋ฌธ์ ์์๋ ๋์ผํ๋ค
๋ถํ ์ ๋ณต(Divide and Conquer) ์๊ณ ๋ฆฌ์ฆ๊ณผ ์ฐจ์ด์
=> ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๋ฌธ์ ๋ค์ด ์๋ก ์ํฅ์ ๋ฏธ์น๊ณ ์์
๋ฉ๋ชจ์ด์ ์ด์ (Memoization) ๊ธฐ๋ฒ
- ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ ์ค ํ ์ข ๋ฅ
- ๊ฐ์ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ด๋ฏ๋ก ์บ์ฑ(Caching)์ด๋ผ๊ณ ๋ ํจ
- ํ๋ฒ ๊ตฌํ ๊ฒฐ๊ณผ๋ฅผ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ฉ๋ชจํด๋๊ณ ๊ฐ์ ์์ ๋ค์ ํธ์ถํ๋ฉด ๋ฉ๋ชจํ ๊ฒฐ๊ณผ๋ฅผ ๊ทธ๋๋ก ๊ฐ์ ธ์ค๋ ๊ธฐ๋ฒ
ํ๋ค์ด(Top-Down) ๋ฐฉ์
- ์ฌ๊ท ํจ์๋ฅผ ์ด์ฉํ์ฌ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ์์ค์ฝ๋๋ฅผ ์์ฑํ๋ ๋ฐฉ๋ฒ
- ํฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์์ ๋ฌธ์ ๋ฅผ ํธ์ถ
๋ณดํ ์ (Botton-Up) ๋ฐฉ์
- ๋จ์ํ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํ์ฌ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ์์ค์ฝ๋๋ฅผ ์์ฑํ๋ ๋ฐฉ๋ฒ
- ์์ ๋ฌธ์ ๋ถํฐ ์ฐจ๊ทผ์ฐจ๊ทผ ๋ต์ ๋์ถ
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ๋ฌธ์
1๋ก ๋ง๋ค๊ธฐ
์ ์ X๊ฐ ์ฃผ์ด์ง ๋ ์ ์ X์ ์ฌ์ฉํ ์ ์๋ ์ฐ์ฐ์ ๋ค์๊ณผ ๊ฐ์ด 4๊ฐ์ง์ด๋ค.
1. X๊ฐ 5๋ก ๋๋์ด ๋จ์ด์ง๋ฉด, 5๋ก ๋๋๋ค.
2. X๊ฐ 3์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ฉด, 3์ผ๋ก ๋๋๋ค.
3. X๊ฐ 2๋ก ๋๋์ด ๋จ์ด์ง๋ฉด, 2๋ก ๋๋๋ค.
4. X์์ 1์ ๋บ๋ค.
์ ์ X๊ฐ ์ฃผ์ด์ก์ ๋, ์ฐ์ฐ 3๊ฐ๋ฅผ ์ ์ ํ ์ฌ์ฉํด์ 1์ ๋ง๋ค๋ ค๊ณ ํ๋ค. ์ฐ์ฐ์ ์ฌ์ฉํ๋ ํ์์ ์ต์๊ฐ์ ์ถ๋ ฅํ์์ค.
let x = Int(readLine()!)!
var d: [Int] = Array(repeating: 0, count: 30001)
//๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ์งํ(๋ณดํ
์
)
for i in 2..<(x+1){
d[i] = d[i-1] + 1
if i%2 == 0{
d[i] = min(d[i], d[i/2]+1)
}
if i%3 == 0{
d[i] = min(d[i], d[i/3]+1)
}
if i%5 == 0{
d[i] = min(d[i], d[i/5]+1)
}
}
print(d[x])
๊ฐ๋ฏธ ์ ์ฌ
๊ฐ๋ฏธ ์ ์ฌ๋ ๋ถ์กฑํ ์๋์ ์ถฉ๋นํ๊ณ ์ ๋ฉ๋๊ธฐ ๋ง์์ ์๋์ฐฝ๊ณ ๋ฅผ ๋ชฐ๋ ๊ณต๊ฒฉํ๋ ค๊ณ ํ๋ค.
๋ฉ๋๊ธฐ ๋ง์์๋ ์ฌ๋ฌ ๊ฐ์ ์๋์ฐฝ๊ณ ๊ฐ ์๋๋ฐ ์๋์ฐฝ๊ณ ๋ ์ผ์ง์ ์ผ๋ก ์ด์ด์ ธ ์๋ค.
๊ฐ ์๋์ฐฝ๊ณ ์๋ ์ ํด์ง ์์ ์๋์ ์ ์ฅํ๊ณ ์์ผ๋ฉฐ, ๊ฐ๋ฏธ ์ ์ฌ๋ ์๋์ฐฝ๊ณ ๋ฅผ ์ ํ์ ์ผ๋ก ์ฝํํ์ฌ ์๋์ ๋นผ์์ ์์ ์ด๋ค.
์ด๋ ๋ฉ๋๊ธฐ ์ ์ฐฐ๋ณ๋ค์ ์ผ์ง์ ์์ ์กด์ฌํ๋ ์๋์ฐฝ๊ณ ์ค์์ ์๋ก ์ธ์ ํ ์๋์ฐฝ๊ณ ๊ฐ ๊ณต๊ฒฉ๋ฐ์ผ๋ฉด ๋ฐ๋ก ์์์ฑ ์ ์๋ค.
๋ฐ๋ผ์ ๊ฐ๋ฏธ ์ ์ฌ๊ฐ ์ ์ฐฐ๋ณ์๊ฒ ๋คํค์ง ์๊ณ ์๋์ฐฝ๊ณ ๋ฅผ ์ฝํํ๊ธฐ ์ํด์๋ ์ต์ํ ํ ์นธ ์ด์ ๋จ์ด์ง ์๋์ฐฝ๊ณ ๋ฅผ ์ฝํํด์ผ ํ๋ค.
๊ฐ๋ฏธ ์ ์ฌ๋ฅผ ์ํด ์๋์ฐฝ๊ณ N๊ฐ์ ๋ํ ์ ๋ณด๊ฐ ์ฃผ์ด์ก์ ๋ ์ป์ ์ ์๋ ์๋์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
i ๋ฒ์งธ ์๋์ฐฝ๊ณ ์ ์๋ ์๋์ด k๋ผ๊ณ ํ์ ๋, ์ ํ์์ ๋ค์๊ณผ ๊ฐ๋ค.
$$a_{i} = max(a_{i-1}, a_{i-2}+k_{i})$$var n = Int(readLine()!)!
var arr = readLine()!.split(separator: " ").map{Int(String($0))!}
var d: [Int] = Array(repeating: 0, count: 100)
d[0] = arr[0]
d[1] = max(arr[0],arr[1])
for i in 2..<n{
d[i] = max(d[i-1],d[i-2]+arr[i])
}
print(d[n-1])
๋ฐ๋ฅ ๊ณต์ฌ
๊ฐ๋ก์ ๊ธธ์ด๊ฐ N, ์ธ๋ก์ ๊ธธ์ด๊ฐ 2์ธ ์ง์ฌ๊ฐํ ํํ์ ์์ ๋ฐ๋ฅ์ด ์๋ค.
ํ์ผ์ด์ ์ด ์์ ๋ฐ๋ฅ์ 1x2์ ๋ฎ๊ฐ, 2x1์ ๋ฎ๊ฐ, 2x2์ ๋ฎ๊ฐ๋ฅผ ์ด์ฉํด ์ฑ์ฐ๊ณ ์ ํ๋ค.
์ด๋ ๋ฐ๋ฅ์ ์ฑ์ฐ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
- 2xN ๋ฐ๋ฅ์ ์ฑ์ฐ๋ ๋ฐฉ๋ฒ์ ์๋ฅผ 796,796์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ์ถ๋ ฅํ์์ค.
์ ๋ฌธ์ ์ ์ ํ์์ ๋ค์๊ณผ ๊ฐ๋ค.
$$ a_{i} = a_{i-1} + a_{i-2} * 2 $$var n = Int(readLine()!)!
var d: [Int] = Array(repeating: 0, count: 1001)
d[0] = 1
d[1] = 3
for i in 2..<n{
d[i] = (d[i-1]+d[i-2]*2) % 796796
}
print(d[n-1])
ํจ์จ์ ์ธ ํํ ๊ตฌ์ฑ
N๊ฐ์ง ์ข ๋ฅ์ ํํ๊ฐ ์๋ค. ์ด ํํ๋ค์ ๊ฐ์๋ฅผ ์ต์ํ์ผ๋ก ์ด์ฉํด์ ๊ทธ ๊ฐ์น์ ํฉ์ด M์์ด ๋๋๋ก ํ๋ ค๊ณ ํ๋ค.
์ด๋ ๊ฐ ํํ๋ ๋ช ๊ฐ๋ผ๋ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ์ฌ์ฉํ ํํ์ ๊ตฌ์ฑ์ ๊ฐ์ง๋ง ์์๋ง ๋ค๋ฅธ ๊ฒ์ ๊ฐ์ ๊ฒฝ์ฐ๋ก ๊ตฌ๋ถํ๋ค.
M์์ ๋ง๋๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ ๊ฒฝ์ฐ -1์ ์ถ๋ ฅํ๋ค.
๊ธ์ก i๋ฅผ ๋ง๋ค ์ ์๋ ์ต์ํ์ ํํ ๊ฐ์๋ฅผ a_i, ํํ์ ๋จ์๋ฅผ k๋ผ๊ณ ํ์ ๋ ์ ํ์์ ๋ค์๊ณผ ๊ฐ๋ค.
a_(i-k) ๋ ๊ธ์ก (i-k)๋ฅผ ๋ง๋ค ์ ์๋ ์ต์ํ์ ํํ ๊ฐ์์ด๋ค.
$$ a_{i} = min(a_{i}, a_{i-k} + 1) $$var inputdata = readLine()!.split(separator: " ").map{Int(String($0))!}
var n = inputdata[0], m = inputdata[1]
var arr = [Int]()
for _ in 0..<n{ arr.append(Int(readLine()!)!)}
var d: [Int] = Array(repeating: 10001, count: m+1)
d[0] = 0
for i in 1..<n{
for j in min(arr[i],m)...max(arr[i],m){
var index = j - arr[i] > 0 ? j - arr[i] : m + j - arr[i]
if d[index] != 10001{
d[j] = min(d[j], d[index]+1)
}
}
}
d[m] == 10001 ? print(-1) : print(d[m])
๋ฐ์ํ
'๐ Computer Science > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ํ ์๊ณ ๋ฆฌ์ฆ (0) | 2022.04.14 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ์ต๋จ ๊ฒฝ๋ก(Shortest Path) (0) | 2022.03.31 |
[์๊ณ ๋ฆฌ์ฆ] ์ด์ง ํ์(Binary Search) (0) | 2022.03.25 |
[์๊ณ ๋ฆฌ์ฆ] ์ ๋ ฌ(Sorting) (0) | 2022.03.24 |
[์๊ณ ๋ฆฌ์ฆ] DFS/ BFS (0) | 2022.03.23 |