๋ฌธ์
์์ฐ์ M๊ณผ N์ด ์ฃผ์ด์ง ๋ M์ด์ N์ดํ์ ์์ฐ์ ์ค ์์์ธ ๊ฒ์ ๋ชจ๋ ๊ณจ๋ผ ์ด๋ค ์์์ ํฉ๊ณผ ์ต์๊ฐ์ ์ฐพ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์๋ฅผ ๋ค์ด M=60, N=100์ธ ๊ฒฝ์ฐ 60์ด์ 100์ดํ์ ์์ฐ์ ์ค ์์๋ 61, 67, 71, 73, 79, 83, 89, 97 ์ด 8๊ฐ๊ฐ ์์ผ๋ฏ๋ก, ์ด๋ค ์์์ ํฉ์ 620์ด๊ณ , ์ต์๊ฐ์ 61์ด ๋๋ค.
์ ๋ ฅ
์ ๋ ฅ์ ์ฒซ์งธ ์ค์ M์ด, ๋์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค.
M๊ณผ N์ 10,000์ดํ์ ์์ฐ์์ด๋ฉฐ, M์ N๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค.
์ถ๋ ฅ
M์ด์ N์ดํ์ ์์ฐ์ ์ค ์์์ธ ๊ฒ์ ๋ชจ๋ ์ฐพ์ ์ฒซ์งธ ์ค์ ๊ทธ ํฉ์, ๋์งธ ์ค์ ๊ทธ ์ค ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
๋จ, M์ด์ N์ดํ์ ์์ฐ์ ์ค ์์๊ฐ ์์ ๊ฒฝ์ฐ๋ ์ฒซ์งธ ์ค์ -1์ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1
60
100
์์ ์ถ๋ ฅ 1
620
61
์์ ์ ๋ ฅ 2
64
65
์์ ์ถ๋ ฅ 2
-1
ํ์ด
1. M๊ณผ N์ด 10000์ดํ์ ์์ฐ์์ด๋ฏ๋ก 1~10000 ์ฌ์ด์ ์์๋ฅผ ๋ฏธ๋ฆฌ ๊ณ์ฐํ์ฌ ๋ฐฐ์ด์ ๋ฃ์ด๋๋ค.
1-1. ์์๋ 1๊ณผ ์๊ธฐ ์์ ์ผ๋ก๋ง ๋๋ ์ง๋ ์์ด๋ฏ๋ก, 2, 3, 5, …… ์์ด๋ค.
1-2. 2์ 3๋ถํฐ ๋ฐฐ์ด prime[] ์ ๋ฃ์ด๋๊ณ
1-3. 4~10000 ์ ์๊ฐ ํด๋น prime์ ์๋ก ๋๋์ด์ง๋์ง ํ์ธํ์ฌ ๋๋์ด์ง์ง ์๋ ์๋ง prime์ ์ถ๊ฐํ๋ค.
2. ์ต์๊ฐ์ ์ ์ฅํ min๊ณผ ์ด ํฉ์ ์ ์ฅํ total์ 0์ผ๋ก ์ด๊ธฐํํ๋ค.
3. ์ฃผ์ด์ง๋ m๊ณผ n ์ฌ์ด์ ์๊ฐ prime์ ์กด์ฌํ๋์ง ํ์ธํ์ฌ ์กด์ฌํ ๊ฒฝ์ฐ min์ด 0์ผ ๋๋ง ํด๋น ์๋ฅผ min์ ์ ์ฅํ๊ณ total์ ๋ํ๋ค. ( ์ต์๊ฐ์ ์ ์ฅํด์ผ ํ๊ธฐ ๋๋ฌธ์ min์ ์ด๋ฏธ ๊ฐ์ด ์์ ๊ฒฝ์ฐ์ ์ต์๊ฐ์ด ์๋ )
4. min์ด 0 ์ด๋ฉด m๊ณผ n ์ฌ์ด์ ์์๊ฐ ์กด์ฌํ์ง ์์๋ค๋ ๋ป์ด๋ฏ๋ก -1์, ๊ทธ ์ด์ธ์ total๊ณผ min์ ์ถ๋ ฅํ๋ค.
import java.util.Scanner;
public class B2581 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int prime[] = new int[1300];
int primeIdx = 1;
prime[0] = 2;
prime[1] = 3;
Loop1 :
for(int i = 4; i <= 10000; i++) {
for(int j = 0; j < primeIdx; j++) {
if(i % prime[j] == 0) {
continue Loop1;
} else {
}
}
prime[++primeIdx] = i;
}
int m = sc.nextInt();
int n = sc.nextInt();
int min = 0;
int total = 0;
for(int i = m; i <= n; i++) {
for(int j = 0; j <= primeIdx; j++) {
if(prime[j] == i) {
min = min == 0 ? prime[j] : min;
total += prime[j];
}
}
}
if(min == 0) {
System.out.println("-1");
} else {
System.out.println(total);
System.out.println(min);
}
}
}