์๋
ํ์ธ์ Foma ๐ป ์
๋๋ค!
์ค๋์ ๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋์ธ ํฉ๋ณ ์ ๋ ฌ์ ๋ํด์ ์์๋ณด๋ ค๊ณ ํฉ๋๋ค.
๋ฐ๋ก ์์ํ ๊ฒ์~
๋ถํ ์ ๋ณต(Divide and Conquer Algorithm) ์๊ณ ๋ฆฌ์ฆ์ด๋? ๐ก
์์์ ํฉ๋ณ ์ ๋ ฌ์ ๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋๋ผ๊ณ ๋ง์๋๋ ธ๋๋ฐ์.
๊ทธ๋ ๋ค๋ฉด ๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ์ ๋ฌด์์ผ๊น์?
๋ง ๊ทธ๋๋ก ์ง๊ธ ํด๊ฒฐํ ์ ์๋ ๋ฌธ์ ๋ฅผ ์๊ฒ ์ชผ๊ฐ์(๋ถํ ) ํ์ด๋๊ฐ๋(์ ๋ณต) ๊ฒ์ ๋๋ค.
์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์ฌ ํฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด๋๊ฐ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ฌ๊ท ํจ์๋ฅผ ํตํด ์์ฐ์ค๋ฝ๊ฒ ๊ตฌํํ ์ ์์ต๋๋ค.
ํฉ๋ณ ์ ๋ ฌ์ด๋? ๐คผโ๏ธ
ํฉ๋ณ ์ ๋ ฌ ๋๋ ๋ณํฉ ์ ๋ ฌ์ ๋น๊ต ๊ธฐ๋ฐ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํํ์ ๋ ์ด ์ ๋ ฌ์ ์์ ์ ๋ ฌ์ ์ํ๋ฉฐ, ๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ์ ํ๋์ด๋ค.
์กด ํฐ ๋ ธ์ด๋ง์ด 1945๋ ์ ๊ฐ๋ฐํ๋ค. - ์ํค ๋ฐฑ๊ณผ -
๊ฐ๋จํ๊ฒ ์ค๋ช ๋๋ฆฌ๋ฉด, ์ ๋ ฌ๋์ง ์์ ๋ฆฌ์คํธ๋ฅผ 1๊ฐ๋ง ๋จ์ ๋๊น์ง ๋ฐ์ผ๋ก ๋ถํ ํ ๋ค์
๋๋ ์ง ๋ฆฌ์คํธ๋ค์ ์๋ก ๋น๊ตํ๋ฉฐ ํฉ์ณ๊ฐ๋ ์ ๋ ฌ ๋ฐฉ์์ ๋๋ค.
ํฉ๋ณ ์ ๋ ฌ ๊ณผ์
๋ง์ฝ 4,1,7,5,3,2,6 ์ด๋ ๊ฒ ์ ๋ ฌ๋์ง ์์ ์ซ์๋ค์ด ์๋ค๊ณ ๊ฐ์ ํ๊ฒ ์ต๋๋ค.
๋ถํ
๋จผ์ ์ด ์ซ์๋ค์ ๋ฐ๋๋ก ๋๋๋๋ค.
(4,1,7,5) - (3,2,6) ์ผ๋ก ๋๋ ์ง๊ฒ ์ฃ ?
์ด๋ ๊ฒ ๋๋ ์ง ์ซ์๋ค์ ํ๋๋ง ๋จ์ ๋๊น์ง ๋๋ ์ค๋๋ค.
(4,1) - (7,5) (3,2) - (6)
(4) - (1) (7)- (5) (3) - (2) (6) ์ด๋ ๊ฒ ๋๋ ์ง๊ฒ ์ฃ ?
ํฉ๋ณ
๋จผ์ ์ผ์ชฝ๋ถํฐ 4 ์ 1์ ๋น๊ตํด์ ๋ ์์ ์ซ์๋ฅผ ์ผ์ชฝ์ผ๋ก ํฉ์ณ์ค๋๋ค.
1,4 ๊ฐ ๋๊ฒ ์ฃ ?
์ด๋ ๊ฒ 2๊ฐ์ ์ซ์๋ฅผ ๋น๊ตํด์ ๋ ์์ ์ซ์๋ก ํฉ๋ณํด์ค๋๋ค.
(1,4) - (5,7) - (2,3) - (6)
๊ทธ ๋ค์ 2๊ฐ์ฉ ํฉ์ณ์ค ์ซ์๋ค์ ๋น๊ตํด์ ๋ ์์ ์ซ์๋ก ํฉ๋ณํด์ค๋๋ค.
1,4 ์ 5,7์ 1,4,5,7๋ก ํฉ์ณ์ค๋๋ค.
2,3 ๊ณผ 6์ 2,3,6์ผ๋ก ํฉ์ณ์ค๋๋ค.
๋ง์ง๋ง์ผ๋ก 1,4,5,7๊ณผ 2,3,6์ ํฉ์ณ์ฃผ๋ฉด 1,2,3,4,5,6,7 ๋ก ์ ๋ ฌ๋๊ฒ ๋ฉ๋๋ค.
์๋ ๊ทธ๋ฆผ์ผ๋ก ๋ณด์๋ฉด ์ดํด๊ฐ ํจ์ฌ ์ฝ๊ฒ ๋์ค๊ฑฐ์์.
์๊ฐ๋ณต์ก๋
์ฐ์ ๋ถํ ์ ํ ๋ N๊ฐ๋ฅผ 1๊ฐ์ฉ ๋จ์ ๋๊น์ง ๋ฐ์ผ๋ก ๋๋ ์ผํ๋ฏ๋ก logN์ ๋น์ฉ์ด ๋ค๊ฒ ์ฃ ?
๊ทธ๋ฆฌ๊ณ ํฉ์ณ์ง๋ ๊ณผ์ ์์ ๋ชจ๋ ์ซ์๋ฅผ ๋น๊ตํ์ฌ ๋ ์์ ์ซ์๋ก ํฉ์น๊ธฐ ๋๋ฌธ์ N๋ฒ์ ๋น์ฉ์ด ๋ญ๋๋ค.
๊ณ ๋ก ์๊ฐ๋ณต์ก๋๋ N * logN ์ฆ, NlogN ์ ๋๋ค.
์ฝ๋ ๊ตฌํ
์ด์ ์ด๋ก ์ ์ดํดํ์ผ๋ ์ฝ๋๋ก ์ง์ ๊ตฌํํด๋ด์ผ๊ฒ ์ฃ ?
์ ๋ ฌ๋์ง ์์ ์ซ์๋ค์ด ๋ด๊ธด numbers๋ฅผ ๋ง๋ค์ด์ค๋๋ค.
var numbers:[Int] = [4,1,7,5,3,2,6]
์ด์ ์ด numbers๋ฅผ ๋ฐ์ผ๋ก ๋๋์ด์ค์ผ๊ฒ ์ฃ ?
๋ง์ฝ 1๊ฐ๋ณด๋ค ์ ๋ค๋ฉด ๋ฐ์ผ๋ก ๋๋ ์ ์์ผ๋ฏ๋ก list๋ฅผ return ํด์ค๋๋ค.
2๊ฐ ์ด์์ด๋ผ๋ฉด left์ right๋ก ๋ฐ์ผ๋ก ๋๋ ์ค๋๋ค.
๊ทธ๋ฆฌ๊ณ merge๋ฅผ ํตํด์ ๋๋ ์ง left์ right๋ฅผ ํฉ์ณ์ค ๊ฒ์ return ํด์ค๋๋ค.
private func divide(_ list:[Element]) -> [Element] {
if list.count <= 1 { return list }
let mid:Int = list.count/2
let left:[Element] = Array(list[0..<mid])
let right:[Element] = Array(list[mid..<list.count])
return merge(divide(left), divide(right))
}
์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ์ ์ซ์๋ค์ ๋น๊ตํด์ฃผ๋ฉด์ ๋ ์์ ์ซ์๋ค๋ก ์๋ก์ด list๋ฅผ ๋ง๋ค์ด์ค๋๋ค.
๋ง์ฝ l์ด๋ r์ ๋จ์ ์ซ์๋ค์ด ์๋ค๋ฉด list์ ๋ชจ๋ ๋ฃ์ด์ฃผ๊ณ ๋ฐํํด์ค๋๋ค.
private func merge(_ left:[Element],_ right:[Element]) -> [Element] {
var l:[Element] = left
var r:[Element] = right
var list:[Element] = []
while !l.isEmpty && !r.isEmpty {
if l.first! < r.first! {
list.append(l.removeFirst())
}else {
list.append(r.removeFirst())
}
}
list.append(contentsOf: l+r)
return list
}
์ ์ฒด ์ฝ๋
'๐ฅ Computer Science > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algorithm] ํต ์ ๋ ฌ(Quick Sort)๋? (feat. Swift) (0) | 2021.10.25 |
---|---|
[Algorithm] ํ ์ ๋ ฌ(HeapSort)์ด๋? (feat.Swift) (0) | 2021.10.19 |
[Algorithm] ์๊ฐ๋ณต์ก๋(Time-Complexity)๋? (feat. Big O) (0) | 2021.09.29 |
[Algorithm] ์ฝ์ ์ ๋ ฌ(Insertion Sort) ์ด๋? (feat.Swift) (0) | 2021.09.28 |
[Algorithm] ๋ฐฑํธ๋ํน(Backtracking)์ด๋? (feat. ์์ ํฌํจ) (0) | 2021.08.28 |
๋๊ธ