1. ๋ฌธ์ ์ค๋ช ๐
๋ฌธ์ ์์ ์ํ๋ ๊ฒ์ A์ ์ ํ๋ฒํธ๋ฅผ ์น๊ณ ์๋ ์์ค์, B์ ์ ํ๋ฒํธ๋ฅผ ์์ฑ์์ผ์, B๋ก ์ ํ๊ฐ ๊ฑธ๋ฆฌ๋ ์ผ์ด ์์ผ๋ฉด ์ผ๊ด์ฑ์ด TRUE
, ์ ํ๊ฐ ํ ๋ฒ์ด๋ผ๋ ๊ฑธ๋ฆฌ๋ฉด FALSE
๋ผ๋ ๋ป์ด๋ค.
์ฆ 'ํ๋์ ์ ํ๋ฒํธ๊ฐ ๋ค๋ฅธ ์ ํ๋ฒํธ์ ์ ๋์ด๊ฐ ๋๋์ง?'๋ฅผ ํ์ธํ๋ผ๋ ๋ฌธ์ ์ด๋ค.
2. ๊ตฌํ ๋ฐฉ๋ฒ ๐๏ธ
KEY WORD
: TRI
๊ธฐ๋ณธ์ ์ธ ํธ๋ผ์ด๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ ๋ฌธ์ ๋ผ ๋ฐ๋ก ๋ถ์ฐ ์ค๋ช ํ ๊ฒ์ด ์๋ค. ์์ง ํธ๋ผ์ด์ ๋ํ ๊ฐ๋ ์ด ์๋ค๋ฉด, ๋ฏธ๋ฆฌ ํ์ต ํ๊ณ ์ค์๊ธธ ๋ฐ๋๋ค.
- 0๏ธโฃ HashMap์ ํ์ฉํ์ฌ ์ ํ์ ์ธ ํธ๋ผ์ด ๊ตฌ์กฐ ํธ๋ฆฌ๋ฅผ ๊ตฌํํ๋ค. + ๋ฌธ์์ด์ ์ฝ์ ํ๋ insert ๋งค์๋๋ฅผ ๊ตฌํํ๋ค.
- 1๏ธโฃ ๋ฌธ์์ด (์ดํ str)์ ํธ๋ผ์ด์ ์ฝ์ ํ๋ค.
- 2๏ธโฃ ๋ง์ฝ str์ ์ฝ์
ํ๋ ๋์ค์, ํ์ฌ ์กฐํ ์ค์ธ ๋ฌธ์๊ฐ ์ด๋ค ๋ฌธ์์ ๋์์ ์๋ฆฌ๋
isEnd
๊ฐTRUE
์ด๋ฉด, ๊ฑฐ๊ธฐ์ ์ฝ์ ์ ๋ฉ์ถ๊ณ ๋์จ๋ค. ์๋ํ๋ฉด, ์ด๋ฏธ str์ ์ ๋์ด๊ฐ ์กด์ฌํ๋ค๋ ์๋ฏธ์ด๋ฏธ๋ก, ํ ์ ํ๋ฒํธ ๋ชฉ๋ก์ ์ผ๊ด์ฑ์ด ์๋ค. - 3๏ธโฃ str ์ฝ์ ์ด ๋๋ฌ๋๋ฐ, ๋ง์ง๋ง ๋ฌธ์์ ์์์ด ํธ๋ผ์ด ๋ด๋ถ์ ์กด์ฌํ๋ค. ํ์ฌ ๋ฃ๊ณ ์๋ str ์์ฒด๊ฐ ์ด๋ค ๋ฌธ์์ ์ ๋์ด๊ฐ ๋๋ค๋ ์๋ฏธ ์ด๋ฏ๋ก, ์ ํ๋ฒํธ ๋ชฉ๋ก์ ์ผ๊ด์ฑ์ด ์๋ค.
- 4๏ธโฃ 2๋ฒ์ด๋ 3๋ฒ์ ํด๋น ํ๋ค๋ฉด
"NO"
์ถ๋ ฅ, ๋์ ๋ฌด์ฌํ ๋น ์ ธ๋์ค๋ฉด"YES"
์ถ๋ ฅ
(1) ์๊ฐ๋ณต์ก๋ ๋ถ์ ๐
ํ
์คํธ ์ผ์ด์ค์ ๊ฐ์ T
, ์ ํ๋ฒํธ๋ถ์ ๊ฐ์ N
, ๋ฌธ์์ด์ ๊ธธ์ด L
๋ฌธ์์ด ํ๋๋ฅผ ํธ๋ผ์ด์ ์ฝ์
ํ๋ ์๊ฐ ๋ณต์ก๋: $O(L)$
์ต์
์ ๊ฒฝ์ฐ, ๋ชจ๋ ํ
์คํธ ์ผ์ด์ค ๋ด์ ๋ชจ๋ ์ ํ๋ฒํธ๋ถ๋ฅผ ๋ชจ๋ ํธ๋ผ์ด์ ๋ฃ์ด์ผ ํจ. : $O(T * N * L)$
ํ ์คํธ ์ผ์ด์ค ๊ฐ์(์ต๋ 50๊ฐ) x ๊ฐ ํ ์คํธ ๋ณ ์ ํ ๋ฒํธ ๊ฐ์ (์ต๋ 10000๊ฐ) x (๊ฐ ์ ํ๋ฒํธ์ ์ต๋ ๊ธธ์ด 10๊ฐ) = ์ด 50๋ง๋ฒ์ ์ฐ์ฐ์ด ํ์ํจ.
๋ฐ๋ผ์ ์๊ฐ ๋ด์ ํ ์ ์์.
3. ์ฝ๋ ์๊ฐ ๐
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;
public class Main {
static int T, N;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder ans = new StringBuilder();
T = Integer.parseInt(br.readLine());
for (int t = 0; t < T; t++) {
N = Integer.parseInt(br.readLine());
Tri tri = new Tri();
boolean isValid = true;
for (int i = 0; i < N; i++) {
String now = br.readLine();
if(!tri.insert(now)) isValid = false;
}
ans.append(isValid? "YES" : "NO").append("\n");
}
System.out.println(ans);
}
}
class Tri {
Node root;
public Tri () {
root = new Node();
}
public boolean insert(String str) {
Node cur = this.root; // ์ด๊ธฐํ
for (int i = 0; i < str.length(); i++) {
char now = str.charAt(i);
cur.child.putIfAbsent(now, new Node());
cur = cur.child.get(now);
if(cur.isEnd) return false; // ํ์ฌ ๊ฐ์ ๋ฃ๊ณ ์๋ ๋์ค์ธ๋ฐ, isEnd = true ๋์ด ์์ผ๋ฉด ์ด ๋ฌธ์์ด์ ์ ๋์ฌ๊ฐ ์กด์ฌํ๋ค๋ ๋ป
}
cur.isEnd = true;
if(!cur.child.isEmpty()) return false; // ํ์ฌ ๊ฐ์ ๋ค ๋ฃ์๋๋ฐ, ํ์๋
ธ๋๊ฐ ์กด์ฌ, ์ด ๋ฌธ์์ด์ ์ด๋ค ๋ฌธ์์ด์ ์ ๋์ฌ์ด๋ค.
return true;
}
}
class Node {
HashMap<Character, Node> child;
boolean isEnd;
public Node(){
child = new HashMap<>();
this.isEnd = false;
}
}
4. ๋ฐฐ์ด ๊ฒ๋ค ๐ฏ
- N์ T ๋ฐ๊นฅ์์ ์ธ์๋ก ๋ฐ์ ์ฒ๋ฆฌํ๋ค. ใ ๊ทธ๋์ ๋ต์ด ๊ณ์ ์ด์ํ๊ฒ ๋์๋ค.
๊ตฌํ ๋ฐฉ๋ฒ
์ ๋์ค๋ 3๏ธโฃ์ ์๊ฐํด์ฃผ์ง ์์๋ค.
๊ทธ๋ ๊ฒ ๋๋ฉด, ์ ๋์ด๊ฐ ์ ๋์ด๋ฅผ ๊ฐ์ง๋ ์ ํ๋ฒํธ๋ณด๋ค ํ์์๋ก ๋์ค๋ฉด์ ๋ต์ ๊ตฌํ ์ ์๋ค.