๐ ๋ฐฑ์ค 15651๋ฒ - N๊ณผ M (3) (DFS/๋ฐฑํธ๋ํน)
๐ ๋ฐฑ์ค 15651๋ฒ - N๊ณผ M (3) (DFS/๋ฐฑํธ๋ํน)
๐ 1. ๋ฌธ์ ์ค๋ช
- 1๋ถํฐ N๊น์ง์ ์์ฐ์ ์ค์์ M๊ฐ๋ฅผ ์ค๋ณตํ์ฌ ๊ณ ๋ฅด๋ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ์ถ๋ ฅํ๋ ๋ฌธ์ ์ ๋๋ค.
- ์ค๋ณต์ด ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ์์ด(Permutation)๊ณผ ์ ์ฌํ ๋ฐฉ์์ผ๋ก ํ์ด์ผ ํฉ๋๋ค.
- ์ถ๋ ฅ์ ์ฌ์ ์์ผ๋ก ์ ๋ ฌ๋์ด์ผ ํฉ๋๋ค.
โ ์ค๋ณต์ด ๊ฐ๋ฅํ ์์ด (์ค๋ณต ์์ด)
โ 1๋ถํฐ N๊น์ง์ ์๋ฅผ ์ค๋ณต ํ์ฉํ์ฌ M๊ฐ๋ฅผ ๋ฝ์ ๋์ด
โ ์์๊ฐ ์ค์ํจ โ ์ค๋ณต ์์ด(Permutation with Repetition)
โ DFS(๋ฐฑํธ๋ํน)๋ฅผ ํ์ฉํ์ฌ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ํ์
๐ 2. ์ ๋ ฅ ๋ฐ ์ถ๋ ฅ ์์
๐น ์ ๋ ฅ ์์
3 2
๐น ์ถ๋ ฅ ์์
1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3
โ ์ฆ, 1~3๊น์ง์ ์๋ฅผ ์ค๋ณต ํฌํจํ์ฌ 2๊ฐ๋ฅผ ๋ฝ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ์ถ๋ ฅ
๐ 3. DFS(๋ฐฑํธ๋ํน) ๊ฐ๋
DFS(๋ฐฑํธ๋ํน) ๋ฐฉ์์ผ๋ก ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ํ์ํ๋ฉฐ ์ค๋ณต์ ํ์ฉํ๋ ๊ตฌ์กฐ์ ๋๋ค.
- M๊ฐ์ ์ซ์๋ฅผ ๋ชจ๋ ์ฑ์ธ ๋๊น์ง ์ฌ๊ท ํธ์ถ ์งํ
- ๊ฐ ์๋ฆฌ์์ 1๋ถํฐ N๊น์ง ๋ชจ๋ ์ซ์๋ฅผ ์ ํ ๊ฐ๋ฅ (์ค๋ณต ํ์ฉ)
- StringBuilder๋ฅผ ํ์ฉํ์ฌ ์ถ๋ ฅ ์ต์ ํ (์๊ฐ ์ด๊ณผ ๋ฐฉ์ง)
๐ 4. ์ฝ๋ ํด์ค
๐น ์ ์ฒด ์ฝ๋
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Back_15651 {
static int arr[];
static int N;
static int M;
static StringBuilder sb = new StringBuilder(); // ์ต์ ํ๋ ์ถ๋ ฅ ์ฒ๋ฆฌ
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken()); // 1~N๊น์ง์ ์์ฐ์
M = Integer.parseInt(st.nextToken()); // ๋ฝ์์ผ ํ ๊ฐ์
arr = new int[M]; // ์ ํ๋ ์ซ์๋ฅผ ์ ์ฅํ ๋ฐฐ์ด
dfs(0); // DFS ํ์ ์์
System.out.println(sb); // ๊ฒฐ๊ณผ ํ ๋ฒ์ ์ถ๋ ฅ
}
public static void dfs(int depth) {
if (depth == M) { // M๊ฐ๋ฅผ ๋ชจ๋ ์ ํํ ๊ฒฝ์ฐ
for (int i = 0; i < M; i++) {
sb.append(arr[i]).append(" ");
}
sb.append('\n'); // ์ค ๋ฐ๊ฟ ์ถ๊ฐ
return;
}
for (int i = 1; i <= N; i++) { // 1๋ถํฐ N๊น์ง ๋ชจ๋ ์ซ์ ์ ํ ๊ฐ๋ฅ (์ค๋ณต O)
arr[depth] = i; // ํ์ฌ ์์น(depth)์ ์ซ์ ์ ์ฅ
dfs(depth + 1); // ๋ค์ ์ซ์ ์ ํ์ ์ํด ์ฌ๊ท ํธ์ถ
}
}
}
๐ 5. dfs()
ํจ์ ์์ธ ๋ถ์
๐น 1๏ธโฃ ๊ธฐ์ ์กฐ๊ฑด (์ข ๋ฃ ์กฐ๊ฑด)
if (depth == M) {
for (int i = 0; i < M; i++) {
sb.append(arr[i]).append(" ");
}
sb.append('\n');
return;
}
โ ์ค๋ช
depth == M
์ด๋ฉด M๊ฐ์ ์ซ์๋ฅผ ๋ค ๋ฝ์์ผ๋ฏ๋ก ์ถ๋ ฅ ํ ์ข ๋ฃarr
๋ฐฐ์ด์ ์ ์ฅ๋ ์ซ์๋ค์sb.append()
๋ก ์ ์ฅ ํ ์ค ๋ฐ๊ฟ ์ถ๊ฐ- ์ฌ๊ท ์ข ๋ฃ ํ ์ด์ ๋จ๊ณ๋ก ๋๋์๊ฐ (๋ฐฑํธ๋ํน)
๐น 2๏ธโฃ DFS ํ์ (์ฌ๊ท ํธ์ถ)
for (int i = 1; i <= N; i++) { // 1๋ถํฐ N๊น์ง ์ ํ ๊ฐ๋ฅ (์ค๋ณต ํ์ฉ)
arr[depth] = i; // ํ์ฌ ์์น(depth)์ ์ซ์ ์ ์ฅ
dfs(depth + 1); // ๋ค์ ์ซ์ ์ ํ์ ์ํด ์ฌ๊ท ํธ์ถ
}
โ ์ค๋ช
1
๋ถํฐN
๊น์ง ๋ชจ๋ ์ซ์๋ฅผ ์ค๋ณต ํ์ฉํ์ฌ ์ ํarr[depth] = i
โ ํ์ฌ ์ ํํ ์ซ์๋ฅผarr[]
์ ์ ์ฅdfs(depth + 1)
โ ๋ค์ ์ซ์๋ฅผ ์ ํํ๊ธฐ ์ํด ์ฌ๊ท ํธ์ถ
๐ 6. DFS ์คํ ๊ณผ์
โ DFS ํธ๋ฆฌ ํํ
dfs(0) โโโโโโ 1 ์ ํ โ dfs(1) โโโโโโ 1 ์ ํ โ dfs(2) โ "1 1" ์ถ๋ ฅ ํ ๋ฐฑํธ๋ํน
โ
โโโโ 2 ์ ํ โ dfs(2) โ "1 2" ์ถ๋ ฅ ํ ๋ฐฑํธ๋ํน
โ
โโโโ 3 ์ ํ โ dfs(2) โ "1 3" ์ถ๋ ฅ ํ ๋ฐฑํธ๋ํน
โ
dfs(0) โโโโโโ 2 ์ ํ โ dfs(1) โโโโโโ 1 ์ ํ โ dfs(2) โ "2 1" ์ถ๋ ฅ ํ ๋ฐฑํธ๋ํน
โ
โโโโ 2 ์ ํ โ dfs(2) โ "2 2" ์ถ๋ ฅ ํ ๋ฐฑํธ๋ํน
โ
โโโโ 3 ์ ํ โ dfs(2) โ "2 3" ์ถ๋ ฅ ํ ๋ฐฑํธ๋ํน
โ
dfs(0) โโโโโโ 3 ์ ํ โ dfs(1) โโโโโโ 1 ์ ํ โ dfs(2) โ "3 1" ์ถ๋ ฅ ํ ๋ฐฑํธ๋ํน
โ
โโโโ 2 ์ ํ โ dfs(2) โ "3 2" ์ถ๋ ฅ ํ ๋ฐฑํธ๋ํน
โ
โโโโ 3 ์ ํ โ dfs(2) โ "3 3" ์ถ๋ ฅ ํ ๋ฐฑํธ๋ํน
โ ์ค๋ช
dfs(0)
์์1
์ ํ โdfs(1)
ํธ์ถdfs(1)
์์1
์ ํ โdfs(2)
ํธ์ถ โ โ1 1โ ์ถ๋ ฅ ํreturn
dfs(1)
์์2
์ ํ โdfs(2)
ํธ์ถ โ โ1 2โ ์ถ๋ ฅ ํreturn
- โฆ ๋ฐ๋ณตํ์ฌ ๋ชจ๋ ๊ฒฝ์ฐ ํ์
๐ 7. ๊ฒฐ๋ก
๐ DFS(๋ฐฑํธ๋ํน)๋ฅผ ํ์ฉํ์ฌ โ์ค๋ณต ๊ฐ๋ฅโํ ์์ด(์ค๋ณต ์์ด)์ ์์ฑํ๋ ๋ฌธ์
๐ ์ถ๋ ฅ ์ต์ ํ๋ฅผ ์ํด StringBuilder
๋ฅผ ํ์ฉํ์ฌ ๋น ๋ฅธ ์คํ ์๋ ์ ์ง
๐ ์๊ฐ ๋ณต์ก๋๋ O(N^M)
์ด์ง๋ง, N์ด ํฌ์ง ์์ผ๋ฏ๋ก DFS๋ก ์ถฉ๋ถํ ํด๊ฒฐ ๊ฐ๋ฅ ๐
๐ก ์ด์ โN๊ณผ Mโ ์๋ฆฌ์ฆ์ ๋ค๋ฅธ ๋ฌธ์ ๋ ์ฝ๊ฒ ํ ์ ์์! ๐ช๐ฅ
๐ ์ด์ ์ด๊ฑธ ๊ทธ๋๋ก ๋ณต์ฌํด์ ๋ธ๋ก๊ทธ์ ๋ถ์ฌ๋ฃ์ผ๋ฉด ๋งํฌ๋ค์ด ํ์์ผ๋ก ์ ๋ฆฌ๋ฉ๋๋ค. ๐
๋๊ธ๋จ๊ธฐ๊ธฐ