ํ์ฌ ์ํ์์ ๊ฐ๋ฅํ ๋ชจ๋ ํ๋ณด๊ตฐ์ ๋ฐ๋ผ ๋ค์ด๊ฐ๋ฉฐ ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ
์ฆ, ํ์ฌ ์ํ์์ ๊ฐ๋ฅํ ๋ชจ๋ ์ ํ์ง๋ฅผ ๋ค ํ๋ ์ดํด๋ณด๋ ๋ฐฉ๋ฒ์ด ๋ฐฑํธ๋ํน์ด๋ค.
-> ์ํ๊ณต๊ฐํธ๋ฆฌ๋ผ๊ณ ๋ ํ๋ค.
ํ์ฌ ์ํ์์ ๊ฐ๋ฅํ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์๊ฐํด๋ณด๋ฉฐ ๊ฒฐ๊ณผ๊น์ง ์๊ฐํด๋ณธ๋ค.
์ค๋ชฉ์ด๋ผ๊ณ ํ๋ฉด ์ด๋ ํ ํ ์๋ฅผ ๋ ๋ ์๋๊ฐ ๋์ ์, ๋์ ๋ค์ ์๋ฅผ ์๊ฐํ๋ ๊ฒ.
DFS์ ํผ๋ํ ์ ์์ง๋ง ๋ฐฑํธ๋ํน์ ๋ถํ์ํ ํ์์ ํ์ง ์๋๋ค.
์๋ฅผ ๋ค์ด, 132,234,123 ์ค 123์ ์ฐพ์๋ 132์ ์ ๊ทผํ์๋ 10์ ์๋ฆฌ์๊ฐ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ๋ค์ ์๋ก ๋ฐ๋ก ๋์ด๊ฐ๋ค.
์ฌ๊ท์ ์ฑ๊ฒฉ์ ๋๊ณ ์๋ค.
๋ฐฑํธ๋ํน ์ฝ๋๋ ์๋์ ๊ฐ์ด ํ ์ ์๋ค.
def backtrack(candidate):
# ๋ง์ฝ ํ์ฌ ํ๋ณด๊ตฐ์ด ์ ํจํ ํด๋ผ๋ฉด ์ ๋ต ์ฒ๋ฆฌํ๊ณ backtrack ํจ์๋ฅผ ์ข
๋ฃ
if find_solution(candidate):
output(candidate)
return
# ๋ฐ๋ณต๋ฌธ์ ๋๋ฉด์ ๊ฐ๋ฅํ ๋ชจ๋ ํ๋ณด๊ตฐ์ ๋ํด ํ์
for next_candidate in list_of_candidates:
# ์ ํจํ ํ๋ณด๊ตฐ์ธ ๊ฒฝ์ฐ์๋ง ํ์ ์งํ
if is_valid(next_candidate):
# ์ด ํ๋ณด๊ตฐ์ ์ฐ์ ์ถ๊ฐํ๊ณ ,
place(next_candidate)
# ํ๋ณด๊ตฐ์ ์ถ๊ฐํ ์ํ์์ ๋ค์ ํ๋ณด๊ตฐ์ ๋ํด์ ํ์ ์งํ
backtrack(next_candidate)
# ํด๋น ํ๋ณด๊ตฐ์ ๋ํ ํ์์ ์ข
๋ฃํ ์ดํ์๋ ์ ๊ฑฐ
remove(next_candidate)
import sys
n,m=map(int,sys.stdin.readline().split())
ans=[]
def back():
if len(ans)==m: #base condition
print(" ".join(map(str,ans))) #m๊ฐ๋ฅผ ๋ชจ๋ ์ ํํ์ผ๋ฉด ์ถ๋ ฅํ๊ณ
return #ํ์ฌ ์ฌ๊ท ํจ์ ์ข
๋ฃํ๋ค.
for i in range(1,n+1): #์ฌ๊ท ํจ์
if i not in ans: #i๊ฐ ์ ๋ต ๋ฆฌ์คํธ์์์ผ๋ฉด
ans.append(i) # ๋ฆฌ์คํธ์ ์ถ๊ฐ
back()
ans.pop() #return์ ํ๋ฉด ๋ค์ ์ฌ๊ธฐ๋ก ๋์์ด.
back()
import sys
input=sys.stdin.readline
n=int(input())
sys.setrecursionlimit(10 ** 4)
"""
queen์ ์ํ์ข์ฐ๋๊ฐ์ ๋ชจ๋ ๊ณต๊ฒฉ๊ฐ๋ฅ
๊ฐ์ ์ด ๋ถ๊ฐ, ๊ฐ์ ํ ๋ถ๊ฐ
๋๊ฐ์ ๋ถ๊ฐ
[ํ index+1,์ด index+1],[ํ index-1,์ด index-1] ๋ถ๊ฐ
[ํ index-1,์ด index+1],[ํ index+1,์ด index-1] ๋ถ๊ฐ
ํ์ฌ ํ์ด ๋ณด๋ํ ์ฌ์ด์ฆ(n)๋ณด๋ค ํฌ๋ฉด ๊ฐ๋ฅํ ๋ฐฉ๋ฒ ํ ๊ฐ์ง ์ฐพ์๋ค ์๊ฐํด 1์ ๋ฆฌํด.
ํ์ฌ ์นธ์ ์ด, ๋๊ฐ์ , reverse๋๊ฐ์ (์ค๋ฅธ์ชฝ ์๋ก)์ ํธ์ด ๋์์ ธ ์์ผ๋ฉด ๋ค์ ์ด๋ก ๋์ด๊ฐ๋ค.
ํ์ฌ ์นธ์ ํธ์ ๋์ ์ ์์ผ๋ฉด row,col์ ๊ณ์ฐํด์ ์ด,๋๊ฐ์ ,reverse๋๊ฐ์ ์ ๋ฃ๋๋ค
"""
cnt=0
def chess(row,cross,cross_reverse,cols):
global n
if row==n:
return 1
sol = 0
for col in range(n):
curr_cross= row-col #ํ์ฌ ๊ธฐ์ค Right to left ์๋ ๋๊ฐ์ ์ ํ-์ด
curr_cross_reverse=row+col #ํ์ฌ ๊ธฐ์ค Left to right ๋๊ฐ์ ์ ์ด๊ณผ ํ ๋ํ๊ธฐ
if (col in cols or curr_cross in cross or curr_cross_reverse in cross_reverse):
continue
cols.add(col)
cross.add(curr_cross)
cross_reverse.add(curr_cross_reverse)
sol+=chess(row+1,cross,cross_reverse,cols)
#๋ง์ฝ์ return์ด ๋์ค๋ฉด ๋๋์๊ฐ๋ฉด์ set์์ ์ถ๊ฐํ๋ ์์๋ฅผ ์ญ์ ํ๋ค..
cols.remove(col)
cross.remove(curr_cross)
cross_reverse.remove(curr_cross_reverse)
return sol
print(chess(0,set(),set(),set()))
์ ์๊ฐ์ด๊ณผ๊ฐ ๋์ฌ๊น pypy3๋ฅผ ์ฌ์ฉํ๋ ํด๊ฒฐ
๐ฉPyPy3 : JIT(Just In Time) ์ปดํ์ผ์ ์ฌ์ฉํ์ฌ ๋๋ฆฐ ์คํ์๋๋ฅผ ๊ฐ์ ํ๋ค.
Python3๊ฐ ๋ฉ๋ชจ๋ฆฌ, ์๋ ์ธก์์ ์ฐ์ธํ๊ณ , ๋ฐ๋ณต์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ PyPy3๊ฐ ์ฐ์ธํ๋ค.
import sys
n,m=map(int,sys.stdin.readline().split())
ans=[]
def back():
if len(ans)==m: #base condition
print(" ".join(map(str,ans))) #m๊ฐ๋ฅผ ๋ชจ๋ ์ ํํ์ผ๋ฉด ์ถ๋ ฅํ๊ณ
return #ํ์ฌ ์ฌ๊ท ํจ์ ์ข
๋ฃํ๋ค.
for i in range(1,n+1): #์ฌ๊ท ํจ์
if i not in ans: #i๊ฐ ์ ๋ต ๋ฆฌ์คํธ์์์ผ๋ฉด
ans.append(i) # ๋ฆฌ์คํธ์ ์ถ๊ฐ
back()
ans.pop() #return์ ํ๋ฉด ๋ค์ ์ฌ๊ธฐ๋ก ๋์์ด.
back()