1. ๋ฌธ์ ์ค๋ช
2. ์ ๊ทผ ๋ฐฉ์
KEY WORD
: ๋ธ๋ฃจํธ ํฌ์ค
(1) ๋ฌธ์์ด๋ก ๋ฐ์ ์ซ์๋ฅผ ํ ์๋ฆฟ์๊ฐ ๋๊ฒ ๋๋์ด์ ๋ฐฐ์ด์ ์ ์ฅํ๋ค.
(2) ์ ์ฒด ์ซ์๊ฐ n๊ฐ๋ผ๋ฉด ๊ทธ ์ค k๊ฐ๋ฅผ ๋ฝ์์ ๋์ดํ๋ค. (์์ด, k = 1 ~ n )
(3) ๋์ด๋ k๊ฐ์ ์๋ฅผ ํฉ์ณ์ ํ๋์ ์ซ์๋ก ๋ง๋ค๊ณ , ์์ ํ๋ณํ๋ค. (์์ ํ๋ณ๋ฒ ์ด์ฉ)
(4) ์์ ํ๋ณ์ด ํ์ ๋๋ฉด ํด๋น ์๊ฐ ์ด์ ์ ๋์๋์ง, hashSet์ผ๋ก ์ฒดํฌํ๋ค. ์์ผ๋ฉด, ์์์ ๊ฐ์๋ฅผ +1 ์ฌ๋ฆฐ๋ค.
โป์ถ์ โป
(1)
๋๋ ํ์๋ฆฌ ์๋ฅผ ํฉ์น๋ ๊ฒ์ ์๋์ ์
* 10 + ์๋ก ๋ค์ด์จ ํ ์๋ฆฌ ์
๋ก ๊ทธ๋ ๊ทธ๋ ๋ฐ๋ก ํ๋ค.
(2)
์์ ํ๋ณ๋ฒ์ ๋ชจ๋ฅธ๋ค๋ฉด, ์ ๋ฆฌ ์ ํ ์ฌ๋ ๋งํฌ๋ฅผ ๋ณด๊ณ ์ค๊ธฐ ๋ฐ๋๋ค. ํด๋น ๋งํฌ์์๋ ์ n์ ์ ๊ณฑ๊ทผ๊น์ง๋ง ๋๋ ์ ํ์ธํ๋ฉด ๋๋์ง ๋์์๋ค.
(3)
์์ ํ๋ณํ๋ ค๋ ๊ฐ์ด 1์ธ ๊ฒฝ์ฐ 1์ ์์๊ฐ ์๋๋ฏ๋ก ์์ธ ์ฒ๋ฆฌ๊ฐ ํ์ํ๋ค.
์ ์ผ ํฐ ์๋ฆฌ์๊ฐ 0์ด๋ฉด ์๋๋ฏ๋ก ex- 011
๊ทธ์ ๋ํ ์์ธ ์ฒ๋ฆฌ๋ ํด์ค๋ค.
3. ์ฝ๋ ๋ถ์
import java.io.*;
import java.util.*;
class Solution {
static int cnt = 0;
static HashSet<Integer> values = new HashSet<>();
public int solution(String numbers) {
int [] num = new int [numbers.length()];
for(int i = 0; i < numbers.length(); i++){
num[i] = numbers.charAt(i) - 48;
}
Arrays.sort(num);
for(int i = 1; i <= num.length; i ++) {
permutation(num, new boolean [num.length], 0, i, 0);
}
return cnt;
}
public void permutation(int [] num, boolean [] isVisited, int depth, int end, int now) {
// ๊ธฐ์ ์กฐ๊ฑด
if(depth == end){
if(now == 1) return;
if(isPrime(now) && !values.contains(now)) {
values.add(now);
cnt++;
}
return;
}
// ๊ณ์ฐ์
for(int i = 0; i < num.length; i++){
if(depth == 0 && num[i] == 0) continue;
if(!isVisited[i]){
isVisited[i] = true;
now = now*10 + num[i];
permutation(num, isVisited, depth+1, end, now);
now = now/10;
isVisited[i] = false;
}
}
}
// ์์ ํ๋ณ
public boolean isPrime(int v) {
for(int i = 2; i <= Math.sqrt(v); i ++){
if(v%i == 0) return false;
}
return true;
}
}