๐ค๋ฌธ์ ํด๊ฒฐ
1. Lv4... | ํธ๋ผ์ด ์๋ฃ๊ตฌ์กฐ
2. ํธ๋ผ์ด ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌ์ฑํ๋ค.( ์ฝ๊ฒ ๋งํ์๋ฉด dict์์ dict์์ dict์์ dict.... ๊ตฌ์กฐ )
๋๋ต ์์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ ํํ๋ก ๊ตฌ์ฑํ๊ฒ ๋๋ค. ๋งจ ์์ ์ซ์๋ ๊ธธ์ด๊ฐ 5์ธ ๋จ์ด, 6์ธ ๋จ์ด
๋ค์ f๋ก ์์ํ๋ ๋จ์ด 4๊ฐ, r๋ก์์ํ๋ ๋จ์ด 4๊ฐ, o๋ก ์์ํ๋ ๋จ์ด3๊ฐ, d๋ก ์์ํ๋ ๋จ์ด 1๊ฐ... ๊ฐ ์๋ค๋ ์๋ฏธ
4. ์ฐพ๋๋ค...
๋ง์ฝ 'fro??' ์ ์ฐพ๋๋ค๊ณ ํ์
(1) ๊ธธ์ด๊ฐ 5 ์ธ ๊ณณ์ผ๋ก ๋ค์ด๊ฐ๋ค
(2) ๊ฑฐ๊ธฐ์ f ๋ก ๋ค์ด๊ฐ๋ค. cnt์๋ f๋ก ์์ํ๋ ๋จ์ด๊ฐ 4๊ฐ์๋ค๋ ๊ฒ์ ์ ์ฅํ๋ค.
(3) r ๋ก ๋ค์ด๊ฐ๋ค. cnt์๋ r๋ก ์์ํ๋ ๋จ์ด๊ฐ 4๊ฐ ์๋ค๋ ๊ฒ์ ์ ์ฅํ๋ค.
(4) o ๋ก ๋ค์ด๊ฐ๋ค. cnt์๋ o๋ก ์์ํ๋ ๋จ์ด๊ฐ 3๊ฐ ์๋ค๋ ๊ฒ์ ์ ์ฅํ๋ค.
(5) ? ๋ฅผ ๋ง๋๋ฉด cnt ๋ฅผ ๋ฆฌํด.
(6) fro ๋ก ์์ํ๋ฉด์ ๊ธธ์ด๊ฐ 5์ธ ๋จ์ด๋ ๋ง์ง๋ง์ ์ ์ฅ๋ 3๊ฐ์ด๋ค.
๐จ !!Tipํ์ง๋ง ์ด๋ ๊ฒ๋ง ํ๋ฉด ํจ์จ์ฑ 3๋ฒ์์ ํ๋ฆฐ๋ค. ์ด์ ๋ ์ฟผ๋ฆฌ๊ฐ ๋ชจ๋ '?'๋ก ๊ตฌ์ฑ๋ ๊ฒฝ์ฐ๊ฐ ์๊ธฐ ๋๋ฌธ!!!!
ํด๊ฒฐ๋ฒ: ๋จ์ด์ ๊ธธ์ด๋ ์ต๋ 1๋ง๊น์ง์ด๋ค. 1๋ง๊น์ง์ ๋ฐฐ์ด์ ๋ง๋ค๊ณ , ๊ฐ ๋จ์ด์ ๊ธธ์ด๋ง๋ค ๋ช๊ฐ์ธ์ง ์ ์ฅ
์ฟผ๋ฆฌ๊ฐ ๋ชจ๋ '?'๋ก ๊ตฌ์ฑ๋ ๋จ์ด๊ฐ ๋์ค๋ฉด ์ฐพ์ง๋ง๊ณ ๋ฆฌ์คํธ์ ์ ์ฅํด๋ ๊ฐฏ์๋ฅผ ๊บผ๋ธ๋ค.
๐ ํธ๋ผ์ด ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ์ง ์๊ณ ๋ฌธ์๋ฅผ ์๋ผ์ ํ๋ํ๋ ์ฐพ์์ค๋ ํจ์จ์ฑ 3๋ฒ๋นผ๊ณ ๋ค ์ฐพ์ ์๋ ์๋ค.
( len('asdf') ๋ ํ๋ฒ์ ์ธํ๊ณ ๊ทธ ๊ฐ์ ์จ์ฃผ์. ๊ณ์ ์ ๋ ๊ฒ ๋ถ๋ฌ์ค๋ฉด ํจ์จ ์์ข๋ค.
๋ง์ฝ ์๊ฐ์ด ์๊ณ ํธ๋ผ์ด๊ตฌ์กฐ๋ฅผ ๋ชจ๋ฅธ๋ค๋ฉด ๋ถ๋ถ์ ์๋ผ๋ ์ฑ๊ฒจ๋ณด์
๐ป์์ค ์ฝ๋
from collections import defaultdict
from collections import deque
def insert(part_trie, word):
copy_trie = part_trie
q = deque(list(word))
while q:
char = q.popleft()
if char not in copy_trie:
copy_trie[char] = [0, {}]
copy_trie[char][0] += 1
copy_trie = copy_trie[char][1]
def find(trie, query):
cnt = 0
copy_trie = trie
if len(copy_trie) == 0:
return 0
q = deque(list(query))
while q:
char = q.popleft()
if char == "?":
return cnt
else:
if char not in copy_trie:
return 0
cnt = copy_trie[char][0]
copy_trie = copy_trie[char][1]
return cnt
def solution(words, queries):
answer = []
# ํธ๋ผ์ด ์๋ฃ๊ตฌ์กฐ ํ์ฉํ๊ธฐ!
trie = defaultdict(dict)
reversed_trie = defaultdict(dict)
# !!!์ฟผ๋ฆฌ๊ฐ ๋ชจ๋ ๋ฌผ์ํ์ธ ๊ฒฝ์ฐ ์๊ฐ ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ฏ๋ก, ๋ฌธ์ ๊ธธ์ด์ ๋ฐ๋ผ ๊ฐฏ์ ์ ์ฅ
length_list = [0] * 10001
# trie ๋ง๋ค๊ธฐ
for word in words:
length_word = len(word)
length_list[length_word] += 1
insert(trie[length_word], word)
insert(reversed_trie[length_word], word[::-1])
# ์ฐพ๊ธฐ
for query in queries:
length_query = len(query)
if query.count('?') == length_query: # ์ฟผ๋ฆฌ๊ฐ ๋ชจ๋ ๋ฌผ์ํ์ธ ๊ฒฝ์ฐ
answer.append(length_list[length_query])
continue
if query[0] == "?": # ๋ฌผ์ํ๋ก ์์ํ๋ ์ฟผ๋ฆฌ
answer.append(find(reversed_trie[length_query], query[::-1]))
else:
answer.append(find(trie[length_query], query))
return answer
qqq = [
[["frodo", "front", "frost", "frozen", "frame", "kakao"], ["fro??", "????o", "fr???", "fro???", "pro?"]]
]
for q1, q2 in qqq:
print(solution(q1, q2))
๐๋ฌธ์ ํ์ธ
์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค
๋งํฌ: https://programmers.co.kr/learn/courses/30/lessons/60060
๋ฌธ์ ์ค๋ช
[๋ณธ ๋ฌธ์ ๋ ์ ํ์ฑ๊ณผ ํจ์จ์ฑ ํ ์คํธ ๊ฐ๊ฐ ์ ์๊ฐ ์๋ ๋ฌธ์ ์ ๋๋ค.]
์น๊ตฌ๋ค๋ก๋ถํฐ ์ฒ์ฌ ํ๋ก๊ทธ๋๋จธ๋ก ๋ถ๋ฆฌ๋ ํ๋ก๋๋ ์์
์ ํ๋ ์น๊ตฌ๋ก๋ถํฐ ์์ ์ด ์ข์ํ๋ ๋
ธ๋ ๊ฐ์ฌ์ ์ฌ์ฉ๋ ๋จ์ด๋ค ์ค์ ํน์ ํค์๋๊ฐ ๋ช ๊ฐ ํฌํจ๋์ด ์๋์ง ๊ถ๊ธํ๋ ํ๋ก๊ทธ๋จ์ผ๋ก ๊ฐ๋ฐํด ๋ฌ๋ผ๋ ์ ์์ ๋ฐ์์ต๋๋ค.
๊ทธ ์ ์ ์ฌํญ ์ค, ํค์๋๋ ์์ผ๋์นด๋ ๋ฌธ์์ค ํ๋์ธ '?'๊ฐ ํฌํจ๋ ํจํด ํํ์ ๋ฌธ์์ด์ ๋ปํฉ๋๋ค. ์์ผ๋์นด๋ ๋ฌธ์์ธ '?'๋ ๊ธ์ ํ๋๋ฅผ ์๋ฏธํ๋ฉฐ, ์ด๋ค ๋ฌธ์์๋ ๋งค์น๋๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด "fro??"๋ "frodo", "front", "frost" ๋ฑ์ ๋งค์น๋์ง๋ง "frame", "frozen"์๋ ๋งค์น๋์ง ์์ต๋๋ค.
๊ฐ์ฌ์ ์ฌ์ฉ๋ ๋ชจ๋ ๋จ์ด๋ค์ด ๋ด๊ธด ๋ฐฐ์ด words์ ์ฐพ๊ณ ์ ํ๋ ํค์๋๊ฐ ๋ด๊ธด ๋ฐฐ์ด queries๊ฐ ์ฃผ์ด์ง ๋, ๊ฐ ํค์๋ ๋ณ๋ก ๋งค์น๋ ๋จ์ด๊ฐ ๋ช ๊ฐ์ธ์ง ์์๋๋ก ๋ฐฐ์ด์ ๋ด์ ๋ฐํํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
๊ฐ์ฌ ๋จ์ด ์ ํ์ฌํญ
- words์ ๊ธธ์ด(๊ฐ์ฌ ๋จ์ด์ ๊ฐ์)๋ 2 ์ด์ 100,000 ์ดํ์ ๋๋ค.
- ๊ฐ ๊ฐ์ฌ ๋จ์ด์ ๊ธธ์ด๋ 1 ์ด์ 10,000 ์ดํ๋ก ๋น ๋ฌธ์์ด์ธ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
- ์ ์ฒด ๊ฐ์ฌ ๋จ์ด ๊ธธ์ด์ ํฉ์ 2 ์ด์ 1,000,000 ์ดํ์ ๋๋ค.
- ๊ฐ์ฌ์ ๋์ผ ๋จ์ด๊ฐ ์ฌ๋ฌ ๋ฒ ๋์ฌ ๊ฒฝ์ฐ ์ค๋ณต์ ์ ๊ฑฐํ๊ณ words์๋ ํ๋๋ก๋ง ์ ๊ณต๋ฉ๋๋ค.
- ๊ฐ ๊ฐ์ฌ ๋จ์ด๋ ์ค์ง ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ, ํน์๋ฌธ์๋ ์ซ์๋ ํฌํจํ์ง ์๋ ๊ฒ์ผ๋ก ๊ฐ์ ํฉ๋๋ค.
๊ฒ์ ํค์๋ ์ ํ์ฌํญ
- queries์ ๊ธธ์ด(๊ฒ์ ํค์๋ ๊ฐ์)๋ 2 ์ด์ 100,000 ์ดํ์ ๋๋ค.
- ๊ฐ ๊ฒ์ ํค์๋์ ๊ธธ์ด๋ 1 ์ด์ 10,000 ์ดํ๋ก ๋น ๋ฌธ์์ด์ธ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
- ์ ์ฒด ๊ฒ์ ํค์๋ ๊ธธ์ด์ ํฉ์ 2 ์ด์ 1,000,000 ์ดํ์ ๋๋ค.
- ๊ฒ์ ํค์๋๋ ์ค๋ณต๋ ์๋ ์์ต๋๋ค.
- ๊ฐ ๊ฒ์ ํค์๋๋ ์ค์ง ์ํ๋ฒณ ์๋ฌธ์์ ์์ผ๋์นด๋ ๋ฌธ์์ธ '?' ๋ก๋ง ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ, ํน์๋ฌธ์๋ ์ซ์๋ ํฌํจํ์ง ์๋ ๊ฒ์ผ๋ก ๊ฐ์ ํฉ๋๋ค.
- ๊ฒ์ ํค์๋๋ ์์ผ๋์นด๋ ๋ฌธ์์ธ '?'๊ฐ ํ๋ ์ด์ ํฌํจ๋ผ ์์ผ๋ฉฐ, '?'๋ ๊ฐ ๊ฒ์ ํค์๋์ ์ ๋์ฌ ์๋๋ฉด ์ ๋ฏธ์ฌ ์ค ํ๋๋ก๋ง ์ฃผ์ด์ง๋๋ค.
- ์๋ฅผ ๋ค์ด "??odo", "fro??", "?????"๋ ๊ฐ๋ฅํ ํค์๋์ ๋๋ค.
- ๋ฐ๋ฉด์ "frodo"('?'๊ฐ ์์), "fr?do"('?'๊ฐ ์ค๊ฐ์ ์์), "?ro??"('?'๊ฐ ์์ชฝ์ ์์)๋ ๋ถ๊ฐ๋ฅํ ํค์๋์ ๋๋ค.
์ ์ถ๋ ฅ ์
wordsqueriesresult
["frodo", "front", "frost", "frozen", "frame", "kakao"] | ["fro??", "????o", "fr???", "fro???", "pro?"] | [3, 2, 4, 1, 0] |
์ ์ถ๋ ฅ ์์ ๋ํ ์ค๋ช
- "fro??"๋ "frodo", "front", "frost"์ ๋งค์น๋๋ฏ๋ก 3์ ๋๋ค.
- "????o"๋ "frodo", "kakao"์ ๋งค์น๋๋ฏ๋ก 2์ ๋๋ค.
- "fr???"๋ "frodo", "front", "frost", "frame"์ ๋งค์น๋๋ฏ๋ก 4์ ๋๋ค.
- "fro???"๋ "frozen"์ ๋งค์น๋๋ฏ๋ก 1์ ๋๋ค.
- "pro?"๋ ๋งค์น๋๋ ๊ฐ์ฌ ๋จ์ด๊ฐ ์์ผ๋ฏ๋ก 0 ์ ๋๋ค.
'Algorithm Problem > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] ๋ฐฑ์ค - 9084. ๋์ (0) | 2020.09.02 |
---|---|
[python] ํ๋ก๊ทธ๋๋จธ์ค - ๋ธ๋ก ์ด๋ํ๊ธฐ(2020 KAKAO BLIND RECRUITMENT) (0) | 2020.09.01 |
[python] ํ๋ก๊ทธ๋๋จธ์ค - ๊ฒฝ์ฃผ๋ก ๊ฑด์ค (2020 ์นด์นด์ค ์ธํด์ญ) (0) | 2020.08.30 |
[python] ํ๋ก๊ทธ๋๋จธ์ค - ์๋ฌผ์ ์ ์ด์ (2020 KAKAO BLIND RECRUITMENT) (2) | 2020.08.29 |
[python] ๋ฐฑ์ค - 1309. ๋๋ฌผ์ (0) | 2020.08.28 |