Feat/22week (#20)

* feat: 22주차 구현

Author: J-MU

src/main/java/org/example/_22week/DecreasingNumber.java

@@ -0,0 +1,45 @@
+package org.example._22week;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class DecreasingNumber {
+
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static int N;
+    private static List<Long> decreasingNumbers = new ArrayList<>();
+
+    public static void main(String[] args) {
+        final Scanner sc = new Scanner(System.in);
+        N = sc.nextInt();
+
+
+        // 10자리가 넘어가면 감소하는 수가 될 수 없음. 9876543210 => 값이 long이여야함.
+        for (int i = 1; i <= 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                dfs(j, i - 1, i, (long) ((long) j * Math.pow(10, i - 1)));
+            }
+        }
+
+        if (decreasingNumbers.size() - 1 < N) {
+            System.out.println(-1);
+        }else{
+            System.out.println(decreasingNumbers.get(N));
+        }
+    }
+
+    private static void dfs(final int curNumber, final int curDigit, final int digit, final long value) {
+        if (curDigit == 0) {
+            decreasingNumbers.add((long) value);
+            return;
+        }
+
+        for (long k = 0; k <= curNumber - 1; k++) {
+            long newValue = (long) (value + k * Math.pow(10, curDigit - 1));
+            dfs((int) k, curDigit - 1, digit, newValue);
+        }
+    }
+}

src/main/java/org/example/_22week/FriendPalindrome.java

@@ -0,0 +1,81 @@
+package org.example._22week;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class FriendPalindrome {
+
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+    private static boolean[][] graph;
+    private static boolean[] visited;
+
+    private static int N;
+    private static int M;
+    private static int answer;
+
+    public static void main(String[] args) throws IOException {
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        N = Integer.parseInt(st.nextToken());
+        M = Integer.parseInt(st.nextToken());
+
+        visited = new boolean[N + 1];
+        graph = new boolean[N + 1][N + 1];
+        List<Pair> pairs = new ArrayList<>();
+
+        for (int i = 0; i < M; i++) {
+            st = new StringTokenizer(br.readLine());
+            final int friend1 = Integer.parseInt(st.nextToken());
+            final int friend2 = Integer.parseInt(st.nextToken());
+
+            graph[friend1][friend2] = true;
+            graph[friend2][friend1] = true;
+
+            final Pair pair = new Pair(friend1, friend2);
+            pairs.add(pair);
+        }
+
+        for (int i = 0; i < M; i++) {
+            dfs(pairs, i, 2);
+        }
+
+        System.out.println(answer < N ? answer + 1 : answer);
+    }
+
+    private static void dfs(final List<Pair> pairs, final int index, final int count) {
+        final Pair pair = pairs.get(index);
+        if (pair.isVisited()) {
+            return;
+        }
+        if (count > answer) {
+            answer = count;
+        }
+
+        for (int i = index; i < M; i++) {
+            pair.visit();
+            dfs(pairs, i, count + 2);
+            pair.visit();
+        }
+    }
+
+    private static class Pair {
+        int friend1;
+        int friend2;
+
+        public Pair(final int friend1, final int friend2) {
+            this.friend1 = friend1;
+            this.friend2 = friend2;
+        }
+
+        public void visit() {
+            visited[friend1] = !visited[friend1];
+            visited[friend2] = !visited[friend2];
+        }
+
+        public boolean isVisited() {
+            return visited[friend1] || visited[friend2];
+        }
+    }
+}

src/main/java/org/example/_22week/GoodNumberArray.java

