์ ํด๋ฆฌ๋ ํธ์ ๋ฒ
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ด์ฉํ ์ต์๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ (C์ธ์ด)
๋ฌธ์ : BOJ_5347๋ฒ LCM
๋ฐฑ์ค ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ณธ ๋ฌธ์ ๋ฅผ ํ๋ค ๋ณด๋ฉด, ์ต๋ ๊ณต์ฝ์์ ์ต์ ๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ๋ค์ ๋ง์ฃผํ๊ฒ ๋ฉ๋๋ค. ์์ ๊ฐ์ ธ์จ ๋ฌธ์ ๋ฅผ ๋ณด๋ฉด ๋ ์ a์ b๋ฅผ ์ ๋ ฅํด์ ์ต์ ๊ณต๋ฐฐ์๋ฅผ ์ถ๋ ฅํ๋ ๋ฌธ์ ์ธ๋ฐ, ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ณ ๋ คํ์ง ์๋๋ค๋ฉด ์ด์ค for๋ฌธ์ ์ด์ฉํ ์ด๋ฐ ๋ฌด์ํ ์ฝ๋ฉ๋ ๊ฐ๋ฅํฉ๋๋ค.
#include<stdio.h>
int main(void) {
int num;
scanf("%d",&num);
for(int a=1;num>=a;a++){
long long num1, num2;
long long mul1, mul2;
scanf("%lld %lld",&num1,&num2);
for(mul1=1;num2>=mul1;mul1++){
for(mul2=1;num1>=mul2;mul2++){
if(mul2*num2==mul1*num1) break;
}
if(mul2*num2==mul1*num1) break;
}
printf("%lld\n",mul2*num2);
}
return 0;
}
(์๊ฐ์ด๊ณผ์ ๊ฑธ๋ฆฌ๋ ๋ฌด์ํ ์ฝ๋ฉ)
์ธ๊ธํ๋ฏ์ด ๋ค์ ๋ฌด์ํ ๋ฐฉ๋ฒ์ด์ง๋ง, ๋ ์๋ฅผ num1, num2๋ผ๊ณ ํ ๋ for๋ฌธ ์์ a*num1 = b*num2 ๊ฐ ๋ ๋๊น์ง a์ b๋ฅผ ์ด์ค for๋ฌธ ์์์ ํ์ํ๋ ๋ฐฉ๋ฒ์
๋๋ค. ์ ์์ค๋ฅผ ์ปดํ์ผํ๋ฉด ์ํ๋ ์ต๋ ๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ ์ ์์ง๋ง num1๊ณผ num2๋ ๋ฐฑ๋ง๊น์ง ์ปค์ง ์ ์์ผ๋ฏ๋ก ์ด๋ฐ ์ฝ๋ฉ์ ์๊ฐ ์ ํ 1์ด๋ฅผ ๋์ด๋ฒ๋ฆฌ๋ for๋ฌธ์ ์ด๋ํ๊ณ ๋ง๋๋ค.
์ด๋ฌํ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ทน๋ณตํ๊ธฐ ์ํด ์๊ณ ๋ฆฌ์ฆ์์ ์ต๋ ๊ณต์ฝ์๋ฅผ ๋น ๋ฅด๊ฒ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ด ๋ฐ๋ก ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ธ๋ฐ์. ์ผ๋จ ์ ์๋ถํฐ ํ์ธํ์๋ฉด,
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ
๋ ์ ์ a, b์ ์ต๋๊ณต์ฝ์๋ฅผ G(a, b)๋ผ๊ณ ํ์.
์ ์ a, b, q r (b ≠ 0)์ ๋ํ์ฌ a = bq + r,์ด๋ฉด G(a, b) = G(b, r)๊ฐ ์ฑ๋ฆฝํ๋ค.
ใ์ฆ๋ช
ใ
G(a, b) = g๋ผ๊ณ ํ์. ์ต๋๊ณต์ฝ์์ ์ฑ์ง์ ์ํด a = a′g, b = b′g์ด๊ณ G(a′, b′) = 1์ด๋ค.
a = bq + r๋ก๋ถํฐ r = a - bq = g(a′ - b′q) ์ด๊ณ , g๋ r์ ์ฝ์์ด๋ค.
G(b, r) = g์์ ๋ณด์ด๊ธฐ ์ํด์๋ G(b′, a′ - b′q) = 1์์ ๋ณด์ด๋ฉด ๋๋ค.
๊ท๋ฅ๋ฒ์ ์ ์ฉํ์ฌ ๊ฒฐ๋ก ์ ๋ถ์ ํด๋ณด์.
์ด๋ค ์ ์ d๊ฐ ์กด์ฌํ์ฌ G(b′, a′ - b′q) =d(≠ 1)๋ผ๊ณ ํ๋ฉด, b′ = dm, a′ - b′q = dn๋ผ๊ณ ํ ์ ์๊ณ , a′ = b′q + dn= dmq + dn = d(mq + n) ์ด๋ฏ๋ก G(a′, b′) = 1๋ผ๋ ๊ฐ์ ์ ๋ชจ์์ด๋ค. ๋ฐ๋ผ์ G(b′, a′ - b′q) = 1์ด๋ฏ๋ก G(b, r) = g๊ฐ ์ฑ๋ฆฝํ๋ค.์ถ์ฒ:[๋ค์ด๋ฒ ์ง์๋ฐฑ๊ณผ] ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ (ํตํฉ๋
ผ์ ๊ฐ๋
์ด ์ฌ์ , 2007. 12. 15., ์ฒญ์์ถํ)
์ฝ๊ฒ ๋งํด a์ b์ ์ต๋ ๊ณต์ฝ์๋ฅผ ๊ตฌํ๊ธฐ ์ํด, ๋ชซ์ q ๋๋จธ์ง๋ฅผ r๋ก ํํํ๋ค๋ฉด,
a = bp + r
์ด๊ณ ์ ์์์ a์ b์ ์ต์ ๊ณต๋ฐฐ์๋ b์ r์ ์ต์ ๊ณต๋ฐฐ์์ ๊ฐ๋ค๋ ์ ๋ฆฌ์
๋๋ค.
ํ๋ก๊ทธ๋๋ฐ์ ์ฆ๋ช
์ ๋ด์ฉ๋ณด๋จ ์ฌ์ฉ๋ฒ์ ์ ํํ ์์์ผ๋์ง๋ง, ์์ ์ฆ๋ช
์ ์งง๊ฒ ํด์ํด๋ณด์๋ฉด,
a์ b์ ์๋ก์๋ฅผ a'์ b'๋ก ์ ํ์ง๊ณ ์ต๋๊ณต์ฝ์๋ฅผ g๋ผ๊ณ ์ ํ์ ๋,
๋๋จธ์ง r์ด g(a′ - b′q)๊ฐ ๋๋๋ฐ, ์ฌ๊ธฐ์ b'์ a′ - b′q๊ฐ ์๋ก์์์ ๊ฒฐ๋ก ์ ๋ถ์ ํ์ฌ ๊ท๋ฅ๋ฒ์ผ๋ก ์ฆ๋ช
ํ๋ ๊ณผ์ ์
๋๋ค. (b'์ a′ - b′q๊ฐ ์๋ก์๊ฐ ์๋๋ผ๋ฉด a'์ b'์ ๊ณต์ฝ์๊ฐ ์๊ธฐ๋ฉด์ ๋์ด ์๋ก์๋ผ๋ ์ ์ ์ ์๋ฐฐ)
์ฆ๋ช
์ ์ด์ฏค์์ ํ๊ณ , ํ๋ก๊ทธ๋๋ฐ์ ๋ชฉ์ ์ผ๋ก ๋ดค์ ๋ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํด์ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ๊ตฌํํ๋ค๋ฉด,
a์ b์ ์ต๋ ๊ณต์ฝ์๋ b์ r์ ์ต๋ ๊ณต์ฝ์์ ๊ฐ๊ณ , b์ r์ ์ต๋ ๊ณต์ฝ์๋ ๋ ๋ค๋ฅธ b'๊ณผ r'์ ์ต๋๊ณต์ฝ์์ ๊ฐ๊ธฐ ๋๋ฌธ์,
๋๋จธ์ง์ธ r(n)'์ด 0์ด ๋๋ ๊ฒฝ์ฐ์์์ b๊ฐ ์ต๋ ๊ณต์ฝ์์์ ์ ์ ์์ต๋๋ค.
๋ง๋ก ํํํ๋ฉด ์ด๋ ต์ง๋ง, ์ํค๋ฐฑ๊ณผ์์ ๊ฐ์ ธ์จ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์๋ฅผ ๋ณด๋ฉด,
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ด์ฉํ ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ (์ถ์ฒ : ์ํค๋ฐฑ๊ณผ)
๋ง์ง๋ง์์ 72 = 36 x 2(๋ชซ) + 0(๋๋จธ์ง) ์์ ์ ์ ์์ต๋๋ค.
๊ทธ๋ฌ๋ฏ๋ก a,b๋ฅผ ํธ์ถ ์, b๊ฐ 0์ด ๋๊ณ , a๊ฐ ๋ง์ง๋ง ์ต๋ ๊ณต์ฝ์๊ฐ ๋๋ ํจ์์์ ๋ง๋ ๋ค๋ฉด, ```c int gcd(int a, int b) { int c; while (b) { c = a; a = b; b = c % a; } ```
(์ ํด๋ฆฌ๋ ํธ์ ๋ฒ ํจ์)
์์ ๊ฐ์ ํจ์๋ก ๋ํ๋ผ ์ ์์ต๋๋ค. (b==0 ์ผ ๋ while ๋ฌธ์ด ์ข
๋ฃ๋จ์ผ๋ก)
*์ต๋ ๊ณต์ฝ์๋ ํธ์์ gcd(greatest common divisor)๋ก ๋ง์ด ์๋๋ค.
์์ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ด์ฉํด์ ์์ ์๊ฐํด๋๋ฆฐ ๋ฐฑ์ค ๋ฌธ์ ๋ฅผ ๋ค์ ํ์ด๋ณธ๋ค๋ฉด,
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์์ฉํ ํ์ด
#include <stdio.h>
int gcd(int a, int b);
int main() {
int roof,i;
scanf("%d", &roof);
for (i = 1; i <= roof; i++) {
int num1, num2, num3;
scanf("%d %d", &num1, &num2);
if (num1 >= num2) {
num3 = gcd(num1, num2);
}
else num3 = gcd(num2, num1);
printf("%d\n", num3*(num1 / num3)*(num2 / num3));
}
return 0;
}
int gcd(int a, int b) {
int c;
while (b) {
c = a;
a = b;
b = c % a;
}
return a;
}
(5347๋ฒ ํ์ด ์ฝ๋ฉ)
์์ ๊ฐ์ด ์ต๋ ๊ณต์ฝ์๋ฅผ ๊ตฌํ ๋ค, num1๊ณผ num2๋ฅผ ์ต๋ ๊ณต์ฝ์๋ก ๋๋ ๋ชซ์ ์ต๋ ๊ณต์ฝ์์ ๊ณฑํด์ฃผ๋ ๋ฐฉ์์ผ๋ก ์ต์ ๊ณต๋ฐฐ์๋ฅผ ์ถ๋ ฅ ํ ์ ์์ต๋๋ค.