๐ ๋ฌธ์
https://www.acmicpc.net/problem/15650
๐ ๋ด๊ฐ ํผ ํ์ด
์์ ํ์๋ N๊ณผ M(1) ๊ณผ ๋น์ทํ๋ค. [1,2]์ [2,1]์ ๋ค๋ฅด๊ฒ ์ทจ๊ธํ๋ (1)๋ฒ ๋ฌธ์ ์๋ ๋ฌ๋ฆฌ (2)๋ฒ ๋ฌธ์ ๋ [1,2] ํ๋๋ง, ์ฆ ์ค๋ฆ์ฐจ์์ผ๋ก ์ด๋ฃจ์ด์ง ๋ต ํ๋๋ง ์ทจ๊ธํด์ผํ๋ค.
์ด์ DFS๊ด๋ จํด์ ํค๋งธ๋๊ฒ ๋๋ฆ ์ถฉ๊ฒฉ์ด์์ด์ ๋จธ๋ฆฟ์์ ๋ช๋ฒ์ด๊ณ ๊ธฐ์ตํ๋ฉด์ ๋ฃ์์๋ค. ๊ทธ๋์ ์ฝ๋๋ ์ฝ๊ฒ ์งค ์ ์์๋ค. ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ด๋ฃจ์ด์ง ๊ฒ๋ค๋ง ๋ฝ์๋ด๋ ๊ฒ์ธ๋ฐ,,, ๋ด๊ฐ ์๊ฐํ ๋ฐฉ์์ ๋ ๊ฐ์ง๊ฐ ์์๋ค. (๊ฒฐ๊ตญ ๋๊ฐ์ง๋ชจ๋ ํ๋ ธ์ง๋ง)
๐ stack์ ์์ด๋ ๊ฒ๋ค์ ์ค๋ฆ์ฐจ์์ ๋ ฌํ ํ, Set์ผ๋ก ์ค๋ณต์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์.
์ด๋ ๊ฒ ํด๋ ๋ต์ด ๋์ค๊ธด ํ ๊ฑฐ๋ค. (1)๋ฒ๊ณผ ๊ฐ์ ํ์ด๋ฐฉ์์ผ๋ก ํ์ด์, stack์ ๋ฐ๋ก๋ฐ๋ก printํ์ง ์๊ณ , stack์ ๋ชจ๋ ์์๋์๋ค๊ฐ, ๋์ค์ ์ถ๋ ฅํ๊ธฐ ์ ์ ์ ๋ ฌ ๋ฐ ์ค๋ณต์ฒ๋ฆฌ๋ฅผ ํด์ฃผ๋ ๋ฐฉ์์ด๋ค. ์ ๋ง, ๋ฐ๋ณด๊ฐ์ง๋ง 1์ฐจ์์ ์ผ๋ก ๊ฐ์ฅ ๋จผ์ ์๊ฐํ ์ ์๋ ๋ฐฉ๋ฒ์ด์๋ค.
ํ์ง๋ง, DFS๋ก ํ์ด๋ณด๊ณ ์ถ์ ๋ง์์ด ์ปธ๋ค. ์ด๋ ๊ฒ ํ๋ฉด 100%ํ๋ฆด๊ฒ์ด๋ผ๊ณ ํ์ ์ด ๋ค์๊ณ , ์๊ฐ์ ํ๋ ์ถฉ๋ถํด์ ํ ์ ์์์ง๋ง ์ด๋ ๊ฒ ํธ๋ ๋ฐฉ์์ ๋๋ ์ํ์ง ์์๊ธฐ ๋๋ฌธ์ ๋ฐฉ๋ฒ์ผ๋ก๋ง ์๊ฐํด๋๊ณ ๋ค๋ฅธ ํ์ด๋ฅผ ์๊ฐํ๋ค.
๐ visited๋ฅผ ๋ง๋ค์ด์ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์..
์ด ๋ฐฉ์์ ์๊ฐํ๋ค๊ฐ ํ๋ฆฌ์ง ์์์ ๋ฒ๋ ธ๋ค. ์๋๋ฉด, 1๋ถํฐ ๋ฐ๋ณตํด์ 1๋ฒ์ visited ์ฒ๋ฆฌ, 2๋ฒ์ visirted์ฒ๋ฆฌ,, ์์๋๋ก ๊ฐ๋ฉด, ์ค๋ฆ์ฐจ์์ด์ง๋ง ๋ง์ฝ 2๋ถํฐ ๋๋ค์น๋ฉด, 1์ ๋ฐฉ๋ฌธํด์ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ ์๋์ด์์ผ๋ฉด visited์ฒ๋ฆฌํด์ฃผ๊ณ stack์๋ฃ๊ณ .. ๊ฒฐ๊ตญ (1)๋ฒ๋ฌธ์ ์ ๊ฐ๋ค๋ ๊ฒ์ด๋ค... ํํํํ ๊ฒฐ๊ตญ ๊ฐ๊ตฐ..
๊ธฐ์กด (1)๋ฒ ํ์ด๋ฅผ ๋ณด๋ฉด, contains ๋ฉ์๋๋ฅผ ํตํด์ stack์ ๋ค์ด์๋์ง์ ์ฌ๋ถ๋ฅผ ํ๋จํ๋ค. ์ด๊ฒ ๋ฐ๋ก visited ์ฒ๋ฆฌ์ ๋น์ทํ ๊ธฐ๋ฅ์ ํ๊ธฐ ๋๋ฌธ์ ๋ด๊ฐ ๊ตณ์ด visited ๋ฅผ ๋ง๋ ๋ค ์ณ๋,, ๋ณ๋ค๋ฅธ ํ์ด๊ฐ ์๋๋ผ๋ ๊ฒ์ด๋ค.
โ dfs์ ๋๊ฒจ์ฃผ๋ ๊ฐ์, ์ง๊ธ ๋๊ฒจ์ฃผ๋ ๊ฐ๋ณด๋ค ํฐ๊ฐ๋ง ์ทจ๊ธํด๋ณด์.
๊ฒฐ๊ตญ, ์ธํฐ๋ท์์ ์กฐ๊ธ์ ํํธ๋ฅผ ์ป์๋ค. ์ฌ๊ธฐ์ ์ป์ ํํธ๋, ์ค๋ฆ์ฐจ์์ผ๋ก ๋์ด์๋ ๊ฒ๋ค๋ง ์ทจ๊ธํด์ผํ๊ธฐ ๋๋ฌธ์, 3๋ถํฐ ์์ํ์ผ๋ฉด ๊ตณ์ด 1๊ณผ 2๋ ์ดํด๋ณด์ง ์์๋ ๋๋ค๋ ๊ฒ์ด๋ค. ์ฆ, dfs๋ฅผ ์ฌ๊ท๋ก ๋๊ฒจ์ฃผ๋ ๊ณผ์ ์์ ํ์ฌ์ ๊ฐ๋ณด๋ค ํฐ ๊ฐ๋ค๋ง ์ทจ๊ธํ๊ฒ ๋๋ฉด? ์ค๋ฆ์ฐจ์์ผ๋ก ์ด๋ฃจ์ด์ง ๊ฒ๋ค๋ง ์์ฐ์ค๋ฝ๊ฒ ์ถ๋ ฅ๋ ๊ฒ์ด๋ค!!
๐ ์ ๋ต์ฝ๋
let NM = readLine()!.split(separator: " ").map{ Int($0)! }
let N = NM[0]
let M = NM[1]
var stack = [Int]()
private func dfs(start: Int) {
if stack.count == M {
print(stack.map{ String($0) }.joined(separator:" "))
return
}
for i in start..<N+1 {
if !stack.contains(i) {
stack.append(i)
dfs(start: i+1)
stack.removeLast()
}
}
}
dfs(start: 1)