@@ -0,0 +1,85 @@
+package org.example._22week;
+
+import java.util.Scanner;
+
+public class GoodNumberArray {
+
+    private static int[] answer;
+    private static boolean found;
+
+    public static void main(String[] args) {
+        final Scanner sc = new Scanner(System.in);
+        final int N = sc.nextInt();
+
+        for (int i = 1; i <= 3; i++) {
+            int[] numberArray = new int[N];
+            numberArray[0] = i;
+            dfs(N, 1, numberArray);
+
+            if (found) {
+                break;
+            }
+        }
+    }
+
+    public static void dfs(int digits, int depth, int[] numberArray) {
+        if (found) {
+            return;
+        }
+
+        if (depth == digits) {
+            found = true;
+            answer = numberArray.clone();
+            for (final int digit : answer) {
+                System.out.print(digit);
+            }
+            System.out.println();
+            return;
+        }
+
+        for (int i = 1; i <= 3; i++) {
+            numberArray[depth] = i;
+            if (isInvalidArray(numberArray, i, depth)) {
+                continue;
+            }
+
+            dfs(digits, depth + 1, numberArray);
+        }
+    }
+
+    private static boolean isInvalidArray(final int[] numberArray, final int targetValue, final int depth) {
+        if (numberArray[depth] == numberArray[depth - 1]) {
+            return true;
+        }
+
+        for (int j = 1; j < depth; j++) {
+            if (j == depth) {
+                continue;
+            }
+
+            if (numberArray[j] != targetValue) {
+                continue;
+            }
+
+            boolean notMatch = false;
+            for (int i = 1; i < depth - j; i++) {
+                if (j - i < 0) {
+                    notMatch = true;
+                    break;
+                }
+
+                if (numberArray[j - i] != numberArray[depth - i]) {
+                    notMatch = true;
+                    break;
+                }
+            }
+            if (notMatch) {
+                continue;
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+}

src/main/java/org/example/_22week/NandM12.java

@@ -0,0 +1,40 @@
+package org.example._22week;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class NandM12 {
+
+    public static void main(String[] args) {
+        final Scanner sc = new Scanner(System.in);
+        final int N = sc.nextInt();
+        final int M = sc.nextInt();
+
+        Set<Integer> numbersSet = new HashSet<>();
+        for (int i = 0; i < N; i++) {
+            int number = sc.nextInt();
+            numbersSet.add(number);
+        }
+
+        List<Integer> numbers = new ArrayList<>(numbersSet);
+        Collections.sort(numbers);
+
+        dfs(numbers, M, 0, new ArrayList<>());
+    }
+
+    public static void dfs(List<Integer> numbers, int targetLength, int index, List<Integer> values) {
+        if (values.size() == targetLength) {
+            for (final Integer value : values) {
+                System.out.print(value+" ");
+            }
+            System.out.println();
+            return;
+        }
+
+        for (int i = index; i < numbers.size(); i++) {
+            values.add(numbers.get(i));
+            dfs(numbers, targetLength, i, values);
+            values.remove(values.size() - 1);
+        }
+    }
+}

src/main/java/org/example/_22week/NandM4.java

@@ -0,0 +1,40 @@
+package org.example._22week;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.util.Scanner;
+
+public class NandM4 {
+
+    private static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+
+    public static void main(String[] args) throws IOException {
+        final Scanner sc = new Scanner(System.in);
+        final int N = sc.nextInt();
+        final int M = sc.nextInt();
+
+        final int[] arr = new int[M];
+        dfs(N, M, 1, 0, arr);
+        bw.flush();
+    }
+
+    public static void dfs(int N, int M, int start, int depth, int[] arr) throws IOException {
+        if (depth == M) {
+            for (int i = 0; i < M; i++) {
+                if (i == M - 1) {
+                    bw.write(arr[i] + "\n");
+                    break;
+                }
+                bw.write(arr[i] + " ");
+            }
+            return;
+        }
+
+        for (int i = start; i <= N; i++) {
+            final int[] newArray = arr.clone();
+            newArray[depth] = i;
+            dfs(N, M, i, depth + 1, newArray);
+        }
+    }
+}

src/main/java/org/example/_22week/NandM5.java

@@ -0,0 +1,59 @@
+package org.example._22week;
+
+import java.io.*;
+import java.util.*;
+
+public class NandM5 {
+
+    private static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+    private static int[] values;
+
+    public static void main(String[] args) throws IOException {
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        final int N = Integer.parseInt(st.nextToken());
+        final int M = Integer.parseInt(st.nextToken());
+
+        values = new int[N];
+        final Map<Integer, Boolean> visited = new HashMap<>();
+
+        st = new StringTokenizer(br.readLine());
+        for (int i = 0; i < N; i++) {
+            final int value = Integer.parseInt(st.nextToken());
+            visited.put(value, false);
+            values[i] = value;
+        }
+
+        values = Arrays.stream(values).sorted().toArray();
+        int[] arr = new int[M];
+
+        dfs(N, M, 0, visited, arr);
+        bw.flush();
+    }
+
+    public static void dfs(int N, int M, int depth, Map<Integer, Boolean> visited, int[] arr) throws IOException {
+        if (depth == M) {
+            for (int i = 0; i < M; i++) {
+                if (i == M - 1) {
+                    bw.write(arr[i] + "\n");
+                    break;
+                }
+                bw.write(arr[i] + " ");
+            }
+            return;
+        }
+
+        for (int i = 0; i < N; i++) {
+            final int value = values[i];
+            if (visited.get(value)) {
+                continue;
+            }
+
+            final HashMap<Integer, Boolean> newVisited = new HashMap<>(visited);
+            newVisited.put(value, true);
+            final int[] newArray = arr.clone();
+            newArray[depth] = value;
+            dfs(N, M, depth + 1, newVisited, newArray);
+        }
+    }
+}