๋ฌธ์
๋ ๊ฐ์ ์์ฐ์๋ฅผ ์ ๋ ฅ๋ฐ์ ์ต๋๊ณต์ฝ์(GCD)์ ์ต์๊ณต๋ฐฐ์(LCM)๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์๋ ๋ ๊ฐ์ ์์ฐ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด ๋์ 10,000 ์ดํ์ ์์ฐ์์ด๋ฉฐ ์ฌ์ด์ ํ ์นธ์ ๊ณต๋ฐฑ์ด ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ์์ ์ต๋๊ณต์ฝ์๋ฅผ, ๋์งธ ์ค์๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ์ถ๋ ฅํ๋ค.

#include <iostream>
using namespace std;
int gcd(int a, int b) {
while (b != 0) {
int r = a % b;
a = b;
b = r;
}
return a;
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int main() {
int a, b;
cin >> a >> b;
cout << gcd(a, b) << endl;
cout << lcm(a, b);
}
๋ ์๊ฐ ์ฃผ์ด์ง๋ฉด ์ต๋๊ณต์ฝ์(GCD)์ ์ต์๊ณต๋ฐฐ์(LCM)์ ๊ตฌํ๋ ๋ฌธ์ ์ ๋๋ค. ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ๋ ๋๋ฌด ํํฉ๋๋ค. ์ ๋ชจ๋ฅด์ ๋ค๋ฉด ์ด๋ฒ ๊ธฐํ์ ์ฝ๋๋ฅผ ๊ผญ ๊ผผ๊ผผํ๊ฒ ๋ด์ ๋ก์ง์ ์ดํดํ๊ธธ ๋ฐ๋๋๋ค.
์ต๋๊ณต์ฝ์๋ ๋ ์์ ๋๋จธ์ง ์ฐ์ฐ์ ์ฌ์ฉํ์ฌ ๊ฐ๋จํ๊ฒ ๊ตฌํ ์ ์์ต๋๋ค. ๋๋จธ์ง ์ฐ์ฐ์ ์ด์ฉํ๋ ์ ๋ฐฉ์์ ์ผ๋ช '์ ํด๋ฆฌ๋ ํธ์ ๋ฒ'์ด๋ผ๊ณ ๋ ํฉ๋๋ค.
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ (์ถ์ฒ)
- ์ ๋ ฅ์ผ๋ก ๋ ์ m,n(m>n)์ด ๋ค์ด์จ๋ค.
- n์ด 0์ด๋ผ๋ฉด, m์ ์ถ๋ ฅํ๊ณ ์๊ณ ๋ฆฌ์ฆ์ ์ข ๋ฃํ๋ค.
- m์ด n์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ฉด, n์ ์ถ๋ ฅํ๊ณ ์๊ณ ๋ฆฌ์ฆ์ ์ข ๋ฃํ๋ค.
- ๊ทธ๋ ์ง ์์ผ๋ฉด, m์ n์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ์๋กญ๊ฒ m์ ๋์ ํ๊ณ , m๊ณผ n์ ๋ฐ๊พธ๊ณ 3๋ฒ์ผ๋ก ๋์์จ๋ค.
์ ๊ณผ์ ์ โn, m์ ๋ํด์ ๋๋จธ์ง ์ฐ์ฐ์ ์ค์ํ ์ ์๋คโ๋ผ๋ ์กฐ๊ฑด์๋ง ์์กดํ๋ฏ๋ก, ์ ์ํ๋ฟ ์๋๋ผ, ์์์ ์ ํด๋ฆฌ๋ ์ ์ญ์ ๋ํด๋ ๋๊ฐ์ ๊ณผ์ ์ ๊ฑฐ์น๋ฉด ๊ณต์ฝ์ธ์๊ฐ ๊ตฌํด์ง๋ค.
int gcd(int a, int b) {
while (b != 0) {
int r = a % b;
a = b;
b = r;
}
return a;
}
์ต์๊ณต๋ฐฐ์๋ ์์ ๊ตฌํ ์ต๋๊ณต์ฝ์๋ฅผ ํ์ฉํ์ฌ ํ ์ ์๋ค๋ ๊ฒ์ ๊ธฐ์ตํ๋ฉด ๋ค์์ ๊ตฌํํ ๋ ๋์์ด ๋ฉ๋๋ค.
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
'๐ Algorithm > Solved' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ ๋ฉ์ค] rook (C++, ์์ ํ์) (0) | 2020.07.09 |
---|---|
[์๊ณ ๋ฆฌ์ฆ ์ก์ค] max of arr (C++, ์์ ํ์) (0) | 2020.07.09 |
[์๊ณ ๋ฆฌ์ฆ ์ก์ค] ์์ ๊พธ๋ฏธ๊ธฐ (C++, ์์ ํ์) (0) | 2020.07.09 |
[์๊ณ ๋ฆฌ์ฆ ์ก์ค] offset (C++, ์์ ํ์) (0) | 2020.07.07 |
[์๊ณ ๋ฆฌ์ฆ] Algorithm ์ด๋? (์๊ฐ ๋ณต์ก๋, ๋น ์ค ํ๊ธฐ๋ฒ) (0) | 2020.04.18 |