ํฐ์คํ ๋ฆฌ ๋ทฐ
๐กRemark
DFS ์ฌ๊ท ํธ์ถ ์ ๋ณ๋์ด ์๋ ๋งค๊ฐ ๋ณ์๋ฅผ ๋ฃ์ ๋ ์ฃผ์ํด์ผ ํ๋ค. ๊ทธ ์ด์ ๋ ์ฌ๊ท ํธ์ถ์ ํ ๋์๋ ๋งค๋ฒ ํ๋์ root ์์ ์ด์ ๋ถ์ด๋ ๋ฐฉ์์ ์ฌ์ฉํ๋๋ฐ, root ์์ฒด์ ๋ณํ๋ฅผ ์ฃผ๋ฉด ์๋๊ณ root ์ ์ด์ ํ๋ ๋ถ์ธ ๊ฐ์ ๋ํด ์ฌ๊ท ํธ์ถํ๊ณ , ๋ค์ root ๊ทธ๋๋ก์ ๋ค๋ฅธ ์ด ํ๋๋ฅผ ๋ถ์ธ ๊ฐ์ ์ฌ๊ท ํธ์ถํ๋ ์์ผ๋ก root ์ ๋ณํ๊ฐ ์๊ฒจ์๋ ์๋๊ณ ๋งค๊ฐ ๋ณ์์๋ง ๋ณํ๋๋ ๋ชจ์์ ์ถ์ ํ ์ ์๊ฒ ๋ฃ์ด์ฃผ์ด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฌธ์
https://school.programmers.co.kr/learn/courses/30/lessons/42839
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
์ฝ๋
์์ ์ฐพ๊ธฐ ๋ฌธ์ ๋ DFS ๋ก ๋ชจ๋ ๋ง๋ค ์ ์๋ ์ซ์๋ฅผ ์์ฑํ ๋ค, ์์์ธ ๊ฒ๋ง ๊ฐ์๋ฅผ ์ธ์ด์ ๋ฐํํด์ฃผ๋ฉด ๋๋ ๋ฌธ์ ์ด๋ค. ์๋์ ๊ฐ์ ์ฝ๋๋ฅผ ์์ฑํ๋ค.
import java.util.*;
// ์ข
์ด ์กฐ๊ฐ์ด ํฉ์ด์ ธ ์์
// ์์๋ฅผ ๋ช ๊ฐ๋ฅผ ๋ง๋ค์ ์์๊น?
// ๋ฌธ์์ด numbers ๊ฐ ์ฃผ์ด์ก์ ๋,
// ๋ง๋ค ์ ์๋ ์์์ ๊ฐ์๋ฅผ ๊ตฌํ์ฌ๋ผ
// ์ฐ์ ์ซ์๋ค์ ๋ชจ๋ ๋ง๋ค๊ณ , ๊ทธ ์ค ์์๋ฅผ ์ฐพ๋๋ค.
// ์ซ์์ ์กฐํฉ์ ์ฌ๋ฌ๊ฐ์ธ๋ฐ, ์ฌ๋ฌ ์กฐํฉ ์ค ์์์ธ ๊ฒ์ ์ฐพ์ ๋ฐฉ๋ฒ์ ์ฌ๋ฌ๊ฐ์ด๋ค.
// ์ฌ๋ฌ ์ซ์์ ์กฐํฉ ๋ชจ๋ ์ฐพ์ ์ ์๋ค.
class Solution {
boolean[] visited;
char[] loopThru;
List<Integer> allNums = new ArrayList<>();
public void generate(char start, String current) {
if (start != ' ' && !allNums.contains(Integer.parseInt(current)))
allNums.add(Integer.parseInt(current));
if (current.length() == loopThru.length) {
return;
}
for (int i = 0; i < loopThru.length; i++) {
if (visited[i]) continue;
visited[i] = true;
generate(loopThru[i], current + loopThru[i]);
visited[i] = false;
}
}
public boolean isPrime(int num) {
if (num == 0 || num == 1) return false;
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) return false;
}
return true;
}
public int check(List<Integer> nums) {
int cnt = 0;
for (int n : nums) {
if (isPrime(n)) cnt++;
}
return cnt;
}
public int solution(String numbers) {
int answer = 0;
loopThru = numbers.toCharArray();
visited = new boolean[numbers.length()];
generate(' ', "");
System.out.println(allNums);
answer = check(allNums);
return answer;
}
}
'Algorithms' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] 23294๋ฒ: ์น ๋ธ๋ผ์ฐ์ 1 Java ํ์ด (0) | 2023.09.11 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] ๊ธฐ์ง๊ตญ ์ค์น (1) | 2022.12.17 |
[์๊ณ ๋ฆฌ์ฆ] Longest Common Subsequence(LCS) - 1๋ถ (0) | 2022.12.09 |
[์๊ณ ๋ฆฌ์ฆ] ํ๋ก๊ทธ๋๋จธ์ค - ๋์คํฌ ์ปจํธ๋กค๋ฌ 1๋ถ (1) | 2022.12.08 |
[์๊ณ ๋ฆฌ์ฆ] Dijkstra's algorithm 2๋ถ - ๊ตฌํ ์ค๋น (0) | 2022.12.05 |
๊ณต์ง์ฌํญ
์ต๊ทผ์ ์ฌ๋ผ์จ ๊ธ
์ต๊ทผ์ ๋ฌ๋ฆฐ ๋๊ธ
- Total
- Today
- Yesterday
๋งํฌ
TAG
- ๊ฐ์ ์๋ฒ
- ci/cd
- ๊ธฐ์ง๊ตญ ์ค์น
- Spring Boot
- DTO
- google cloud
- ์ธ์ฆ/์ธ๊ฐ
- LazyInitializationException
- ๋์ปค
- JPQL
- ์ฝํ
- JPA
- json web token
- ์ค์๊ฐ๋ฐ์ดํฐ
- ํ๋ก๊ทธ๋๋จธ์ค
- Java Data Types
- ์ง์ฐ ๋ก๋ฉ
- gitlab
- ์ญ์ง๋ ฌํ
- DeSerialization
- @RequestBody
- spring
- N+1
- ์๊ณ ๋ฆฌ์ฆ
- Jackson
- docker
- Firebase
- FCM
- ๊น๋ฉ
- JOIN FETCH
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | ||||||
2 | 3 | 4 | 5 | 6 | 7 | 8 |
9 | 10 | 11 | 12 | 13 | 14 | 15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 |
23 | 24 | 25 | 26 | 27 | 28 |
๊ธ ๋ณด๊ดํจ