๋ฌธ์
ํด๋น ํฌ์คํ ์ ๋ฐฑ์ค์ N๊ณผ M (1) ์ ์ ๊ทผ๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ค๋ช ํ ๊ธ ์ ๋๋ค.
์ ๋ต ์์ค ์ฝ๋๋ฅผ ํ์ธํ์๋ ค๋ฉด solve url ์์ ํ์ธ ๊ฐ๋ฅํฉ๋๋ค.
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ๊ทผํด์ผ ํ๋์ง๋ฅผ ๋จผ์ ์๊ฐํด๋ณด์.
๋ฌธ์ ์ ๊ทผ
์ด๋ฒ ๋ฌธ์ ๋ ๋ฐฑํธ๋ํน ๋ฌธ์ ์ ๋ํ์ ์ธ ๋ฌธ์ ๋ผ๊ณ ํ ์ ์๋ค.
์ด์ ์๊ฐ๊น์ง ์ฐ๋ฆฌ๋ ๋ธ๋ฃจํธ ํฌ์ค ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ค์ ํ์๋๋ฐ, ๋ธ๋ฃจํธ ํฌ์ค ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๋ฅํ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ๋์
ํด ์ ๋ต์ ์ฐพ๋ ๋ฐฉ์์ด๋ค.
ํ์ง๋ง ์ด๋ฒ ๋ฌธ์ ์์ ๋ธ๋ฃจํธ ํฌ์ค ์๊ณ ๋ฆฌ์ฆ์ด ์๋ ๋ฐฑ ํธ๋ํน ์๊ณ ๋ฆฌ์ฆ์ด ๋์ฑ ์ ์ด์ธ๋ ค ๋ณด์ธ๋ค.
Back-Tracking ์๊ณ ๋ฆฌ์ฆ
๋ฐฑํธ๋ํน์ ๋ ธ๋์ ์ ๋ง์ฑ์ ํ๋จํ๋ค.
์ฌ๊ธฐ์ ๋
ธ๋์ ์ ๋ง์ฑ์ด๋ผ๊ณ ํจ์ ์ฝ๊ฒ ๊ฐ์ง์น๊ธฐ๋ผ๊ณ ๋ ๋ถ๋ฆฌ๋ฉฐ ํํ ์๋ก dfs์์ ๋ฐฉ๋ฌธ ํ๋์ง๋ฅผ ํ์ธํ๋ boolean[] check
์ ํด๋นํ๋ค.
์ฌ๊ธฐ์ ๋
ธ๋์ ์ ๋ง์ฑ์ ํ์ธํ๊ณ ๋ง์ฝ ์ ๋งํ์ง ์์ ๋
ธ๋๋ผ๋ฉด ํด๋น ํ์์ ๋ ๊น๊ฒ ๋ค์ด๊ฐ์ง ์๊ณ ๋ค๋ฅธ ํ์์ผ๋ก ์งํํ๊ฒ ๋๋ค.
์ด ๋ฐฉ๋ฒ์ด ๋ฐ๋ก ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ๋ค ์๋ํ๋ ๋ธ๋ฃจํธ ํฌ์ค์ ๋ค๋ฅธ์ ์ด๋ผ๊ณ ํ ์ ์๋๋ฐ, ํด๋น ๋ฌธ์ ์์๋ ์ด๋ฌํ ์ ์ ์ด์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
ํด๊ฒฐ๋ฒ
์ฐ์ ๋ฌธ์ ์์ ํ๊ณ ์ ํ๋ ๋ง์ ์ฐพ์๋ณด์.
1~N ๊น์ง ์๋ฅผ ์ค๋ณต ์์ด M๊ฐ ๋ฝ์ ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์
์๋ฅผ ๋ค์ด N๊ณผ M์ด ๊ฐ๊ฐ 3์ด๋ผ๊ณ ๊ฐ์ ํด๋ณด์.
๊ทธ๋ผ ์์ ๊ฐ์ด ์ค๋ณต์ด ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํธ๋ฆฌ์ ๊ฐ์ด ๋ํ๋ผ ์ ์๋ค.
์ฌ๊ธฐ์ ๋ฐฑํธ๋ํน ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํด๋ณด์.
๋ ธ๋์ ์ ๋ง์ฑ์ ๋ฌด์์ผ๊น?
๊ทธ๋ ๋ค ๋ฐ๋ก ์ค๋ณต์ด ์๋ ๋ ธ๋๊ฐ ๋ ธ๋์ ์ ๋ง์ฑ์ด ๋๋ค.
์ฐ๋ฆฌ๋ ์ ๋ง์ฑ์ ํ๋จํ๊ธฐ ์ํ boolean[] check
๋ฐฐ์ด์ ๋ง๋ค๊ณ ํ์ ๊ณผ์ ์์ ๊ฒฐ๊ณผ ๊ฐ์ ๋ด์ int[] arr
๋ฅผ ์์ฑํ์ฌ ์ด์ฉํ ๊ฒ์ด๋ค.
์ด ๋ฌธ์ ๋ dfs๋ก ํด๊ฒฐํ ๊ฒ์ด๋ฉฐ, N๊ณผ M์ ๋ฐ๋ ๋ณ์์ Index ๋ณ์๋ฅผ ํตํด์ ์ฌ๊ท๊ฐ ๊น์ด์ง ๋ ๋ง๋ค 1์ฉ ์ฆ๊ฐํ๋ ์ฌ๊ท ํจ์๋ฅผ ๊ตฌํํ๋ค.
๊ทธ๋ฆฌ๊ณ Index ๋ณ์๊ฐ m๊ณผ ๊ฐ์์ง๋ค๋ฉด ํธ์ถ์ ๋๋ด๊ณ ํ์ ๊ณผ์ ์์ ์ ์ฅํ arr ๊ฐ์ ์ถ๋ ฅํ์ฌ ๋ง๋ฌด๋ฆฌํ๋ฉด ๋๋ค.
์ค๋ต ํ๋ณด
๋ง์ฝ check[i] ์ ๊ฐ์ ๋ค์ false๋ก ์ง์ ํ์ง ์๋๋ค๋ฉด ๋ชจ๋ ๋ ธ๋์ ๋ํด์ dfs๊ฐ ๋์ง ์์ ๊ฒ์ด๋ค.
์ฆ ์ฒ์ ์คํํ dfs๋ง ์ถ๋ ฅ์ด ๋ ๊ฒ์ด๋ค.
์ฐ๋ฆฌ๋ ๋ชจ๋ ๋ ธ๋๋ฅผ dfsํด์ผ ํ๊ธฐ ๋๋ฌธ์ ํด๋น ๋ ธ๋๋ก ์์ํ dfs์ ํ์์ด ๋๋๋ค๋ฉด ๋ค๋ฅธ ๋ ธ๋๋ ํ์ํ ์ ์๋๋ก false๋ก ์ด๊ธฐํ ํด์ฃผ์ด์ผ ํ๋ค.
์ ๋ต ์ฝ๋
public class Main {
static boolean[] check = new boolean[10];
static int[] graph = new int[10];
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int m = input.nextInt();
dfs(0, n, m);
}
private static void dfs(int index, int n, int m) {
if(index == m) {
for(int value : graph) {
if(value != 0) System.out.print(value + " ");
}
System.out.println();
return ;
}
for (int i = 1; i <= n; i++) {
if(check[i]) continue;
check[i] = true;
graph[index] = i;
dfs(index + 1, n, m);
check[i] = false;
}
}
}
๋๊ธ