11/16

src/backtracking/Boj15655.java

@@ -0,0 +1,57 @@
+package backtracking;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+// https://www.acmicpc.net/problem/15655
+// N과 M (6)
+public class Boj15655 {
+    static int[] arr;
+    static int[] selected;
+    static boolean[] visited;
+    static StringBuilder sb;
+    static int N;
+    static int M;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(bf.readLine());
+        N = Integer.parseInt(st.nextToken());
+        M = Integer.parseInt(st.nextToken());
+
+
+        StringTokenizer ints = new StringTokenizer(bf.readLine());
+        arr = new int[N];
+        arr = Arrays.stream(arr)
+                .map(i -> Integer.parseInt(ints.nextToken()))
+                .sorted()
+                .toArray();
+
+        selected = new int[M];
+        sb = new StringBuilder();
+        visited = new boolean[N];
+        dfs(0, 0);
+        System.out.println(sb.toString());
+
+    }
+
+    static void dfs(int depth, int now) {
+        if (depth == M) {
+            Arrays.stream(selected).forEach(i -> sb.append(i + " "));
+            sb.append("\n");
+            return;
+        }
+
+        for (int i = now; i < N; i++) {
+            if (!visited[i]) {
+                selected[depth] = arr[i];
+                visited[i] = true;
+                dfs(depth + 1, i + 1);
+                visited[i] = false;
+            }
+        }
+    }
+}

src/backtracking/Boj15656.java

@@ -0,0 +1,54 @@
+package backtracking;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+// https://acmicpc.net/problem/15656
+// N과 M (7)
+public class Boj15656 {
+    static int[] arr;
+    static int[] selected;
+    static StringBuilder sb;
+    static int N;
+    static int M;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            N = Integer.parseInt(st.nextToken());
+            M = Integer.parseInt(st.nextToken());
+        }
+
+        arr = new int[N];
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            arr = Arrays.stream(arr)
+                    .map(i -> Integer.parseInt(st.nextToken()))
+                    .sorted()
+                    .toArray();
+        }
+        sb = new StringBuilder();
+        selected = new int[M];
+        dfs(0);
+        System.out.println(sb.toString());
+    }
+
+    static void dfs(int depth) {
+        if (depth == M) {
+            Arrays.stream(selected)
+                    .forEach(i -> sb.append(i + " "));
+            sb.append("\n");
+            return;
+        }
+
+        Arrays.stream(arr).forEach(i -> {
+                selected[depth] = i;
+                dfs(depth + 1);
+            }
+        );
+    }
+}

src/backtracking/Boj15657.java

@@ -0,0 +1,54 @@
+package backtracking;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+// https://acmicpc.net/problem/15657
+// N과 M (8)
+public class Boj15657 {
+    static int N;
+    static int M;
+    static int[] arr;
+    static int[] selected;
+    static StringBuilder sb;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            N = Integer.parseInt(st.nextToken());
+            M = Integer.parseInt(st.nextToken());
+            arr = new int[N];
+            selected = new int[M];
+        }
+
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            arr = Arrays.stream(arr)
+                    .map(i -> Integer.parseInt(st.nextToken()))
+                    .sorted()
+                    .toArray();
+        }
+
+        sb = new StringBuilder();
+        dfs(0, 0);
+        System.out.println(sb.toString());
+    }
+
+    static void dfs(int depth, int now) {
+        if (depth == M) {
+            Arrays.stream(selected).forEach(i -> sb.append(i + " "));
+            sb.append("\n");
+            return;
+        }
+
+        for (int i = now; i < N; i++) {
+            selected[depth] = arr[i];
+            dfs(depth + 1, i);
+        }
+    }
+}

src/backtracking/Boj15663.java

