1. ๋ฌธ์ ์ค๋ช
2. ์ ๊ทผ ๋ฐฉ์
keyword
: GCD(์ต๋ ๊ณต์ฝ์) ๊ตฌํ๋ ๋ฒ - ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ
ArrayA์ ArrayB์ ์ต๋ ๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ค. ์ต๋ ๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
- ๋งจ ์ฒ์ ๊ฐ๊ณผ ๋ ๋ฒ์งธ ๊ฐ ๊ฐ์ ์ต๋ ๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ค. (์ ํด๋ฆฌ๋ ํธ์ ๋ฒ ์ด์ฉ)
- 1๋ฒ์์ ๋์จ GCD์ ์ธ ๋ฒ์งธ ๊ฐ๊ฐ์ ์ต๋ ๊ณต์ฝ์๋ฅผ ๊ตฌํ๋ค.
(์ ์ด๋ ๊ฒ ๊ตฌํด๋ ๋๋๊ฑฐ์ผ?
- 1๋ฒ์์ ๋์จ GCD๋ ์ด๋ฏธ 1 ๋ฒ์งธ ๊ฐ๊ณผ 2 ๋ฒ์งธ ๊ฐ์์์ ์ต๋ ๊ณต์ฝ์ ์ด๋ค.
๋ง์ฝ ํด๋น GCD๋ก 3 ๋ฒ๊ฐ์ด ๋ฐ๋ก ๋๋์ด์ง๋ค๋ฉด, GCD๊ฐ 1,2๋ฒ๊ณผ ๊ฐ์ ๊ฒ์ด๋ฏ๋ก, ๊ทธ๋๋ก ๊ฐ๋ ๋๋ค.
๋ง์ฝ GCD๊ฐ ๋ ์์์ง๋ค๋ฉด, ํด๋น ๊ฐ์ด ํ์ฌ๊น์ง 3๊ฐ์ง ๊ฐ์์ ํตํ๋ GCD ์ธ ๊ฒ์ด๋ค.
์ด๋ฐ ์์ผ๋ก GCD๋ฅผ ๊ฐฑ์ ํด ๋๊ฐ๋ฉด, ๋ชจ๋ ๊ฐ์์ ํตํ๋ GCD๋ฅผ ๊ตฌํ ์ ์๋ค.) - 1,2๋ฒ ๊ณผ์ ์ ๋ฐฐ์ด ์ ์ฒด์ ๋ํด์ ๋ฐ๋ณตํ์ฌ ์ต์ข ์ ์ธ GCD๋ฅผ ๋ฐฐ์ด๋ง๋ค ๊ตฌํ๋ค.
- GCD๊ฐ ์๋ก์ ๋ฐฐ์ด์์ ๊ทธ ๋ฌด์๋ ๋๋ ์ ์๋ ์์ธ์ง ํ์ธํ๋ค. (GCD๊ฐ
1
์ธ ๊ฒฝ์ฐ ์ฌ๊ธฐ์ ํต๊ณผํ์ง ๋ชปํ๋ค.) - 1~4๋ฒ ๊ณผ์ ์ ๋ค ํต๊ณผํ GCD ์ค ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค.
3. ์ฝ๋ ๋ถ์
import java.io.*;
import java.util.*;
class Solution {
public int solution(int[] arrayA, int[] arrayB) {
// 1. ๊ฐ ๋ฐฐ์ด์ GCD ๊ตฌํ๊ธฐ
int GCD_A = arrayA[0]; int GCD_B = arrayB[0];
for(int i = 1; i<arrayA.length; i++){
GCD_A = getGCD(GCD_A, arrayA[i]); // ๋ชจ๋์๊ฒ ํตํ๋ GCD๋ก ๊ฐฑ์ ๋จ.
}
for(int i = 1; i<arrayB.length; i++){
GCD_B = getGCD(GCD_B, arrayB[i]);
}
// 2. Cross ํด์ ๋จ์ GCD๋ก ๋๋ ์ง๋ ์๊ฐ ์๋์ง ์ฒดํฌ ์์ผ๋ฉด fail
for(int i = 0; i<arrayB.length; i++){
if(arrayB[i]%GCD_A == 0) { GCD_A = 0; break;}
}
for(int i = 0; i<arrayA.length; i++){
if(arrayA[i]%GCD_B == 0) { GCD_B = 0; break;}
}
// 3, ์ด์๋จ์ GCD ์ค ๊ฐ์ฅ ํฐ ๊ฐ ์ถ๋ ฅ
int ans = Math.max(GCD_A, GCD_B);
return ans;
}
public int getGCD(int a, int b){
if(a%b == 0) return b;
else return getGCD(b, a%b);
}
}
4. ์ฑ์ฅํ๊ธฐ
์ ์ฒด ๋ฐฐ์ด์ ๋ํด์ ์ฑ๋ฆฝํ๋ GCD๋ฅผ ๊ตฌํด์ผ ํ๋๋ฐ, ์ ์ผ ์์ ๊ฐ๊ณผ ๋ ๋ฒ์งธ๋ก ์์ ๊ฐ์์ ๋์จ GCD๋ฅผ ์ด์ฉํด์ ๋ฌธ์ ๋ฅผ ํ์๋ค. ์ด๋ ๊ฒ ๋๋, ๋น์ฐํ, ๋ฐฐ์ด๋ง๋ค์ ์ ํํ GCD๋ฅผ ๊ตฌํ์ง ๋ชปํ๊ณ , ๊ทธ ๋๋ฌธ์ ๋ฌธ์ ๋ฅผ ํ๋ ธ๋ค.
๊ทธ๋ฅ ์์์ ์์ 2๊ฐ์ GCD๋ฅผ ๋ค๋ฅธ ์์๋ค๊ณผ ๋น๊ตํ๋ฉฐ GCD๋ฅผ ๊ณ์ ๊ฐฑ์ ํด๋๊ฐ๋ค๋ฉด, ๋ชจ๋ ๋ฐฐ์ด์ ๋ํด์ ์ฑ๋ฆฝํ๋ GCD๋ฅผ ๊ตฌํ ์ ์๋ค๋ ์๊ฐ์ ํ์ง ๋ชปํ๋ค. ์ด๋ฒ ๋ฌธ์ ์์ ๋ ํ๋ ๋ฐฐ์ด ๊ฒ ๊ฐ๋ค.