1. ๋ฌธ์ ์ค๋ช ๐
(1) ๋งํฌ๐
https://www.acmicpc.net/problem/1016
(2) ํด์ค๐ต
์ ๊ณฑ ใดใด ์
: 1๋ณด๋ค ํฐ ์ ๊ณฑ ์๋ก ๋๋์ด ๋จ์ด์ง์ง ์๋ ์. ๋ฐ๋ผ์ 4์ด์ ๋ชจ๋ ์ ๊ณฑ ์๋ก ๋๋์ด ๋จ์ด์ง์ง ์์์ผ ํจ
2. ์๊ฐ์ ํ๋ฆ: ์ฝ๋๊ฐ ๋์ค๊ธฐ๊น์ง ๐๏ธ
(1) IDEA ๋์ถ๐ก
KEY WORD
: ์๋ผํ ์คํ
๋ค์ค์ ์ฒด
a. ํธ๋ ๋ฐฉํฅ
์ผ๊ตญ์ง์์ ์กฐ์กฐ๋ ์ฒ์์ ๊ฒ๋ฆด๋ผ ํญ์ ์ ํ๋ ํฉ๊ฑด์ ์๋น์ ์ก๊ธฐ ์ํด ์ฒ์ ์ง์ ๋ค์ด๊ฐ๊ธฐ ๋ณด๋ค ์ฒ์ ๋ถ์ ์ง๋ฌ์ ์ด๋ ค๊ณ ๋์ค๋ ์๋น์ ์ฃฝ์๋ค. ๊ทธ์ฒ๋ผ ๋ชจ๋ ์ ๊ณฑ ์๋ก ๋๋ ์ง์ง ์๋ ์(์ ๊ณฑ ใดใด ์)๋ฅผ ์ผ์ผํ ๊ตฌํ๋ ๊ฒ๋ณด๋ค, ์ ๊ณฑ ์๋ก ๋๋ ์ง๋ ์๋ฅผ ์ ๊ฑฐํด์ ๊ฒฐ๊ตญ์ ์ ๊ณฑ ใดใด ์๋ง ๋ฐฐ์ด์ ๋จ๊ธฐ๋ ๊ฒ์ด ๊ฐํธํ ๊ฒ์ด๋ค. ๊ทธ๋ ๋ค๋ฉด ์ด์ ๊ตฌํด์ผํ ๊ฒ์ ์ ๊ณฑ์์ ๊ทธ ๋ฐฐ์ ๋ค์ธ๋ฐ, MAX ๊ฐ ๋ํ ์ ๊ณฑ ์ ์์ฒด ์ผ ์ ์์ผ๋ฏ๋ก ์ฐ๋ฆฌ๊ฐ ๊ตฌํด์ผ ํ๋ ์ ๊ณฑ ์์ ๋ฒ์๋ $0 <= K^{2} <= MAX$ ๊ฐ ๋ ๊ฒ์ด๋ค.
a. ์ ๊ณฑ ์๋ ์ด๋๊น์ง ๊ตฌํด์ผ ํ ๊น?
์ ๊ณฑ ์($K^{2}$)๋ฅผ max์ ์ต๋๊ฐ์ธ 1์กฐ 100๋ง๊น์ง ๋ค ๊ตฌํ๋ค๋ฉด ํํ ์๊ฐ์ด๊ณผ๋ก ์ด์ด์ง ๊ฒ์ด๋ค. ํ์ง๋ง $K^{2} <= MAX$ ๋ฅผ ์ ๊ณฑ๊ทผ์ผ๋ก ๋๋๋ฉด, $K <= \sqrt{MAX}$ ๊ฐ ๋๋ค. ์ด๋ ์ต๋ $10^{6}$ ์ ๋๊น์ง๋ง K๋ฅผ ๊ตฌํ๋ฉด ๋๋ฏ๋ก ์๊ฐ ์ด๊ณผ๋ ๋์ง ์๋๋ค.
b. ์ด๋ป๊ฒ ๋ํ๋ด์ง?
min
์ ์ต๋๊ฐ์ด 1์กฐ์ฌ์ ๋๋ต ๋๊ฐํ๋ค. ํ์ง๋ง max
๋ฅผ ๋ณด๋ min๊ณผ ์ต๋ ๋ฐฑ๋ง ๋ฐ์ ์ฐจ์ด๊ฐ ๋์ง ์๋๋ค. ๋ฐ๋ผ์ ๋ฒ์ ๋ด์ ์๋ค์ ๋ฐฐ์ด๋ก ๋ํ๋ผ ์ ์์๋ค. ์ฆ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ max - min
์ด๊ณ ๋ฐฐ์ด์ index
๋ min ~ max ์ฌ์ด์ ์ซ์, value
๋ ํด๋น ์๊ฐ ์ ๊ณฑ ใดใด์์ด๋ฉด 1, ์๋๋ฉด 0์ ๋ํ๋ธ๋ค. ๋น์ฐํ index๋ฅผ min๋ถํฐ ์์ํ ์ ์์ผ๋ฏ๋ก, ์ค์ ๋ํ๋ด๋ ค๋ ์๊ฐ K๋ผ๋ฉดindex = K - min์ผ๋ก ์ด์ ์ ์กฐ์ ํ๋ค.
์ด์ ์ฐ๋ฆฌ๋ min์์ max ๊น์ง์ ์๋ค ์ค์, ์ ๊ณฑ ์์ ๋ฐฐ์
๋ค์ ์ฐพ๊ณ Value = 0์ผ๋ก ๋ง๋ค๋ฉด ๋๋ค. ํ์ง๋ง ์ฌ๊ธฐ์ ๊ฑธ๋ฆผ๋์ด ์๊ธด๋ค. ๋ฐ๋ก 'K๋ผ๋ ์์์ ์ ๊ณฑ ์์ ๋ฐฐ์ ์ค min๋ณด๋ค ํฐ ์ต์ด์ ๊ฐ์ ์ด๋ป๊ฒ ์ฐพ์๊น?' ์ด๋ค. ๋ง์ฝ ์ ๊ณฑ์์ ๋ฐฐ์๋ฅผ 1๋ถํฐ ์์ํ์ฌ ์์ ํ์์ผ๋ก ์ฐพ๋๋ค๋ฉด ๋ถ๋ช
ํ ์๊ฐ์ด๊ณผ๊ฐ ๋ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด min ์ด 1์กฐ๋ผ๊ณ ํ์ ๋, 4์ ๋ฐฐ์ ์ค 1์กฐ๋ฅผ ๋๋ ์ต์ด์ ๊ฐ์ ์ฐพ๊ธฐ ์ํด ์ฒ์๋ถํฐ ํ๋์ฉ ๊ณฑํ๋ ๊ฒ์ ์๊ฐํด๋ณด์๋ผ.
c. min๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด์ ์ ์ผ ๊ฐ๊น์ด ์ ๊ณฑ์์ ๋ฐฐ์ ์ฐพ๊ธฐ
๋ต์ ์์ธ๋ก ์ฝ๋ค. ํ์ฌ ์ฐ๋ฆฌ๊ฐ ๊ณ์ฐํ ์ ๊ณฑ ์๋ฅผ $K^{2}$๋ผ๊ณ ํ ๋, $\frac{min}{K^{2}}$์ ๋ชซ์ ์ฐพ๋๋ค. ๋ง์ฝ $\frac{min}{K^{2}}$์ ๋๋จธ์ง๊ฐ 0์ด๋ผ๋ฉด, min์ด ๊ณง ์์์ ์ด ๋ ๊ฒ์ด๋ค. ๋ง์ฝ ๋๋์ด ๋จ์ด์ง์ง ์๋๋ค๋ฉด, $K^{2}$์ min๋ณด๋ค ํฐ ์์์ ์ $K^{2} * (๋ชซ + 1)$์ด ๋ ๊ฒ์ด๋ค.
์๋ํ๋ฉด $min = K^{2} * ๋ชซ + ๋๋จธ์ง$๋ผ๋ฉด $min > K^{2} * ๋ชซ$ ์ด๋ผ๋ ์๋ฆฌ์ด๋ค. ์ด๋, $K^{2} * ๋ชซ$์ min๋ณด๋ค ์์ผ๋ฉด์ ์ ์ผ ๊ฐ๊น์ด ์๊ฐ ๋๋ค. ๋ฐ๋ผ์ ๋ค์ ๋ฐฐ์์ธ $K^{2} * (๋ชซ + 1)$์ min๋ณด๋ค ํฌ๋ฉด์ ์ ์ผ ๊ฐ๊น์ด ์๊ฐ ๋๋ค.
์ด์ ์ด ๊ฐ์ ์์์ ์ผ๋ก max๊น์ง $K^{2}$์ ๋ฐฐ์๋ฅผ ์ฐพ์ผ๋ฉด ๋๋ค.
d. ๋ฐฐ์ด ๋ด์์ ์์น ์ฐพ๊ธฐ
b๋ฒ๊น์ง ๊ตฌํ ๋ฐฐ์๋ค์ ๋ชจ๋ min ~ max ์ฌ์ด์ ๊ฐ์ด๋ค. ๋ฐ๋ผ์ ์ฐ๋ฆฌ๊ฐ ๊ตฌํ ๋ฐฐ์์ -min
์ ํด์ฃผ๋ฉด ๊ทธ๊ฒ์ด ๋ฐฐ์ด์ index๊ฐ ๋๋ค. ํด๋น index์ value๋ฅผ 0์ผ๋ก ๋ฐ๊ฟ์ฃผ๋ฉด ๋๋ค.
(2) SUDO CODE ๐
- 1๏ธโฃ 2์์ $\sqrt{MAX}$ ๊น์ง์ ์๋ฅผ ์ฐจ๋ก๋๋ก ์กฐํ ํ๋ค.
- 2๏ธโฃ 1๋ฒ์์ ์ฐพ์ ์๋ฅผ ์ ๊ณฑํด์ ์ ๊ณฑ ์($K^{2}$) ํํ๋ก ๋ง๋ ๋ค.
- 3๏ธโฃ ์์์ ํ๋ ์ค๋ช ์ฒ๋ผ min๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด์ min์ ์ ์ผ ๊ฐ๊น์ด $K^{2}$์ ๋ฐฐ์๋ฅผ ์ฐพ๋๋ค.
- 4๏ธโฃ 3๋ฒ์ ์ฐพ์ ๊ฐ์ ์์์ ์ผ๋ก ๋ฐฐ์์ ๊ณ์๋ฅผ ๋์ฌ๊ฐ๋ฉฐ ๋ฐฐ์ด์์ ์ ์ธ ํ๋ค.
- 5๏ธโฃ ๋จ์ ๊ฐ๋ค์ ๊ฐ์๋ฅผ ์ผ๋ค.
(3) ์๊ฐ๋ณต์ก๋ ๋ถ์ ๐
- $K^{2}$ ๊ตฌํ๊ธฐ: $O(10^{6})$
- ๋ฐฐ์์ ์์์ ์ฐพ๊ธฐ: $O(1)$
- ์์์ ๋ถํฐ ๋ฐฐ์ ์ง์ฐ๊ธฐ: ์ ์ผ ๋ง์ ๋ฐ๋ณต๋ฌธ์ ๋๋ ๊ฒ์ 4์ ๋ฐฐ์๋ฅผ ์ฐพ์ ๋ ์ผ ๊ฒ์ด๋ค. ๊ทธ๊ฒ์ ๋ฐ๋ณต ํ์๋ฅผ ๋ณด๋ฉด$O100,000/4$ ์ด๋ค. ์ ๊ณฑ์($K^{2}$)๊ฐ ์ปค์ง์๋ก ์ด ์ฐ์ฐํ์๋ ์ค ๊ฒ์ด๋ค. $(100,000/4 + 100,000/9 ...)$
๊ฒฐ๋ก
: $O(10^{6} * 1 * ???)$
์ฌํผ 1์ด์ 2์ต๋ฒ๋ณด๋จ ์์ ๋ฏ ใ
3. ๊ตฌํ ์ฝ๋ ๐
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
static long min, max;
static int [] nums;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st= new StringTokenizer(br.readLine());
min = Long.parseLong(st.nextToken());
max = Long.parseLong(st.nextToken());
nums = new int [(int)(max-min+1)];
Arrays.fill(nums, 1);
square_sieve();
System.out.println(Arrays.stream(nums).sum());
}
public static void square_sieve () {
for (long i = 2; i <= Math.sqrt(max); i++) {
long square = i*i;
long delete_start = 0;
if(min%square != 0) delete_start = (min/square) + 1;
else delete_start = min/square;
for (long j = delete_start; j*square <= max; j++) {
nums[(int)(j*square - min)] = 0;
}
}
}
}
4. ๋ฐฐ์ด ๊ฒ๋ค ๐ฏ
๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ๋ณด๊ณ ๋ฐฐ์ด ๊ธฐ์
System.out.println(Arrays.stream(nums).sum());
๋ฐฐ์ด์ boolean์ด ์๋๋ผ 0, 1์ ๊ฐ์ง๋ ๊ฐ์ผ๋ก ํ๊ณ , ์ ํจํ ์์น์ value = 1๋ก ๋๋๋ค. ์ดํ stream์ ์ฌ์ฉํด ๋ค ๋ํด๋ฒ๋ฆฌ๋ฉด, ๋ต์ ๋น ๋ฅด๊ฒ ๊ตฌํ ์ ์๋ค.