@@ -0,0 +1,61 @@
+package backtracking;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.util.stream.Collectors;
+
+// https://www.acmicpc.net/problem/15663
+// N과 M (9)
+// TODO 다시 해볼 것
+public class Boj15663 {
+    static int N;
+    static int M;
+    static int[] arr;
+    static int[] selected;
+    static HashSet<String> ans = new LinkedHashSet<>();
+    static boolean[] visited;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            N = Integer.parseInt(st.nextToken());
+            M = Integer.parseInt(st.nextToken());
+            arr = new int[N];
+            visited = new boolean[N];
+            selected = new int[M];
+        }
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            arr = Arrays.stream(arr)
+                    .map(i -> Integer.parseInt(st.nextToken()))
+                    .sorted()
+                    .toArray();
+        }
+
+        dfs(0);
+        String collected = ans.stream().collect(Collectors.joining());
+        System.out.println(collected);
+    }
+
+    static void dfs(int depth) {
+        if (depth == M) {
+            StringBuilder intSb = new StringBuilder();
+            Arrays.stream(selected).forEach(i -> intSb.append(i+" "));
+            intSb.append("\n");
+            ans.add(intSb.toString());
+            return;
+        }
+
+        for (int i = 0; i < N; i++) {
+            if (visited[i]) continue;
+
+            selected[depth] = arr[i];
+            visited[i] = true;
+            dfs(depth + 1);
+            visited[i] = false;
+        }
+    }
+}

src/backtracking/Boj15664.java

@@ -0,0 +1,57 @@
+package backtracking;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+// https://www.acmicpc.net/problem/15664
+// N과 M (10)
+public class Boj15664 {
+    static int N;
+    static int M;
+    static int[] arr;
+    static int[] selected;
+    static StringBuilder sb;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            N = Integer.parseInt(st.nextToken());
+            M = Integer.parseInt(st.nextToken());
+            arr = new int[N];
+            selected = new int[M];
+        }
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            arr = Arrays.stream(arr)
+                    .map(i -> Integer.parseInt(st.nextToken()))
+                    .sorted()
+                    .toArray();
+        }
+
+        sb = new StringBuilder();
+        dfs(0, 0);
+        System.out.println(sb.toString());
+    }
+
+    static void dfs(int depth, int now) {
+        if (depth == M) {
+            Arrays.stream(selected).forEach(i -> sb.append(i + " "));
+            sb.append("\n");
+            return;
+        }
+        int before = 0;
+
+        for (int i = now; i < N; i++) {
+            if (before != arr[i]) {
+                selected[depth] = arr[i];
+                before = arr[i];
+                dfs(depth + 1, i + 1);
+            }
+
+        }
+    }
+}

src/backtracking/Boj15665.java

@@ -0,0 +1,53 @@
+package backtracking;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+// https://www.acmicpc.net/problem/15665
+// N과 M (11)
+public class Boj15665 {
+    static int N;
+    static int M;
+    static int[] arr;
+    static int[] selected;
+    static StringBuilder sb;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            N = Integer.parseInt(st.nextToken());
+            M = Integer.parseInt(st.nextToken());
+            arr = new int[N];
+            selected = new int[M];
+        }
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            arr = Arrays.stream(arr)
+                    .map(i -> Integer.parseInt(st.nextToken()))
+                    .sorted()
+                    .toArray();
+        }
+        sb = new StringBuilder();
+        dfs(0);
+        System.out.println(sb);
+    }
+    static void dfs(int depth) {
+        if (depth == M) {
+            Arrays.stream(selected).forEach(i -> sb.append(i + " "));
+            sb.append("\n");
+            return;
+        }
+        int before = 0;
+        for (int i = 0; i < N; i++) {
+            if (before == arr[i]) continue;
+            before = arr[i];
+            selected[depth] = arr[i];
+            dfs(depth + 1);
+        }
+    }
+
+}

src/backtracking/Boj15666.java

@@ -0,0 +1,54 @@
+package backtracking;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+// https://www.acmicpc.net/problem/15666
+// N과 M (12)
+public class Boj15666 {
+    static int N;
+    static int M;
+    static int[] arr;
+    static int[] selected;
+    static StringBuilder sb;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            N = Integer.parseInt(st.nextToken());
+            M = Integer.parseInt(st.nextToken());
+            arr = new int[N];
+            selected = new int[M];
+        }
+        {
+            StringTokenizer st = new StringTokenizer(bf.readLine());
+            arr = Arrays.stream(arr)
+                    .map(i -> Integer.parseInt(st.nextToken()))
+                    .sorted().toArray();
+        }
+        sb = new StringBuilder();
+        dfs(0, 0);
+        System.out.println(sb);
+    }
+
+    static void dfs(int depth, int now) {
+        if (depth == M) {
+            Arrays.stream(selected).forEach(i -> sb.append(i + " "));
+            sb.append("\n");
+            return;
+        }
+        int before = 0;
+
+        for (int i = now; i < N; i++) {
+            if (before == arr[i]) continue;
+
+            before = arr[i];
+            selected[depth] = arr[i];
+            dfs(depth + 1, i);
+        }
+    }
+}