Tags
- Python
- ๊ทธ๋ํ ํ์
- DP
- ๋ฐฑํธ๋ํน
- PGM
- ์ํ
- ๊ต์ฌ
- BOJ
- Java
- Brute Force Algorithm
- stack
- ๊ทธ๋ํ ์ด๋ก
- ๊น์ด ์ฐ์ ํ์
- ์ ์๋ก
- ์๋ฃ๊ตฌ์กฐ
- ์๋ฎฌ๋ ์ด์
- sort
- ๋ฌธ์์ด
- dfs
- BFS
- greedy
- queue
- LV2
- ๊ตฌํ
- ์ ๋ ฌ
- ๋๋น ์ฐ์ ํ์
- CodingTest
- Study
- Dynamic Programming
- SpringBoot
Archives
๊ธฐ๋ก๋ฐฉ
BOJ_5052 : ์ ํ๋ฒํธ ๋ชฉ๋ก ๋ณธ๋ฌธ
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
- t ๋ฒ์ ํ ์คํธ ๋์ n ๊ฐ์ ์ ํ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ์ ํ๋ฒํธ๊ฐ ์๋ก ์ ๋์ด๊ฐ ๋๋ ๊ฒฝ์ฐ๊ฐ ์๋์ง ํ๋จํ๋ค.
- ์ ๋์ด ๊ด๊ณ๊ฐ ์์ผ๋ฉด NO, ์์ผ๋ฉด YES๋ฅผ ์ถ๋ ฅํ๋ค.
๐ธ ๋ฌธ์ ํ์ด ๐ธ
- n๊ฐ์ ๋ฌธ์์ด๋ค์ ์๋ก ๋น๊ตํด์ผํ๋๋ฐ, n์ด 1๋ง์ด๋ฏ๋ก O(n^2)์ผ๋ก ๋น๊ตํ๋ฉด ํ ์คํธ์ผ์ด์ค๊น์ง ํฉ์ณ์ 1์ด๋ฅผ ์ด๊ณผํ๊ฒ ๋๋ค.
- ๋ฐฉ๋ฒ์ 2๊ฐ์ง๊ฐ ์๋๋ฐ ์ ๋ ฌ ํน์ ํธ๋ผ์ด ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ๋ ๊ฒ์ด๋ค.
- ์ ๋ ฌ : ํ์ฌ ๋ฌธ์์ด๋ณด๋ค ๊ธด ๋ฌธ์์ด ํ๊ณ ๋ง ๋น๊ตํด์ ์ ๋์ด์ธ ๊ฒฝ์ฐ๊ฐ ์๋์ง ํ์ ํ๋ค.
- ํธ๋ผ์ด : ํ์ฌ ๋ฌธ์์ด์ ์ ๋์ด๋ก ํ๊ฑฐ๋, ๋ค๋ฅธ ๋ฌธ์์ด์ด ํ์ฌ ๋ฌธ์์ด์๊ฒ ์ ๋์ด์ธ์ง ํ์ธํ๋ค.
๐ธ ์ ๋ ฌ ํ์ด ์ฝ๋ ๐ธ
import java.io.*;
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
StringBuilder sb = new StringBuilder();
int T = Integer.parseInt(br.readLine());
for (int t = 0; t < T; t++) {
int n = Integer.parseInt(br.readLine());
char[][] chars = new char[n][];
for (int i = 0; i < n; i++) {
chars[i] = br.readLine().toCharArray();
}
Arrays.sort(chars, Comparator.comparingInt(o -> o.length));
if ((checkStrs(chars)))
sb.append("YES\n");
else
sb.append("NO\n");
}
bw.write(sb.toString());
bw.flush();
}
private static boolean checkStrs(char[][] chars) {
for (int i = 0; i < chars.length; i++) {
for (int j = i + 1; j < chars.length; j++) {
if (isPrefix(chars[i], chars[j]))
return false;
}
}
return true;
}
private static boolean isPrefix(char[] cs1, char[] cs2) {
for (int i = 0; i < cs1.length; i++) {
if (cs1[i] != cs2[i])
return false;
}
return true;
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- n๊ฐ์ ๋ฌธ์์ด์ ๋ชจ๋ ์ ๋ ฅ๋ฐ๊ณ , ๊ธธ์ด๋ก ์ ๋ ฌ ํ์ ์ ๋์ด ๊ด๊ณ๊ฐ ์๋์ง ํ์ ํ๋ค.
- checkStrs() ๋ฉ์๋์์ ํ์ฌ ๋ฌธ์์ด๋ณด๋ค ๋ท ์ธ๋ฑ์ค์ ๋ฌธ์์ด์ ๋น๊ตํ๋ค. ๊ธธ์ด๊ฐ ๋ ๊ธธ๊ฑฐ๋ ๊ฐ์ ๋ฌธ์์ด๋ง ๋น๊ตํ ์ ์๊ฒ ๋๋ค.
- isPrefix() ๋ฉ์๋์์ ๋ฌธ์๋ฅผ ํ๋์ฉ ๋น๊ตํ๋๋ฐ, String.charAt()์ ํจ์จ์ด ๋์๋ฏ๋ก char[] ๋ฐฐ์ด์ ์ฌ์ฉํ๋ค.
๐ธ ํธ๋ผ์ด ํ์ด ์ฝ๋ ๐ธ
import java.io.*;
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
StringBuilder sb = new StringBuilder();
int T = Integer.parseInt(br.readLine());
for (int t = 0; t < T; t++) {
int n = Integer.parseInt(br.readLine());
Trie trie = new Trie();
boolean isConsistent = true;
for (int i = 0; i < n; i++) {
if (!trie.insert(br.readLine().toCharArray()))
isConsistent = false;
}
if (isConsistent)
sb.append("YES\n");
else
sb.append("NO\n");
}
bw.write(sb.toString());
bw.flush();
}
private static class Trie { // ํธ๋ผ์ด ์๊ณ ๋ฆฌ์ฆ
private final Node rootNode = new Node(); // ๋ฃจํธ ๋
ธ๋ ์ฑ๊ธํค ์์ฑ
public boolean insert(char[] chars) {
Node node = rootNode; // ๋ฃจํธ ๋
ธ๋๋ถํฐ ์์
boolean isNewNodeCreated = false;
for (char c : chars) { // ํด๋น key๊ฐ ์์ผ๋ฉด ๋ง๋ค์ด ๋ฐํ, ์์ผ๋ฉด ๊ทธ value๋ฅผ ๋ฐํ
if (!node.chiledNode.containsKey(c)) {
node.chiledNode.put(c, new Node());
isNewNodeCreated = true;
}
node = node.chiledNode.get(c);
if (node.isEnd) { // ๋ค๋ฅธ ๋ฒํธ๊ฐ ์ด ๋ฒํธ์ ์ ๋์ด์
return false;
}
}
if (!isNewNodeCreated) {
return false; // ์ด ๋ฒํธ๊ฐ ๋ค๋ฅธ ๋ฒํธ์ ์ ๋์ด์
}
node.isEnd = true; // ๋ฌธ์์ด์ ๋ง์ง๋ง์ด ๋๋ ๋
ธ๋์
return true;
}
}
private static class Node {
final Map<Character, Node> chiledNode;
boolean isEnd;
public Node() {
this.chiledNode = new HashMap<>();
this.isEnd = false;
}
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- ํธ๋ผ์ด ์๋ฃ๊ตฌ์กฐ๋ฅผ ์์ฉํด์ ํธ๋ฆฌ์ ๋ฌธ์์ด์ ์ ์ฅํจ๊ณผ ๋์์ ์ ๋์ด ๊ด๊ณ์ธ์ง ํ์ ํ๋ค.
- ํธ๋ผ์ด ์๋ฃ๊ตฌ์กฐ๋ ๋ฌธ์์ด์ ํธ๋ฆฌ ๊ตฌ์กฐ๋ก ์ ์ฅํด์ ๊ฒ์์ ํจ์จ์ ์ผ๋ก ํ ์ ์๊ฒํ๋ค.
- ๋ฌธ์ ํ๋์ฉ map์ key๋ก ๋งตํํ๊ณ value๋ ์์ ๋ ธ๋์ด๋ค.
- ํ์ฌ ๋ ธ๋๊ฐ ๋ฌธ์์ด์ ๋ง์ง๋ง์ด ๋๋ ๋ ธ๋์ด๋ฉด boolean ๋ณ์ isEnd๋ฅผ true๋ก ์ ์ฅํ๋ค.
- ๋ฌธ์์ด์ ํธ๋ผ์ด์ ์ ์ฅํ ๋ isEnd๊ฐ true์ธ ๊ฒฝ์ฐ๋ฅผ ๋ฐ๊ฒฌํ๋ฉด, ๋ค๋ฅธ ๋ฌธ์์ด์ด ํ์ฌ ๋ฌธ์์ด์ ์ ๋์ด๊ฐ ๋๋ ๊ฒฝ์ฐ์ด๋ค.
- ๋ฌธ์์ด ์ ์ฅ์ ๋ง์ณค๋๋ฐ, ์๋ก ์์ฑ๋ ๋ ธ๋๊ฐ ์์ผ๋ฉด, ํ์ฌ ๋ฌธ์์ด์ด ๋ค๋ฅธ ๋ฌธ์์ด์ ์ ๋์ด๊ฐ ๋ ๊ฒฝ์ฐ์ด๋ค.
๐ธ end ๐ธ
- ์ฒ์์ Bruete Force๋ก ๋ชจ๋ ๋ฌธ์์ด์ contains๋ก ๋น๊ตํ๋๋ฐ ๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ๊ฐ ๋ฌ๋ค.
- ํ๊ทธ๋ฅผ ์ดํด๋ณด๋ ์ ๋ ฌ์ด ์์ด์ ์กฐ๊ธ ๊ณ ๋ฏผ ํ, ๊ธธ์ด ์ ๋ ฌ๋ก ๊ฐ๋จํ ํ์ดํ ์ ์์๋ค.
- ์ ๋ ฌ ์ ๋์ ํ์ด๋ ๊ผญ ์ฒ์๋ถํฐ ๊ณ ๋ คํด ๋ณด๋๋ก ํ์.
- ํ๊ทธ์ ํธ๋ผ์ด๋ผ๋ ๊ฒ๋ ์๊ธธ๋ ์๋ฃ๊ตฌ์กฐ ์ด๋ก ์ ์ดํด๋ณธ ๋ค ์๋กญ๊ฒ ํฌ์คํ
์ ๋ฆฌ ํ ํ์ด์๋ ์ ์ฉํด ๋ณด์๋ค.
- ์๋กญ๊ฒ ๋ฌธ์์ด ์ฒ๋ฆฌ ๋ฐฉ๋ฒ์ ์๊ฒ ๋์ด์ ์ข์ ๊ณต๋ถ๊ฐ ๋ ๊ฒ ๊ฐ๋ค.
728x90
'CodingTest > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ_1062 : ๊ฐ๋ฅด์นจ (0) | 2024.05.20 |
---|---|
[ํ๊ธฐ] ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉ์ ๋ฌธ์ญ๋์ธ์ฆ(PCCP) Lv3 ์ทจ๋ (0) | 2024.05.20 |
BOJ_1915 : ๊ฐ์ฅ ํฐ ์ ์ฌ๊ฐํ (0) | 2024.05.11 |
BOJ_11657 : ํ์๋จธ์ (0) | 2024.05.11 |
BOJ_1261 : ์๊ณ ์คํ (0) | 2024.05.10 |