intro
๐ ฐ๏ธ ๋ถํ ์ ๋ณต(divide & conquer)์ ๋ณต์กํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ ์ฌ๋ฌ ์ฌ์ด ๋ฌธ์ ๋ค๋ก ์ชผ๊ฐ์ ํด๊ฒฐํ๋ ์ ๊ทผ๋ฒ. ์ ์์ ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ตฌํ๋ ๊ณผ์ ์์ ๋ถํ ์ ๋ณต ๊ธฐ๋ฒ์ ํ์ฉํด ๋ ํจ์จ์ ์ธ ์๊ฐ ๋ด์ ์งํํ ์ ์๋ค.
'์ค์ a์ ์์ด ์๋ ์ ์ x์ ๋ํด a^x๋ฅผ ๊ตฌํ๋ ๋ฌธ์ '
โ x = 1์ด๋ฉด ๋ต์ a๋ก ์ง์ ํด๊ฒฐ
→ ์๊ฐ๋ณต์ก๋ O(1)
โก x > 1์ด๋ฉด sub-problems๋ก ์ชผ๊ฐ๊ธฐ.
๐ ฐ๏ธ x๊ฐ ์ง์๋ผ๋ฉด a^(x/2) x a^(x/2)
๐ ฐ๏ธ x๊ฐ ํ์๋ผ๋ฉด a^((x-1)/2) x a^ ((x-1)/2) x a
→ ์๊ฐ๋ณต์ก๋ T(x) = T(x/2) + O(1). ์ฆ T(x) = O(logx)
example 7^10
๐ ฐ๏ธ ์๋ฅผ ๋ค์ด 7^10์ ๊ตฌํ๋ ๋ฌธ์ ๊ฐ ์๋ค๊ณ ํ์. ๋ ๊ฐ์ง ์ ๊ทผ๋ฒ์ผ๋ก ๋๋์ด๋ณผ ์ ์๋๋ฐ,
โ 7์ 10๋ฒ ๊ณฑํ๋ ์ฐ์ฐ. ๊ณฑ์ ํ์ 10๋ฒ ์นด์ดํธ (7x7x7x7x7x7x7x7x7x7)
โก ์ง์์ธ 10์ ๋ฐ์ 2๋ก ํ๋ log ์ฐ์ฐ์ผ๋ก ์ชผ๊ฐ์ด ๋ถํ ์ ๋ณต์ ์ด์ฉํ ๊ฑฐ๋ญ์ ๊ณฑ์ผ๋ก ๊ตฌํ๋ ์ฐ์ฐ
→ โ ์ ์๊ฐ ์ด๊ณผ / โก๋ ์๊ฐ ๋ณต์ก๋ O(log2(์ง์)) ์ด๋ฏ๋ก ์ง์๊ฐ 1์กฐ๋ฅผ ๋์ด๋ ๊น์ด๊ฐ 40์ ๋์ง ์๋๋ค. ์ฆ, ์๋ฅผ ๋ค์ด 7์ 1์ต์น๋ ์ฝ๊ฒ ๊ณ์ฐํ ์ ์๋ค๋ ๋ป
→ 7์ 10์น์ ๊ตฌํด๋ณด์. ์ง์์ธ 10์ ์ง์์ด๋ฏ๋ก 7์ 5์น์ ์ ๊ณฑํ ๊ฒ. ๋ฐ๋ผ์ 7์ 5์น์ ํ ๋ฒ ๊ตฌํ๋ฉด ๊ตฌํ ๊ฒฐ๊ณผ๋ฅผ ํ ๋ฒ ๋ ๊ณฑํด์ฃผ๊ธฐ๋ง ํ๋ฉด ๋๋ค. 7์ 5์น์ ํ ๋ฒ ๋ ๊ตฌํ ํ์๊ฐ ์๋ค. ๊ทธ๋ฌ๋ฉด 7์ 5์น์ ๊ตฌํ๊ธฐ ์ํด ์ด์ 7์ 2์น์ ๊ตฌํ๋ฉด ๋๋ค. 7์ 2์น์ ๊ตฌํ๋ฉด ๊ตฌํ ๊ฒฐ๊ณผ๋ฅผ ํ ๋ฒ ๋ ๊ณฑํ๊ณ 7๋ง ๊ณฑํด์ฃผ๋ฉด ๋๋ค. ๊ทธ ๋ค์ 7์ 2์น์ ๊ตฌํ๊ธฐ ์ํด 7์ 1์น์ ๊ตฌํ๋ฉด ๋๋ค. 7์ 1์น์ ๊ตฌํ๋ฉด ๊ตฌํ ๊ฒฐ๊ณผ์ ํ ๋ฒ ๋ ๊ณฑํด์ฃผ๋ฉด ๋๋ค. ์ด ๋ 7์ 1์น์์ ์ง์๊ฐ 1์ด๋ฏ๋ก recursion ์ข ๋ฃํ๊ณ 7์ 1์น ๋ฆฌํดํด์ฃผ๋ฉด ๋๋ค.
→ ์ด๋ ๊ฒ ์ฌ๊ท์ ์ผ๋ก ํฐ problem์ ์ง์๊ฐ ํ์์ธ์ง ์ง์์ธ์ง์ ๋ฐ๋ผ sub-problem์ผ๋ก ๋ถํ ํ๊ณ , ๋ถํ ๋ sub-problem์ ํด๊ฒฐํด๋๊ฐ๋ฉด์ ๋ค์ ์๋ก ์ฌ๋ผ๊ฐ๋(recursion) 'divide & conquer' ์ ํ์ผ๋ก ๋งค์ฐ ๋น ๋ฅด๊ฒ O(logn)) (n์ ์ง์) ์๊ฐ๋ณต์ก๋๋ก ํ ์ ์๋ค.
→ ์๋ ํ์ด์ฌ ์ฝ๋ ์ฐธ์กฐ(a์ b์ ๊ณฑ ๊ตฌํ๊ธฐ)
def get_power(a,b):
if b == 1:
return a
x = get_power(a,b//2)
if b % 2 == 0:
return x * x
else:
return x * x * a
+ modulo operation
modulo multiplication property
๐ ฐ๏ธ ๋ค๋ง, a์ b์ ๊ณฑ ๊ฒฐ๊ณผ๊ฐ b๊ฐ ๋งค์ฐ ํด ๊ฒฝ์ฐ, ์ปดํจํฐ๊ฐ ํฐ ์๋ฅผ ๋ํ๋ด๊ธฐ์ ๊ฐ๋นํ์ง ๋ชปํ๋ค. ์ด ๋, modulo ์ฐ์ฐ, ์ฆ ๋งค์ฐ ํฐ ์๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์ ํ์ผ๋ก ๋๋ถ๋ถ ์ถ์ . ์ด ๋ ๋ชจ๋๋ฌ ๊ณฑ์ ์ฐ์ฐ ์ฑ์ง(modulo multiplication property)์ ์์์ผ ํ๋ค.
ex) ์ฆ, 10์ 3์ผ๋ก ๋๋ ๋๋จธ์ง๋ (5๋ฅผ 3์ผ๋ก ๋๋ ๋๋จธ์ง) x (2๋ฅผ 3์ผ๋ก ๋๋ ๋๋จธ์ง)์ ๋์ผ. 3๊ฐ ์ด์์ ์๋ฅผ ๊ณฑํ ๊ฒฐ๊ณผ์ modulo opertation๋ ๋์ผํ ๊ณผ์ ์ผ๋ก ์งํ๋๋ค. 30์ 7๋ก ๋๋ ๋๋จธ์ง๋ ์๋ฅผ ๋ค์ด (3์ 7๋ก ๋๋ ๋๋จธ์ง) x (2๋ฅผ 7๋ก ๋๋ ๋๋จธ์ง) x (5๋ฅผ 7๋ก ๋๋ ๋๋จธ์ง)์ด๋ค.
modulo addition / subtraction property
๐ ฐ๏ธ ๋ชจ๋๋ก ๊ณฑ์ ์ฑ์ง์ ์ด์ด ๋ง์ / ๋บ์ ์ฑ์ง๋ ๋์ผํ๋ค.
+ ์ถ๊ฐ๋ก ๋ชจ๋๋ก ๊ณฑ์ ์ญ์(modular inverse), ์ฆ ๋๋์ ๊ด๋ จ ๋ชจ๋๋ก ์ฑ์ง์ ํ๋ฅด๋ง์ ์์ ๋ฆฌ์ ํจ๊ป ์ฌ๋ฌ ์ฑ์ง์ ๊ฒฐํฉํด์ ์ฐ์ฐ ํด์ผ ํ๋ค. ๋ณ๋ ํฌ์คํ ์ฐธ์กฐ
a^b (mod c)
๐ ฐ๏ธ ์ modulo property์ ์ํด a์ b์ ๊ณฑ์ c๋ก ๋๋ ๋๋จธ์ง์ ๋ํด ๊ตฌํด๋ณด์
def get_power(a,b,c):
if b == 1:
return a%c
x = get_power(a,b//2,c)
if b % 2 == 0:
return ((x%c) * (x%c)) % c
else:
return ((x%c) * (x%c) * (a%c))%c
: ์ ์ฝ๋์์ %c(divisor)๋ฅผ ํญ๋ง๋ค ํด์ฃผ์ด์ modulo multiplication property์ ์ํด ๋จ์ํ ๊ณฑํด์ฃผ๋ฉด ๋๋ค.
Power by Divide & Conquer exercises
examples
โ <BOJ S1 1629 ๊ณฑ์ > โ
: ์ ์์ ์ฝ๋์ ๊ทธ๋๋ก ๋์ผ. A^B์ C๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๋ถํ ์ ๋ณต ๊ธฐ๋ฒ์ ์ฌ์ฉํด ๊ตฌํ๋ ๋ฌธ์
โ <BOJ S1 11819 The Shortest does not Mean the Simplest> โ
: ์ 1629 ๊ณฑ์ ๋ฌธ์ ์ ๋์ผ ๋ฌธ์
โ <BOJ S3 13171 A> โ
: ๋ถํ ์ ๋ณต์ ์ด์ฉํ ๊ฑฐ๋ญ์ ๊ณฑ ๋ด์ฉ์ ๋ฌธ์ ์์ ๊ทธ๋๋ก ์ค๋ช ํด์ค. ์ ์ฝ๋ ๊ทธ๋๋ก ์ฌ์ฉํด A^B๋ฅผ 1,000,000,007๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ ๋ฌธ์
โ <BOJ G5 15717 ๋กํ์ด์ด> โ
: ๊ฐ์ง์๋ 2^(N-1)์์ ์๊ณ 2^(N-1)์ 10^9+7๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ ๋ฌธ์
'Computer Science > Algorithms' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๐ฃ Fibonacci Sequence (0) | 2024.06.26 |
---|---|
๐ฒ Divide&Conquer (1) | 2024.06.08 |
๐ฃ๏ธ Shortest Path in an Unweighted Graph (0) | 2024.05.23 |
โ Flood Fill (0) | 2024.05.19 |
๐๏ธEuler Sieve (1) | 2024.04.21 |
๋๊ธ