#18 ์์ ๊ตฌํ๊ธฐ
M์ด์ N์ดํ์ ์์ฐ์ ์ค ์์ ๋ชจ๋ ์ถ๋ ฅ
์ต๋ ํฌ๊ธฐ 1,000,000์ด๋ฏ๋ก ์๊ฐ๋ณต์ก๋๊ฐ O(N^2)์ธ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉ ๋ถ๊ฐํ๋ค.
๊ณผ์
1. ํฌ๊ธฐ๊ฐ N+1์ธ ๋ฐฐ์ด ์์ฑ, ๊ฐ ์์์ ์ธ๋ฑ์ค ๋์ // ์ธ๋ฑ์ค ์์ 1๋ถํฐ ์์ํ์ฌ ์ ๊ฒฝ ์ ์ฐ๊ฒ ํ๊ธฐ ์ํ์ฌ
2. 1์ ์์ X์ด๋ฏ๋ก ์ญ์ , 2๋ถํฐ N์ ์ ๊ณฑ๊ทผ๊น์ง ํ์ํ์ฌ ๊ฐ์ด ์ธ๋ฑ์ค์ ์ผ์นํ๋ฉด ๊ทธ๋๋ก ๋๊ณ
// ์ฒ์ ์ ํํ ์๋ ์์๋ก ์ธ์ , ๊ทธ ๋ฐฐ์๋ ์ญ์
3. ๋จ์ ์๋ ์ ๋ชจ๋ ์ถ๋ ฅ // M์ด์ N์ดํ
*N์ ์ ๊ณฑ๊ทผ๊น์ง๋ง ํ์ํ๋ ์ด์
N์ ๋ ์์ ๊ณฑ a*b๋ก ํํํ๋ฉด ๊ฐ ์์ธ a, b๋ ๋์ค ํ๋๋ N์ ์ ๊ณฑ๊ทผ๋ณด๋ค ํด ์ ์๋ค.
๊ทธ๋ฌ๋ฏ๋ก N์ ์ ๊ณฑ๊ทผ๊น์ง๋ง ํ์ํ๋ฉด ์ ์ฒด ๋ฒ์์ ์์ ํ์ ๊ฐ๋ฅ
for(int i = 2; i <= Math.sqrt(N); i++) // N์ ์ ๊ณฑ๊ทผ๊น์ง ๋ฐ๋ณต
if(A[i] == 0) continue; // ์ด๋ฏธ ์์๊ฐ ์๋๋ผ๊ณ ํ์ ๋์์ผ๋ฉด ๋์ด๊ฐ
for(int j = i+i; j<=N; j=j+i) { // ํ์ฌ ์ ํ๋ ์์ ๋ฐฐ์ ์ญ์ , ์ธ๋ฑ์ค ์ฃผ์
A[j] = 0;
for(int i =M; i<=N; i++) { // ๋ฒ์ M๋ถํฐ N๊น์ง
if(A[i] != 0) // ์์๋ผ๊ณ ํ์ ๋์์ผ๋ฉด
System.out.println(A[i]);
}
#19 ์ต์ ๊ณต๋ฐฐ์ ๊ตฌํ๊ธฐ
์ต์ ๊ณต๋ฐฐ์๋? ๋ ์์ ๊ณต๋ฐฐ์ ์ค์์ ์ต์๊ฐ
์ฝ๋ฉ ํ ์คํธ์์ ์ต์ ๊ณต๋ฐฐ์ ๊ตฌํ๋ ๋ฒ a*b/์ต๋๊ณต์ฝ์
์ํ์ ์ผ๋ก ์ต์ ๊ณต๋ฐฐ์ ๊ตฌํ๋ ๋ฒ
2 36 48
2 18 24
3 9 12
3 4 // ์๋ก์๊ฐ ๋ ๋๊น์ง ์์๋ก ๋๋๊ณ ๋ชจ๋ ๊ณฑํ๋ค.
2*2*3*3*4 == 144 // ์ต์ ๊ณต๋ฐฐ์
๋ ์์ ๊ณฑ์ ์ต๋ ๊ณต์ฝ์๊ฐ 1๋ฒ ์ค๋ณต ๋์ด ์์ผ๋ฏ๋ก ๋ ์์ ๊ณฑ์์ ์ต๋ ๊ณต์ฝ์๋ฅผ ๋๋์ด ๋นผ์ฃผ๋ฉด ์ต์ ๊ณต๋ฐฐ์๊ฐ ๋๋ค.
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ฌ๊ทํจ์๋ก ๊ตฌํํ๋ค.
result = a*b / gcd(a,b);
gcd(a, b)
if(b==0)
return a;
else{
return gcd(b, a%b);
// ํญ์ ๋งจ ์์ ํฐ์๊ฐ ์ ๋ฌ๋์ง ์์ง๋ง, ๋๋จธ์ง ์ฐ์ฐ ๋๋ฌธ์ ์์ฐ์ค๋ฝ๊ฒ swap ๋๋ค.