์ ํด๋ฆฌ๋ ํธ์ ๋ฒ (์๊ณ ๋ฆฌ์ฆ)์ ์ธ๊ณ ์ต์ด์ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
์ด ์ธ๊ณ ์ต์ด ์๊ณ ๋ฆฌ์ฆ์ ์ด๋ค ๋์์ ํ๊ณ ์ด๋ค ๊ฒฐ๊ณผ๋ฅผ ๋ด๋์ง ์์๋ณด์.
์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ธ ๊ฒ
- ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ
- ์ต๋ ๊ณต์ฝ์
- ์ต์ ๊ณต๋ฐฐ์
- Java๋ก ๊ตฌํํ๊ธฐ
- ์ต๋ ๊ณต์ฝ์
- ๋ฐ๋ณต๋ฌธ์ ํตํ ๊ตฌํ
- ์ฌ๊ทํธ์ถ์ ํตํ ๊ตฌํ
- ์ต์ ๊ณต๋ฐฐ์
- ์ต๋ ๊ณต์ฝ์
- ์๊ฐ๋ณต์ก๋
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ
์ ํด๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ 2๊ฐ์ ์์ฐ์์ ์ต๋ ๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ต๋ ๊ณต์ฝ์๋ ๋ฌด์์ธ์ง ๊ธฐ์ต์ด ๋๋ฉด ์ข๊ฒ ์ง๋ง ์ต๋๊ณต์ฝ์๋ ์คํ๊ต 1ํ๋ ๊ต์ก ๊ณผ์ ์ ๋์ค๋ ๋ด์ฉ์ด๋ผ ๊น๋จน์์ ์ ์๋ ์ฌ๋ฌ๋ถ์๊ฒ ๋ค์ ํ๋ฒ ์๊ธฐ์์ผ์ฃผ์๋ฉด
์ต๋ ๊ณต์ฝ์์ ์ต์ ๊ณต๋ฐฐ์
์ต๋ ๊ณต์ฝ์์ ์ต์ ๊ณต๋ฐฐ์๋ฅผ ๊ฐ์ฅ ๋นจ๋ฆฌ ์๊ธฐ์ํค๋ ๋ฐฉ๋ฒ์ ์ฐ๋ฆฌ๊ฐ ์ฃฝ์ด๋ผ ํ๋ ๊ณต์์ ํ ๋ฒ ๋ณด์ฌ์ฃผ๋ ๊ฒ์ด๋ผ ์๊ฐํ๋ค.
์ต๋๊ณต์ฝ์(GCD) ๋ ์ด๋ค ๋ ์ A, B๊ฐ ์กด์ฌํ ๋, ๊ณตํต์ธ ์ฝ์ ์ค ๊ฐ์ฅ ํฐ ์
์ต์๊ณต๋ฐฐ์(LCM) ๋ ์ด๋ค ๋ ์ A, B๊ฐ ์กด์ฌํ ๋, ๊ทธ๋ค์ ๋ฐฐ์๊ฐ๋๋ ๊ฐ์ฅ ์์ ์
๋ณดํต ์ฐ๋ฆฌ๋ ์ต๋ ๊ณต์ฝ์๋ฅผ ๊ตฌํ ๋ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํ๊ฒ ๋๋ค.
์ด์ ๋ค์ ๋ณธ๋ก ์ผ๋ก ๋์๊ฐ์ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ด ๋ฌด์์ด๋?
์์์ ๋ณธ ์ฌ์ง์ฒ๋ผ GCD์ด๋ LCM์ ๊ตฌํ๊ฒ ๋๋ฉด ๋ง์ฝ A, B๊ฐ ๋ง๋ ์๋๊ฒ ํฐ ์๋ผ๋ฉด ์์ฃผ ํ๋ค์ด์ง๋ค.
ํ์ง๋ง ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ด์ฉํ๋ค๋ฉด ์ฝ๊ณ ์ฒด๊ณ์ ์ผ๋ก ๊ตฌํ ์ ์๋ค.
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ผ๋ก ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ํต์ฌ์ ๋ชจ๋๋ฌ ์ฐ์ฐ์ด๋ค.
๋ชจ๋๋ฌ ์ฐ์ฐ์ ๋ฐ๋ณตํ์ฌ 0์ด๋ ๋ ๊น์ง ๊ฐ๋ค๋ฉด ์ฐ๋ฆฌ๋ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ ์ ์๋ค.
๋ง์ฝ ์ A์ B๊ฐ ์๊ณ ํด๋น ์์ ๋๋จธ์ง, ๋ชจ๋๋ฌ N์ด ์๋ค๊ณ ๊ฐ์ ํด๋ณด์.
์ด ๋์ ๋ค์๊ณผ ๊ฐ์ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉด ๋๋ค.
- A์ B์ค ๋ ํฐ ์ ์ฐพ๊ธฐ.
- ํฐ ์๋ฅผ A๋ก ์์ ์๋ฅผ B๋ก ์ค์
A % B = N
๊ตฌํ๊ธฐN == 0
์ด๋ฉดB
๋ ์ต๋๊ณต์ฝ์N != 0
์ด๋ฉดA = B, B = N
์ผ๋ก ๋์ ํ๊ณ 3๋ฒ ~ 5๋ฒ ๊ณผ์ ๋ฐ๋ณต
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ผ๋ก ์ต์๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ
์ต์ ๊ณต๋ฐฐ์์ ํต์ฌ์ GCD์ด๋ค.
์ ํด๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํตํด์ ๊ตฌํ ์ต๋ ๊ณต์ฝ์์ a์ b๋ฅผ ๊ฐ๊ฐ ๊ณฑํ ๊ฐ์ ๋๋ ๋ง ์ค๋ค๋ฉด ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ ์ ์๋ค.
Java๋ก ๊ตฌํํ๊ธฐ
GCD๋ฅผ ์๋ฐ๋ก ๊ตฌํํ๋ ๋ฐฉ๋ฒ์๋ ํฌ๊ฒ 2๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋ค.
- ๋ฐ๋ณต๋ฌธ์ ํตํ ๊ตฌํ
- ์ฌ๊ทํธ์ถ์ ํตํ ๊ตฌํ
๋ ๋ฐฉ๋ฒ ๋ชจ๋๋ฅผ ์ฌ์ฉํด ๋ณผ ๊ฒ์ด๋ค.
๋ฐ๋ณต๋ฌธ์ ํตํ ๊ตฌํ
private static int gcdByLoop(int a, int b) {
if(a < b) {
int temp = a;
a = b;
b = temp;
}
while(b > 0) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
์ฌ๊ทํธ์ถ์ ํตํ ๊ตฌํ
private static int gcdByRecursive(int a, int b) {
if(a < b) {
int temp = a;
a = b;
b = temp;
}
if(b == 0) {
return a;
}
return gcdByRecursive(b, a % b);
}
์ต์๊ณต๋ฐฐ์ ๊ตฌํ
private static int lcm(int a, int b) {
return (a * b) / gcdByLoop(a, b);
}
์๊ฐ ๋ณต์ก๋
์ผ๋ฐ์ ์ธ ๋ ผ๋ฆฌ์ ์ํด์ ์ต๋ ๊ณต์ฝ์, ์ต์ ๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ค๋ฉด O(N^2)์ ์๊ฐ์ด ํ๊ท ์ ์ผ๋ก ์์๋๋ค.
ํ์ง๋ง ์ ํด๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ๋ค๋ฉด O(log N)์ด๋ผ๋ ์๊ฐ์ด ์์๋๋ค.
๋๊ธ