* intro
๐ป ๋ถํ (Divide)ํ๊ณ ์ ๋ณต(Conquer)ํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ถํ → ์ ๋ณต → ๊ฒฐํฉ ํฌ๊ฒ ์ธ ๋จ๊ณ๋ก ์งํ
๐ป
โ ๋ถํ (Divide): ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ๋ ์์ ์ฌ๋ฌ ๊ฐ์ sub-problem์ผ๋ก ๋ถํ ํ๋ค.
โก ์ ๋ณต(Conquer): ์ฌ๊ท์ ์ผ๋ก sub-problem๋ค์ ๊ฐ๊ฐ ํด๊ฒฐํ๋ค. ๋ฌธ์ ๋ค์ ๊ฐ๊ฐ ๋ ๋ฆฝ์ ์ผ๋ก ํด๊ฒฐ.
โข ๊ฒฐํฉ(Combine): ๊ฐ๊ฐ์ sub-problem ํด๊ฒฐ ๊ฒฐ๊ณผ๋ฅผ ๋ฌถ์ด ์ ์ฒด ๋ฌธ์ ์ ์ต์ข ์๋ฃจ์ ์ ๋์ถ!
๐ป ํฐ problem์ ์ฌ๋ฌ ๊ฐ์ sub-problem์ผ๋ก ๋๋๋ ๊ณผ์ ์์ recursion ์ฌ๊ท๊ฐ ์ฌ์ฉ๋๋ค. ๋ถํ ์ ์ฌ๊ท๋ก ๊ตฌํํ๋ฉด์ ๋๋๊ณ ๋ ์ด์ ๋๋ ์ ์๋ sub-problem ๊ฐ๊ฐ conquer(์ ๋ณต)ํ ๋ค์ ๊ฐ sub-problem๋ณ conquer๋ ๊ฒฐ๊ณผ๋ฅผ combine(๊ฒฐํฉ)ํด ์ต์ข ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ๋ฉด ๋๋ค.
๐ป ์ํฉ์ ๋ฐ๋ผ combine ๊ณผ์ ์์ด ์ผ๋ถ๋ง ๋ถํ ํ๊ณ ์ผ๋ถ๋ง ์ ๋ณตํ ๋ค ๋ฐ๋ก ์๋ฃํ๋ ์ ํ๋ ์กด์ฌ(combine ๊ฒฐํฉ์ด ๋ฐ๋์ ํฌํจ๋์ง๋ x)
* example
Q. Finding the maximum
๐ป ์ ์ผ ๊ฐ๋จํ, ์ฃผ์ด์ง ๋ฐฐ์ด์์ ์ต๋๊ฐ์ ์ฐพ๋ ๊ณผ์ ์ ์๊ฐํด๋ณด์. ์ผ๋จ Divide & Conquer ๋จ๊ณ์ ๋ง๊ฒ โ ๋จผ์ ๋งจ ์์ ๊ธด Array์์ ์ ๋ฐ์ผ๋ก ๋๋์ด๋๊ฐ๋ ๊ณผ์ Divide๋ฅผ ์๋์ ๊ฐ์ด ์งํํ๋ค. ๊ทธ ๋ค์ โก ๋ ์ด์ ๋๋ ์ ์์ ๋ ๋ถํฐ Conquer๋ฅผ ์์ํด์ โข ์๋ก ์ฌ๋ผ๊ฐ๋ฉฐ Combine์ ํด ๋๊ฐ๋ค.
(1) divide: ์ผ๋จ ์ ์ฒด list๋ฅผ ๊ธธ์ด๊ฐ 2 ๋๋ 1์ด ๋ ๋๊น์ง ์ ๋ฐ์ผ๋ก sub-problem์ผ๋ก ๋๋์ด ๋๊ฐ๋ค
(2) conquer: ์ต์ข ์ ์ผ๋ก ๋๋์ด์ง sub-problem์ ๊ฐ list์ ์ต๋๊ฐ์ ๊ตฌํ๋ค. ์ต๋๊ฐ์ ๊ตฌํ๋ ๊ฑด max() ์ฌ์ฉ ์์ด ๋ถ๋ฑ์์ผ๋ก ์งํ
(3) combine: ์ํฉ์ ๋ฐ๋ผ ๋ถํ ์ ๋ณต ๋ฌธ์ ์์ divide&conquer๋ง ์งํํ ์ ์๋ค. ํด๋น ๋ฌธ์ ๋ ๊ฐ๊ฐ conquer๋ ๊ฒฐ๊ณผ๋ฅผ combineํด ๋ค์ ์๋ก ์ฌ๋ผ๊ฐ๋ฉฐ ๋ conquerํ๊ณ combineํ๋ ๋ฐฉ์ ๊ณ์ ์งํ
def find_maximum(i,length):
if length <= 2:
if length == 1:
return l[i]
else:
if l[i] >= l[i+1]:
return l[i]
else:
return l[i+1]
if length%2 == 0:
left, right = find_maximum(i,length//2), find_maximum(i+length//2,length//2)
if left >= right:
return left
else:
return right
else:
left, right = find_maximum(i,length//2), find_maximum(i+length//2,length//2+1)
if left >= right:
return left
else:
return right
l = list(map(int,input('input your integers: ').split()))
print(find_maximum(0,len(l)))
* properties
โ ์ฆ, DP๋ ์ฌ๋ฌ sub-problem์ด ์๋ก ์ํฅ์ ๋ฏธ์น์ง๋ง(subproblems are evaluated many times), DAC๋ ์ฌ๋ฌ sub-problem์ด ์๋ก ์ํฅ์ ์ฃผ์ง ์๋๋ค(evaluated only once)
โก ํฐ ๊ณต๊ฐ ์์ด cache memory ํจ์จ์ ์ธ ์ฌ์ฉ
โข Quick Sort์ Merge Sort์ ์ฌ์ฉ๋๋ ๋ถํ -์ ๋ณต
โฃ ํฐ problem์ ์ฌ๋ฌ ๊ฐ์ sub-problems๋ก ๋๋ ๋ ๊ตฌํ์ด ์ด๋ ค์ด ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
โ ๋ถํ ์ ๋ณต์ผ๋ก sub-problem์ผ๋ก ์ฌ๋ฌ ๋ฒ ๋๋ ๋ ์ฌ๊ทํจ์ ๋ด์ ์ธ์๋ฅผ ์ด๋ป๊ฒ ์ค์ ํ ์ง ๊ณ ๋ฏผํ๊ณ , ์ฌ๊ท์ ์ผ๋ก ๋ฐ๋ณต๋๋ ๋ถ๋ถ์ ์ฐพ์๋ด์
* exercises
โ <BOJ S2 2630 ์์ข ์ด ๋ง๋ค๊ธฐ> โ
: ์ ์ฌ๊ฐํ์ ๋๋์ด์ ํ์ ์์ญ, ํ๋ ์์ญ ์์ข ์ด์ ๊ฐ์ ๊ตฌํ๋ฉด ๋๋ค.
โ <BOJ S2 1780 ์ข ์ด์ ๊ฐ์> โ
: 4๋ฑ๋ถ์ด ์๋ 9๋ฑ๋ถ์ผ๋ก divide
โ <BOJ S1 1074 Z> โ
: 4๋ฑ๋ถํด์ ์ฐพ๊ณ ์ ํ๋ ๊ณณ๋ง depth ๊ณ์ divideํ๊ณ conquerํ ๋ค ๋ฐ๋ก ์ถ๋ ฅํ๊ณ ์ข ๋ฃ
'Computer Science > Algorithms' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๐ซ Prefix Sum (1) | 2024.09.06 |
---|---|
๐ฃ Fibonacci Sequence (0) | 2024.06.26 |
๐ Power by Divide and Conquer (1) | 2024.06.06 |
๐ฃ๏ธ Shortest Path in an Unweighted Graph (0) | 2024.05.23 |
โ Flood Fill (0) | 2024.05.19 |
๋๊ธ