1. ์ค์ผ๋ฌ ํผ ํจ์๋?
$$
φ(n) = n์ดํ\;์์ฐ์\;์ค\;n๊ณผ\;์๋ก์์ธ\;์์\;๊ฐ์
$$
$φ(12) \; = \; 4$์ด๋ค.
2. ์ฌ์ ํ์ต
์ค์ผ๋ฌ ํผ ํจ์์ ์ฆ๋ช
์ ์ํด์ ๋ค์ ์ฑํฐ์์ ์ค์ผ๋ฌ์ ๊ณฑ ๊ณต์
์ ์ดํด๋ณผ ๊ฒ์ธ๋ฐ, ์ฌ์ ์ ํ์ตํด์ผํ ๋ด์ฉ์ด ์์ด์ ๋ฏธ๋ฆฌ ์๊ฐํ๊ฒ ๋ค.
- 1๏ธโฃ
์์ธ์
: ์์์ ์ K์ ์์์ด๋ฉด์ ์ธ์์ธ ์์ด๋ค. ์๋ฅผ ๋ค๋ฉด 12์ ์์ธ์๋ 2์ 3 ์ด ์๋ค. - 2๏ธโฃ
์์ธ์ ๋ถํด
: ์์์ ์ K๋ฅผ ์์๋ก๋ง ์ธ์ ๋ถํดํ๋ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด 12๋ฅผ ์์ธ์ ๋ถํดํ๋ฉด, $12\,=\,2^{2}\,*\,3$์ด๋ค. - 3๏ธโฃ
์๋ก์
: A์ B๊ฐ ์๋ก์๋ผ๋ ๋ป์, A์ B์ ๊ณต์ฝ์๊ฐ 1๋ง๊ณ ๋ ์๋ค๋ ๋ป์ด๋ค. - 4๏ธโฃ $φ()$: ์ค์ผ๋ฌ ํ์ด๋ผ๊ณ ์ฝ๋๋ค.
- 5๏ธโฃ $\prod_{p \mid N}$: ์ฌ๋ฌ ๊ฐ์ ํฉ์ ๋ํ๋ด๋ ∑ ์ฒ๋ผ ์ฌ๋ฌ ๊ฐ์ ๊ณฑ์ ์ ๋ํ๋ด๋ ์ํ๊ธฐํธ ์ด๋ค.
3. ์ค์ผ๋ฌ์ ๊ณฑ ๊ณต์
(1) ์ ์
$$
\phi(N) = N \times \prod_{p \mid N} \left( 1 - \frac{1}{p} \right)
$$
(2) ํด์ค
์ค์ผ๋ฌ์ ๊ณฑ ๊ณต์
์ ์๋ฆฌ๋ 1๋ถํฐ N๊น์ง์ ์ซ์ ์ค ์์ธ์์ ๊ทธ ๋ฐฐ์๋ฅผ ์ ์ธ
์์ผ์ ๊ฒฐ๊ตญ ์์๋ง ์์ญ์์ ๋จ๊ฒ ํ๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ ์๋ฅผ ์ผ๋ค.
์์์ ๋ํ๋ธ p๋ N์ ์์ธ์๋ฅผ ๋ปํ๋ค. ํด๋น ์์ด ํ์ด๋ก ๋ฌถ์ฌ ์์ผ๋ฏ๋ก p์๋ N์ ์์ธ์๊ฐ ์ฐจ๋ก๋๋ก ๋ค์ด๊ฐ ๊ฒ์ด๋ค. ์ด์ ํ๋์ฉ ๋๋ฆด๋ง ํด๋ณด์.
โ N์ดํ์ ์์ฐ์ ์ค p์ ๋ฐฐ์์ ๊ฐ์๋ ๋ช ๊ฐ์ผ๊น?
๊ทธ๊ฒ์ N์ P๋ก ๋๋ ๋ชซ๊ณผ ๊ฐ์ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด 1์ด์ 12 ์ดํ์์ 2์ ๋ฐฐ์์ ๊ฐ์๋ 6์ด๋ค. 3์ ๋ฐฐ์๋ 4๊ฐ์ผ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ ์ด๋ฅผ ๋ณ์ํํด์ ๋ํ๋ธ๋ค๋ฉด, $\frac{N}{p} (๋ด๋ฆผ)$ ๋ก ๋ํ๋ผ ์ ์๋ค.
โ ๋น์จํ ํด์ ๋ํ๋ด๊ธฐ
ํด๋น ๊ณต์์์๋ ๊ณ์ฐํ๊ธฐ ์ฝ๊ฒ N๊ฐ ์ค์์ ์์ธ์์ ๋ฐฐ์๊ฐ ์๋ ์์ ๋น์จ ์ ๊ตฌํ๊ณ ๊ฑฐ๊ธฐ์ N์ ๊ณฑํด ์ต์ข
์ ์ผ๋ก N ์ดํ N๊ณผ ์๋ก์์ธ ๋ฐฐ์๋ฅผ ๊ตฌํ๋ค.
N์ดํ ์์ฐ์ ์ค ์์ธ์ p์ ๋ฐฐ์๊ฐ ์๋ ์์ ๋น์จ ์ ํํํ๋ฉด $1 - \frac{1}{p}$์ ๊ฐ์ ๊ฒ์ด๋ค. ์ด๋ฅผ ์์ธํ ์ค๋ช
ํ๋ฉด ์ฐ๋ฆฌ๊ฐ ๊ตฌํ๋ ค๋ ๊ฒ์
$$
๋น์จ\;=\;\frac{P์\;๋ฐฐ์๊ฐ\;์๋\;์ซ์์\;๊ฐ์}{์ ์ฒด\;์ซ์์\;๊ฐ์}
$$
์ฆ,
$$
๋น์จ = \frac{N - \frac{N}{P}}{N}
$$
๋ถ๋ชจ๋ฅผ ์ ๋ฆฌํ๋ฉด
$$
๋น์จ = 1 - \frac{1}{P}
$$
๊ฐ ๋๋ค.
์ด์ ํ๋์ $1 - \frac{1}{p}$์ ๋ป์ ์๊ฒ ๋ค. ํ์ง๋ง ๊ณต์์ ๋ณด๋ ํ์ด ๊ธฐํธ๋ก ๋ชจ๋ ์์ธ์๊ฐ ์๋ ์์ ๋น์จ์ ๊ณฑํ๊ณ ์๋ค. ์ด๊ฑด ์ ๊ทธ๋ด๊น?
โ ์์ธ์์ ๋ฐฐ์๊ฐ ์๋ ์์ ๋น์จ์ ์ ๋ถ ๊ณฑํ๋ ์ด์
์ด๋ ํฌํจ ๋ฐฐ์ ์ ์๋ฆฌ ๋๋ฌธ์ด๋ค. 2์ ๋ฐฐ์์ 3์ ๋ฐฐ์๋ฅผ ์ง์ฐ๋ฉด์ 6์ ๋ฐฐ์๊ฐ 2๋ฒ ์ง์์ก๋ค. ํฌํจ ๋ฐฐ์ ์ ์๋ฆฌ๋ ์งํฉ์๊ฐ์ ๋ฐฐ์ ์ํ
๋ฐ, ๊ธฐ์ต ์ ๋๋ ๋ถ์ด ๋ง์ํ
๋ ๋ค์ ๊ธฐ๋กํ๊ณ ๊ฐ๊ฒ ๋ค.
$$
โฃA∪B∪Cโฃ=โฃAโฃ+โฃBโฃ+โฃCโฃ−โฃA∩Bโฃ−โฃB∩Cโฃ−โฃC∩Aโฃ+โฃA∩B∩Cโฃ
$$
์ฆ ๋๋ฒ ์ค๋ณตํด์ ๋นผ์ง ๊ฐ์ ํ ๋ฒ ๋ํด์, ๊ณ์ฐ์ ์ฌ๋ฐ๋ฅด๊ฒ ์ ์งํ๋ ๊ฒ์ด๋ค. ์ด ํฌํจ ๋ฐฐ์ ์ ์๋ฆฌ๋ ๊ณฑ์
๊ณต์์ ์์ฐ์ค๋ฝ๊ฒ ๋
น์ ์๋ค.
์์ ๊ณต์ ๋๋ก, $φ(12)$๋ฅผ ๊ตฌํด๋ณผ๊น?
$$
ฯ(12)=12×(1− \frac{1}{2})×(1− \frac{1}{3})
$$
์ฌ๊ธฐ์ ๊ณฑ ๊ณต์์ ๊ณ์ฐํด๋ณด๋ฉด
$$
12×(1 - \frac{1}{2} - \frac{1}{3} + \frac{1}{6})
$$
์ด๋ค. ์ด๋ฅผ ๊ธ๋ก ํ์ด๋ณด๋ฉด,
$$
12×(100\% - 2์\,๋ฐฐ์์\,๋น์จ - 3์\,๋ฐฐ์์\,๋น์จ + 6์\,๋ฐฐ์์\,๋น์จ)
$$
์ด๋ค. ์์ฐ์ค๋ฝ๊ฒ ํฌํจ ๋ฐฐ์ ์ ์๋ฆฌ ๊ฐ ๋ค์ด๊ฐ ์๋ค. ๋ฐ๋ผ์ ํ์ด๋ฅผ ์จ์ ๋ชจ๋ ๋น์จ์ ๊ณฑํด์ผ ํ๋ค.
์๊ฒฐ
์ด๋ ๊ฒ ๋ชจ๋ ์์ธ์๊ฐ ์๋ ์์ ๋น์จ์ ๊ณฑํ๋ฉด (์ฆ ํ์ด๊ธฐํธ๊น์ง๋ง ๊ณ์ฐํ๋ฉด) N ์ดํ์ ์ ์ค N๊ณผ ์๋ก์์ธ ์์ ๋น์จ์ด ๋๋ค. ์ฌ๊ธฐ์ ์ ์ฒด ๊ฐ์์ธ N์ ๊ณฑํ์ฌ ์๋ก์์ ๊ฐ์๋ฅผ ๊ตฌํ๋ฉด ๋๋ ๊ฒ์ด๋ค.
์ด์ ์ค์ผ๋ฌํผ ํจ์์ ์๋ฆฌ๋ฅผ ์์๋ดค์ผ๋ ์ด๋ฅผ JAVA๋ก ๊ตฌํํด๋ณด๊ฒ ๋ค.
4. JAVA๋ก ๊ตฌํํ๋ ๋ฒ
(1) ์๋ฆฌ
์์์ ๊ตฌํ ์ค์ผ๋ฌ ํผ ํจ์(φ(n))๋ ํ๋์ N์ ๋ํด์ ๊ทธ๊ฒ๊ณผ ์๋ก์์ธ ์์ ๊ฐ์๋ฅผ ๊ตฌํ๋ค. ์ฐ๋ฆฌ๊ฐ ํ ๊ฒ์ 1๋ถํฐ N๊น์ง ์์ฐ์ ๊ฐ๊ฐ์ φ(k)์ ๊ฐ์ ๊ตฌํ ๊ฒ์ด๋ค.
์ด๋ฅผ ์ํด์ ์๋ผํ ์คํ
๋ค์ค์ ์ฒด๋ฅผ ํ์ฉํ๋ค. ์๋ผํ ์คํ
๋ค์ค์ ์ฒด์์ ์์์ ๋ฐฐ์๋ฅผ ์์ ํ์ ๋ฐฐ์ด์์ false
๋ก ๋ฐ๊พธ๋ ๊ฒ์ ์์์ ๋ฐฐ์๊ฐ i์ด๋ฉด arr[i] = arr[i] - arr[i]/P (P๋ ์์, i๋ ์์์ ๋ฐฐ์)
๋ก ๋ฐ๊พธ์ด์ฃผ๋ฉด ๋๋ค.
์ด๊ฒ ์ ๊ฐ๋ฅํ ๊น? arr[i] = arr[i] - arr[i]/P1
๋ $N×(1-\frac{1}{P_1})$๋ฅผ ํ์ด ์ด ๊ฒ๊ณผ ๊ฐ๋ค. ์ฌ๊ธฐ์ ๋ง์ฝ ์์ $P_2$๋ i๋ฅผ ๋ฐฐ์๋ก ๊ฐ์ง๋ค๋ฉด arr[i] = arr[i] - arr[i]/P2
๊ณ์ฐ์ ํ๋ฒ ๋ ํ ๊ฒ์ด๋ค. ์ด๋ $N×(1-\frac{1}{P_1})$ ์ด๋ ๊ณ์ฐ์ด ๋๋ ๊ณณ์, $(1-\frac{1}{P_2})$๋ฅผ ํ๋ฒ ๋ ๊ณฑํ๋ ๊ฒ์ด๋ค. ์ฆ ๊ฐ ๋ฐฐ์ด์ ์์๋ง๋ค
$$
\phi(N) = N \times \prod_{p \mid N} \left( 1 - \frac{1}{p} \right)
$$
๊ณ์ฐ์ ํด์ฃผ๋ ๊ฒ์ด ๋๋ค.
(2) SUDO CODE
- 0๏ธโฃ ์ด๋๊น์ง ์๋ก์์ ๊ฐ์ ์ฐพ์ ๊ฑด์ง N ์ ๋ ฅ ๋ฐ๊ธฐ
- 1๏ธโฃ ์๋ผํ ์คํ ๋ค์ค์ ์ฒด ๊ตฌํํด์ N๊ฐ์ ์์ญ ๋ด์ ์์ ์ฐพ๊ธฐ โ ์๋ ํ๋ฏ์ด ์์ ํ์ ๋ฐฐ์ด ๋ง๋ค๊ธฐ
- 2๏ธโฃ ์ค์ผ๋ฌ์ ํผ ์ํ
- 2-1) 1๋ฒ์์ ์์ฑํ ์์ ํ์ ๋ฐฐ์ด ์กฐํ
- 2-2) ์์์ ์์ p๋ฅผ ๋ง๋๋ฉด ํด๋น ์์์ ๋ฐฐ์๋ค(์ดํ k)์ ๋ํ์ฌ euler_arr[k] = euler[k] - euler_arr[k]/p ํด์ฃผ๊ธฐ
(3) JAVA CODE
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main {
static int N;
static boolean [] is_prime;
static int [] euler_arr;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
N = Integer.parseInt(br.readLine());
is_prime = new boolean [N + 1];
prime_sieve(N);
euler_phi_f(N);
System.out.println(Arrays.toString(euler_arr));
}
public static void prime_sieve(int n){
Arrays.fill(is_prime, true);
for (int i = 2; i <= Math.sqrt(n); i++) {
if(is_prime[i]){
for (int j = i*i; j <= n; j*=i) {
is_prime[j] = false;
}
}
}
}
public static void euler_phi_f(int n){
euler_arr = new int[n + 1];
for (int i = 1; i <= N; i++) {
euler_arr[i] = i;
}
for (int i = 2; i <= N; i++) {
if(is_prime[i]){
for (int j = i; j <= N; j+=i) {
euler_arr[j] = euler_arr[j] - euler_arr[j]/i;
}
}
System.out.println("์์: "+i + "๋ฐฐ์ด ์ํฉ: " + Arrays.toString(euler_arr));
}
}
}
๋งค๋ฒ ์์๋ฅผ ํ์ฉํด ์ค์ผ๋ฌ์ ํผ ์ ์ฉ ๋ฐฐ์ด์ ๋ ๋๋ง๋ค ์ฝ์์ ์ฐ๋๋ก ํ์ผ๋, ํ ์ค ์ฉ ํ์ธํ๋ฉฐ ์ดํดํ๊ธธ ๋ฐ๋๋ค.