์ ๋ฒ์๋ DP๋ก ์ต์ฅ ์ฆ๊ฐ ๋ถ๋ถ ์์ด (LIS)๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด์๋๋ฐ,
์ค๋์ DP๋ณด๋ค ํจ์ฌ ์๊ฐ๋ณต์ก๋๊ฐ ์ข์ ์ด๋ถ ํ์ (BS)๋ก ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ์ ๋ฆฌํด๋ณด๋ ค๊ณ ํ๋ค.
๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ์ฐจ์ด์ ๋ ์์๋ณด๊ณ , ์ด๋ถํ์์ผ๋ก LIS๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ๋ ๊ตฌํํด๋ณด์.
(LIS์ ๋ํ ์ค๋ช , ๊ทธ๋ฆฌ๊ณ DP๋ก LIS ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ด ๊ถ๊ธํ์ ๋ถ๋ค์ ์๊ธฐ๐๋ฅผ ์ฐธ๊ณ ํด์ฃผ์ธ์!)
๐ ์ด๋ถํ์์ผ๋ก ๊ตฌํ๋ LIS
LIS๋ฅผ DP๊ฐ ์๋ ์ด๋ถํ์์ผ๋ก ๊ตฌํ์ ๋์ ์๊ฐ๋ณต์ก๋ ์ฐจ์ด๋ฅผ ์์๋ณด๊ณ ,
์ด๋ถํ์์ผ๋ก ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ณด์.
๐ DP์์ ์๊ฐ๋ณต์ก๋ ์ฐจ์ด
์์ DP๋ก LIS๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ ๋ฆฌํ ํฌ์คํ ์์๋ ์ธ๊ธํ์ง ์์์ง๋ง,
DP๋ ์์ด์ ๋ชจ๋ ์์๋ง๋ค ์ด์ ์๋ค์ ๋น๊ตํด์ฃผ์ด์ผํ๋ฏ๋ก ์๊ฐ ๋ณต์ก๋๊ฐ O(N^2)์ด ๋๋ค.
๋ฐ๋ผ์ N์ด ์์ฃผ ์ปค์ง๋ค๋ฉด ๊ธ์์ ์ผ๋ก ์ปค์ง๋ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฒฝํํ ์ ์๋ค,,
์ ๋ ฅ์ด 100๋ง๊ฐ ์ ๋๋ง ๋๋๋ผ๋ ์คํ ์๊ฐ์ด 10์ด ์ด์ ๊ฑธ๋ฆฐ๋ค๊ณ ํ๋ค.
ํ์ง๋ง ์ด๋ถ ํ์์ O(log n)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ฏ๋ก,
BS๋ฅผ ์ด์ฉํด ๊ตฌํด์ค๋ค๋ฉด LIS๋ฅผ ๊ตฌํ๋ ์๊ฐ ๋ณต์ก๋๋ฅผ O(nlog n)์ผ๋ก ๊ฐ์ ํ ์ ์๋ค.
๐ ์ด๋ถํ์์ผ๋ก ๊ตฌํํ๊ธฐ
์ด๋ถํ์์ ์ด์ฉํ์ฌ LIS๋ฅผ ๊ตฌํ๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํํ๋ฅผ ์์ ๋ก ์์ฑํด๋ณด์๋ค.
import Foundation
let permu = [1, 3, 2, 5, 4, 6]
var lis = [Int]()
func BinarySearch(_ start: Int, _ end: Int, _ value: Int) -> Int {
var s = start // lis์ ์์ ์ธ๋ฑ์ค
var e = end // lis์ ๋งจ ๋ ์ธ๋ฑ์ค
var m = 0 // s์ m์ ์ค๊ฐ ์ธ๋ฑ์ค
while s < e {
m = (s + e) / 2
if value <= lis[m] { e = m }
else { s = m + 1 }
}
return s
}
for i in 0..<permu.count {
if lis.isEmpty { lis.append(permu[i]) }
else if lis.last! < permu[i] { lis.append(permu[i]) }
else { lis[BinarySearch(0, lis.count-1, permu[i])] = permu[i] }
}
print(lis.count)
๋ณ์ ์ค๋ช
- permu : ์ฃผ์ด์ง ์์ด
- lis : ์ต์ฅ ์ฆ๊ฐ ๋ถ๋ถ ์์ด์ ์ ์ฅํ๊ธฐ ์ํ ๋ฐฐ์ด
์ฝ๋ ์ค๋ช
- ์๋์ชฝ์ for๋ฌธ์ ๋ณด๋ฉด, ์์๋๋ก permu[i]๋ฅผ ๋ฃ์ lis์ ์ ์ ํ ์๋ฆฌ๋ฅผ ๊ฒฐ์ ํ๋ ์ญํ ์ ํ๋ค.
if, lis ๋ฐฐ์ด์ด ๋น์ด์์ ๊ฒฝ์ฐ lis์ ๋ง์ง๋ง์ permu[i]๋ฅผ ์ถ๊ฐํ๋๋ก ํด์ฃผ์๋ค.
else if, lis์ ๋ง์ง๋ง ์์๊ฐ permu[i]๋ณด๋ค ์์ ๊ฒฝ์ฐ ๋ง์ฐฌ๊ฐ์ง๋ก lis ๋ง์ง๋ง์ permu[i]๋ฅผ ์ถ๊ฐํ๋ค.
else, lis ๋ฐฐ์ด์ด ๋น์ด์์ง๋ ์๊ณ lis ๋ฐฐ์ด์ ๋ง์ง๋ง ์์๊ฐ permu[i]๋ณด๋ค ํด ๊ฒฝ์ฐ
BinarySearch ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ ํ ์ธ๋ฑ์ค๋ฅผ ์ฐพ๊ณ , lis์ ํด๋นํ๋ ์์น ์์๋ฅผ permu[i]๋ก ๊ฐฑ์ ํ๋ค. - BinarySearch ํจ์๋ start, end, value๋ฅผ ์ธ์๋ก ํ์๋ก ํ๋๋ฐ,
๊ฐ๊ฐ lis์ ์์ ์ธ๋ฑ์ค, ๋ ์ธ๋ฑ์ค, ๊ทธ๋ฆฌ๊ณ permu[i] ๊ฐ์ ์๋ฏธํ๋ค. - start์ end๋ ๊ฐ๊ฐ s์ e ๋ณ์์ ์ ์ฅํ๊ณ , m์ด๋ผ๋ ๋ณ์๋ฅผ 0์ผ๋ก ์ด๊ธฐํํ๋ค.
m ๋ณ์๋ ์ด๋ถํ์์ ํ๋ฉฐ ๊ณ์ ์ ๋ฐ์ดํธ ๋ s์ e์ ์ค๊ฐ ๊ฐ์ ์ ์ฅํ ์ฉ๋์ด๋ค. - while ๋ฐ๋ณต์ ํตํด ์ด๋ถํ์์ ํ๋๋ฐ, s๊ฐ e๋ณด๋ค ์์ ๋์ ๋ฐ๋ณตํ๋ค.
s์ e๋ฅผ ๋ํ ํ 2๋ก ๋๋์ด ์ค๊ฐ ๊ฐ์ ์ฐพ์ m ์ด๊ธฐํ, value๊ฐ lis[m]๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ
e๋ฅผ m์ผ๋ก ์ด๊ธฐํํ๊ณ , value๊ฐ ํด ๊ฒฝ์ฐ์๋ s๋ฅผ m+1๋ก ์ด๊ธฐํํ๋ค.
๐ ์ ๋ฆฌ
์ด๋ถํ์์ ์ด์ฉํ์ฌ LIS๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ดํดํ๊ณ , ์ฌ์ฉ ๋ฐฉ๋ฒ์ ๊ณต๋ถํ๋ค.
์ด์ ์๋ ๋ฌธ์ ๋ฅผ ํ๋ฉด์ ์ด๋ถํ์์ ๋ํ์ฌ ๊ณต๋ถํ ์ ์ ์์ง๋ง,์ด๋ ค์ด ๋ฌธ์ ๊ฐ ๋ฅ์ณค์ ๋๋ ์ด๋ถํ์์ ์ด๋ค ์์ผ๋ก ์ ์ฉํด์ผํ ์ง ๋ชฐ๋ผ์์ฉํ๊ธฐ๊ฐ ์ด๋ ค์ด ๊ฒ ๊ฐ๋ค. ์ฐ์ต์ด ๋ ํ์ํ ๊ฒ ๊ฐ๋ค.
'5๏ธโฃ CS > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java Algorithm Note] ์กฐํฉ (feat. ์ฌ๊ท) (0) | 2022.08.15 |
---|---|
[Java Algorithm Note] ์์ด (feat. ์ฌ๊ท) (0) | 2022.08.15 |
[Swift Algorithm Note] ์ต์ฅ ์ฆ๊ฐ ๋ถ๋ถ ์์ด (feat. DP) (0) | 2021.08.28 |
[Swift Algorithm Note] ๋์ ๊ณํ๋ฒ (feat. Fibonacci) (0) | 2021.08.28 |
[Swift Algorithm Note] ๊ผฌ๋ฆฌ ์ฌ๊ท ํจ์ (feat. Fibonacci) (0) | 2021.07.09 |
๋๊ธ