๋ฆฌํธ์ฝ๋ LeetCodeย 46 Permutations
ย ๋ฌธ์ ์ ํ์ด์ฌ python ํ์ด์
๋๋ค.
https://leetcode.com/problems/permutations/
๋ฌธ์
2์์ 9๊น์ง ์ซ์๊ฐ ์ฃผ์ด์ก์ ๋ ์ ํ ๋ฒํธ๋ก ์กฐํฉ ๊ฐ๋ฅํ ๋ชจ๋ ๋ฌธ์๋ฅผ ์ถ๋ ฅํ๋ผ.
ํ์ด
DFS๋ฅผ ํ์ฉํ ์ ์์ ์ธ ํ์ด ๋ฐฉ๋ฒ๊ณผ, ํ์ด์ฌ itertools
๋ชจ๋์ ์ฌ์ฉํ ํธ๋ฆฌํ ํ์ด ๋ฐฉ๋ฒ ๋ ๊ฐ์ง๋ฅผ ์์ฑํ์ต๋๋ค.
1. DFS๋ฅผ ํ์ฉํ ์์ด ์์ฑ
# ์์ด : DFS
class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
result = [] # ์ต์ข
์์ด ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๋ ๋ฆฌ์คํธ
prev_elements = [] # ์ง๊ธ๊น์ง ์ ํํ ์ซ์๋ค์ ์ ์ฅ (๊ฒฝ๋ก)
def dfs(elements): # ํ์ฌ ์ฌ์ฉํ ์ ์๋ ์ซ์๋ค(elements)๋ฅผ ์
๋ ฅ์ผ๋ก ๋ฐ์
# ๋ ์ด์ ์ ํํ ์ ์๋ ์ซ์๊ฐ ์๋ ๋ฆฌํ ๋
ธ๋์ผ ๋ -> ํ๋์ ์์ด์ด ์์ฑ๋ ๊ฒ
if len(elements) == 0:
result.append(prev_elements[:]) # ํ์ฌ๊น์ง ์ ํ๋ ์ซ์ ๊ฒฝ๋ก(prev_elements)๋ฅผ ๋ณต์ฌํ์ฌ ๊ฒฐ๊ณผ์ ์ถ๊ฐ
# ์์ด ์์ฑ ์ฌ๊ท ํธ์ถ
for e in elements:
next_elements = elements[:]
next_elements.remove(e)
prev_elements.append(e)
dfs(next_elements)
prev_elements.pop()
dfs(nums)
return result
class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
permute
ํจ์๋ nums๋ผ๋ ์ ์ ๋ฆฌ์คํธ๋ฅผ ๋ฐ์์, ๊ฐ๋ฅํ ๋ชจ๋ ์์ด์ ๋ฆฌ์คํธ ํํ๋ก ๋ฐํํฉ๋๋ค.- ์: nums = [1, 2, 3] โ ๊ฒฐ๊ณผ๋ [[1,2,3],[1,3,2],[2,1,3],โฆ[3,2,1]]
DFS ์ฌ๊ท ํธ์ถ
for e in elements:
next_elements = elements[:]
next_elements.remove(e)
prev_elements.append(e)
dfs(next_elements)
prev_elements.pop()
- ํ์ฌ ์ ํํ ์ ์๋ ์ซ์๋ค ์ค ํ๋(e)๋ฅผ ๊ณ ๋ฆ ๋๋ค.
- e๋ฅผ ์ ํํ ํ์ ๋ ์ด์ ํด๋น ์ซ์๋ฅผ ์ ํํ ์ ์์ผ๋ฏ๋ก elements์์ ์ ๊ฑฐํ ์ ๋ฆฌ์คํธ(next_elements)๋ฅผ ๋ง๋ญ๋๋ค.
- ๊ทธ ์ซ์๋ฅผ ํ์ฌ ๊ฒฝ๋ก(prev_elements)์ ์ถ๊ฐํ๊ณ ๋๋จธ์ง ์ซ์๋ค์ ๋์์ผ๋ก DFS๋ฅผ ์ฌ๊ท์ ์ผ๋ก ์คํํฉ๋๋ค.
- ์ฌ๊ท ํธ์ถ ์ดํ์๋ prev_elements์์ ๋ง์ง๋ง์ ์ถ๊ฐํ ์ซ์๋ฅผ ์ ๊ฑฐํ์ฌ ๋ฐฑํธ๋ํนํฉ๋๋ค.
์์
์ ๋ ฅ: nums = [1, 2, 3]
Start: prev=[] | elements=[1,2,3]
โ 1 ์ ํ โ prev=[1] | elements=[2,3]
โ 2 ์ ํ โ prev=[1,2] | elements=[3]
โ 3 ์ ํ โ prev=[1,2,3] | elements=[]
โ ์ ์ฅ: [1,2,3]
โ 3 ์ ๊ฑฐ
โ 2 ์ ๊ฑฐ
โ 3 ์ ํ โ prev=[1,3] | elements=[2]
โ 2 ์ ํ โ prev=[1,3,2] | elements=[]
โ ์ ์ฅ: [1,3,2]
โ 2 ์ ๊ฑฐ
โ 3 ์ ๊ฑฐ
โ 1 ์ ๊ฑฐ
โ 2 ์ ํ โ prev=[2] | elements=[1,3]
...
(์ด์ ๊ฐ์ด ์ด 6๊ฐ์ ์์ด์ด ์์ฑ๋จ)
์ด ์ฝ๋๋ ๋ฐฑํธ๋ํน ๊ธฐ๋ฒ์ ์ฌ์ฉํ์ฌ nums์ ๋ชจ๋ ์์ด์ ๊ตฌํฉ๋๋ค.
์ฌ๊ท ํธ์ถ์ ํตํด ํ๋์ฉ ์ ํํ๊ณ , ์ ํ์ด ์๋ฃ๋๋ฉด ๊ฒฐ๊ณผ์ ์ ์ฅํ๋ฉฐ, ์ ํ์ ๋๋๋ฆฌ๋ฉฐ(๋ฐฑํธ๋ํน) ๋ค๋ฅธ ๊ฒฝ์ฐ์ ์๋ฅผ ์๋ํฉ๋๋ค.
**์๊ฐ๋ณต์ก๋๋ O(n!)**์ ๋๋ค. ๊ฐ๋ฅํ ๋ชจ๋ ์์ด์ ์์ฑํด์ผ ํ๋ฏ๋ก, n๊ฐ์ ์ซ์์ ๋ํด n!๊ฐ์ ๊ฒฝ์ฐ์ ์๊ฐ ์๊น๋๋ค.
2. itertools ๋ชจ๋ ์ฌ์ฉ
ํ์ด์ฌ์๋ itertools
๋ผ๋ ๋ชจ๋์ด ์์ต๋๋ค. itertools
๋ชจ๋์ ๋ฐ๋ณต์ ์์ฑ์ ์ต์ ํ๋ ํจ์จ์ ์ธ ๊ธฐ๋ฅ๋ค์ ์ ๊ณตํ๋ฏ๋ก, ์ค๋ฌด์์๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ง์ ๊ตฌํํ๊ธฐ๋ณด๋ค๋ ๊ฐ๋ฅํ๋ค๋ฉด itertools
๋ชจ๋์ ์ฌ์ฉํ๋ ํธ์ด ๋ซ๊ฒ ์ต๋๋ค.
class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
return list(map(list, itertools.permutations(nums)))
itertools.permutations()
ํจ์์ ๊ฒฐ๊ณผ๋ฌผ์ ๋ฆฌ์คํธ ๋ด ํํ์
๋๋ค. ๋ฆฌํธ์ฝ๋ ๋ฌธ์ ์์๋ ๋ฆฌ์คํธ๋ฅผ ๋ฐํํ๋๋ก ์๊ตฌํ๊ธฐ ๋๋ฌธ์, ๋ฆฌ์คํธ๋ก map ํด์ฃผ๋ ๊ณผ์ ์ ์ถ๊ฐํ์ต๋๋ค.