๋ฆฌํŠธ์ฝ”๋“œ 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 ํ•ด์ฃผ๋Š” ๊ณผ์ •์„ ์ถ”๊ฐ€ํ–ˆ์Šต๋‹ˆ๋‹ค.