https://www.acmicpc.net/problem/2485
๋ฌธ์
์ง์ ์ผ๋ก ๋์ด์๋ ๋๋ก์ ํ ํธ์ ๊ฐ๋ก์๊ฐ ์์์ ๊ฐ๊ฒฉ์ผ๋ก ์ฌ์ด์ ธ์๋ค. KOI ์์์๋ ๊ฐ๋ก์๋ค์ด ๋ชจ๋ ๊ฐ์ ๊ฐ๊ฒฉ์ด ๋๋๋ก ๊ฐ๋ก์๋ฅผ ์ถ๊ฐ๋ก ์ฌ๋ ์ฌ์ ์ ์ถ์งํ๊ณ ์๋ค. KOI ์์์๋ ์์ฐ๋ฌธ์ ๋ก ๊ฐ๋ฅํ ํ ๊ฐ์ฅ ์ ์ ์์ ๋๋ฌด๋ฅผ ์ฌ๊ณ ์ถ๋ค.
ํธ์์ ๊ฐ๋ก์์ ์์น๋ ๊ธฐ์ค์ ์ผ๋ก ๋ถํฐ ๋จ์ด์ ธ ์๋ ๊ฑฐ๋ฆฌ๋ก ํํ๋๋ฉฐ, ๊ฐ๋ก์์ ์์น๋ ๋ชจ๋ ์์ ์ ์์ด๋ค.
์๋ฅผ ๋ค์ด, ๊ฐ๋ก์๊ฐ (1, 3, 7, 13)์ ์์น์ ์๋ค๋ฉด (5, 9, 11)์ ์์น์ ๊ฐ๋ก์๋ฅผ ๋ ์ฌ์ผ๋ฉด ๋ชจ๋ ๊ฐ๋ก์๋ค์ ๊ฐ๊ฒฉ์ด ๊ฐ๊ฒ ๋๋ค. ๋ํ, ๊ฐ๋ก์๊ฐ (2, 6, 12, 18)์ ์๋ค๋ฉด (4, 8, 10, 14, 16)์ ๊ฐ๋ก์๋ฅผ ๋ ์ฌ์ด์ผ ํ๋ค.
์ฌ์ด์ ธ ์๋ ๊ฐ๋ก์์ ์์น๊ฐ ์ฃผ์ด์ง ๋, ๋ชจ๋ ๊ฐ๋ก์๊ฐ ๊ฐ์ ๊ฐ๊ฒฉ์ด ๋๋๋ก ์๋ก ์ฌ์ด์ผ ํ๋ ๊ฐ๋ก์์ ์ต์์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ. ๋จ, ์ถ๊ฐ๋๋ ๋๋ฌด๋ ๊ธฐ์กด์ ๋๋ฌด๋ค ์ฌ์ด์๋ง ์ฌ์ ์ ์๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์๋ ์ด๋ฏธ ์ฌ์ด์ ธ ์๋ ๊ฐ๋ก์์ ์๋ฅผ ๋ํ๋ด๋ ํ๋์ ์ ์ N์ด ์ฃผ์ด์ง๋ค(3 ≤ N ≤ 100,000). ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ๊ฐ ์ค๋ง๋ค ์ฌ์ด์ ธ ์๋ ๊ฐ๋ก์์ ์์น๊ฐ ์์ ์ ์๋ก ์ฃผ์ด์ง๋ฉฐ, ๊ฐ๋ก์์ ์์น๋ฅผ ๋ํ๋ด๋ ์ ์๋ 1,000,000,000 ์ดํ์ด๋ค. ๊ฐ๋ก์์ ์์น๋ฅผ ๋ํ๋ด๋ ์ ์๋ ๋ชจ๋ ๋ค๋ฅด๊ณ , N๊ฐ์ ๊ฐ๋ก์๋ ๊ธฐ์ค์ ์ผ๋ก๋ถํฐ ๋จ์ด์ง ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ๊น์ด ์์๋๋ก ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
๋ชจ๋ ๊ฐ๋ก์๊ฐ ๊ฐ์ ๊ฐ๊ฒฉ์ด ๋๋๋ก ์๋ก ์ฌ์ด์ผ ํ๋ ๊ฐ๋ก์์ ์ต์์๋ฅผ ์ฒซ ๋ฒ์งธ ์ค์ ์ถ๋ ฅํ๋ค.
ํ์ด
์ ๋ ฅ ๋ฐ์ ๊ฐ๋ก์์ ์์น๋ค์ ์ฌ์ด ๊ฐ์ ๋ฐฐ์ด๋ก ์ ์ฅํ๋ค
์๋ฅผ๋ค์ด ๊ฐ๋ก์์ ์์น๊ฐ 1,3,7,13 ์ด ์ฃผ์ด์ง๋ฉด
๋ฒกํฐ์๋ 2,4,6 ์ด ์ ์ฅ๋๋ ํํ (๊ฐ๊ฐ 3-1, 7-3, 13-7)
(1)
๋ฒกํฐ์ ์๋ ๋ชจ๋ ์๋ค์ ์ต๋๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ค
gcd ํจ์๋ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ด์ฉํ์ฌ ๊ฐ๋จํ๊ฒ ๊ตฌํํ๋ค.
์ด๋, a>b๋ฅผ ํ์ ํ ์ ์์ผ๋ฏ๋ก ํจ์ ๋ด๋ถ์์ ์์๋ฅผ ์๋์ผ๋ก ์ง์ ํด์ฃผ๋๋ก ํ๋ค
(2)
๋ฒกํฐ์ ์๋ ์ / ๋ฐฉ๊ธ ๊ตฌํ ์ต๋๊ณต์ฝ์ = ํด๋น ๊ฑฐ๋ฆฌ์ ์ฌ์ด์ ธ์ผ ํ ๊ฐ๋ก์์ ๊ฐฏ์ +1 ์ด๋ค
์๋ฅผ๋ค์ด ์ ์์ ์์ ์ต๋๊ณต์ฝ์๋ 2๊ฐ ๋์ค๋๋ฐ,
1๊ณผ 3 ์ฌ์ด๋ ๊ฑฐ๋ฆฌ๊ฐ 2 ์ด๋ฏ๋ก 2/2=1 -> ์ฌ์ด์ 0๊ฐ ์ฌ์
3๊ณผ 7 ์ฌ์ด๋ ๊ฑฐ๋ฆฌ๊ฐ 4 ์ด๋ฏ๋ก 4/2=2 -> ์ฌ์ด์ 1๊ฐ ์ฌ์ (5 ์์น)
7๊ณผ 13 ์ฌ์ด๋ ๊ฑฐ๋ฆฌ๊ฐ 6 ์ด๋ฏ๋ก 6/2=3 -> ์ฌ์ด์ 2๊ฐ ์ฌ์ (9, 11 ์์น)
์ด์ ๊ทธ ์๋ฅผ ๋ํด์ฃผ๋ฉด ๋ !
์ฝ๋
#include <iostream>
#include <vector>
using namespace std;
// Greatest Common Divisor : ์ต๋๊ณต์ฝ์
int gcd(int a, int b) {
if(a<b) {
int tmp = a;
a = b;
b = tmp;
} // a์ b ์์ ์๋ฌด๋ ๊ฒ๋ ๊ฐ๋ฅ
if(a%b != 0) {
return gcd(b, a%b);
}
return b;
}
int main() {
int n, before, cur;
cin >> n;
vector<int> v(n-1);
cin >> before;
for(int i=0; i<n-1; i++) {
cin >> cur;
v[i] = cur-before;
before = cur;
}
// (1)
int totalGcd = v[0];
for(int i=1; i<v.size(); i++) {
totalGcd = gcd(v[i], totalGcd);
}
// (2)
int ans = 0;
for(int i=0; i<v.size(); i++) {
ans += v[i]/totalGcd - 1;
}
cout << ans;
return 0;
}
'๐ BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ][C++] ๋ฐฑ์ค 2636๋ฒ: ์น์ฆ (0) | 2024.04.11 |
---|---|
[BOJ][C++] ๋ฐฑ์ค 2217๋ฒ: ๋กํ (0) | 2024.03.15 |
[BOJ][C++] ๋ฐฑ์ค 15686๋ฒ: ์นํจ๋ฐฐ๋ฌ (0) | 2024.03.11 |
[BOJ][C++] ๋ฐฑ์ค 1037๋ฒ: ์ฝ์ (0) | 2024.03.08 |
[BOJ][C++] ๋ฐฑ์ค 2849๋ฒ: ํ์ด์ ๋ฐํด (0) | 2024.03.06 |