[22주차] 백제완

BOJ/1000-5000번/JW_1707.java

@@ -0,0 +1,62 @@
+import java.util.ArrayList;
+
+public class JW_1707 {
+
+    static int v, e;
+    static ArrayList<ArrayList<Integer>> edges;
+    static int[] groups;
+
+    public static void main(String[] args) throws Exception {
+        int k = read();
+        StringBuilder sb = new StringBuilder();
+        while (k-- > 0) {
+            init();
+            boolean isBipartite = true; // 이분 그래프인지 판단하는 플래그
+            // 방문하지 않은 점에 대해서 이분 그래프인지 판단
+            for (int i = 1; i < v + 1; i++)
+                if (groups[i] == 0)
+                    if (!dfs(i, 1)) {
+                        isBipartite = false;
+                        break;
+                    }
+            sb.append(isBipartite ? "YES\n" : "NO\n");
+        }
+        System.out.println(sb);
+    }
+
+    private static boolean dfs(int node, int group) {
+        groups[node] = group;               // 현재 노드 넘버링
+        for (int next : edges.get(node))
+            if (groups[next] == 0) {
+                // 그래프에 모순이 발생하면 false 반환
+                if (!dfs(next, 3 - group))
+                    return false;
+            // 그래프에 모순이 발생하면 false 반환
+            } else if (groups[next] == group)
+                return false;
+        return true;
+    }
+
+    private static void init() throws Exception {
+        v = read();
+        e = read();
+        groups = new int[v + 1];
+        edges = new ArrayList<>();
+        for (int i = 0; i < v + 1; i++)
+            edges.add(new ArrayList<>());
+        for (int i = 0; i < e; i++) {
+            int v = read(), u = read();
+            edges.get(v).add(u);
+            edges.get(u).add(v);
+        }
+    }
+
+    private static int read() throws Exception {
+        int c, n = System.in.read() & 15;
+        while ((c = System.in.read()) >= 48)
+            n = (n << 3) + (n << 1) + (c & 15);
+        if (c == 13)
+            System.in.read();
+        return n;
+    }
+}

BOJ/15001-20000번/JW_16724.java

@@ -0,0 +1,57 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class JW_16724 {
+
+    static int n, m, cnt = 0;
+    static int[] board;
+    static boolean[] visited, isCycle;
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        n = Integer.parseInt(st.nextToken());
+        m = Integer.parseInt(st.nextToken());
+        // 행, 열을 인덱스화
+        board = new int[n * m];
+        visited = new boolean[n * m];
+        isCycle = new boolean[n * m];
+        for (int i = 0; i < n; i++) {
+            char[] line = br.readLine().toCharArray();
+            for (int j = 0; j < m; j++)
+                // 다음 인덱스 계산을 편하게 하기 위해 변화량으로 변환
+                switch (line[j]) {
+                case 'U':
+                    board[i * m + j] = -m;
+                    break;
+                case 'D':
+                    board[i * m + j] = m;
+                    break;
+                case 'L':
+                    board[i * m + j] = -1;
+                    break;
+                case 'R':
+                    board[i * m + j] = +1;
+                    break;
+                }
+        }
+        // 사이클 검출
+        for (int i = 0; i < n * m; i++)
+            if (!visited[i]) {
+                dfs(i);
+            }
+        System.out.println(cnt);
+    }
+
+    private static void dfs(int cur) {
+        // 방문하지 않은 인덱스라면
+        if (!visited[cur]) {
+            visited[cur] = true;
+            dfs(cur + board[cur];); // 다음 재귀 호출
+        // 방문했다면 사이클 발생
+        } else if (!isCycle[cur])
+            cnt++;
+        isCycle[cur] = true;
+    }
+}

BOJ/15001-20000번/JW_18430.java

@@ -0,0 +1,63 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class JW_18430 {
+
+    static int n, m, maxValue = 0;
+    static int[] board;
+    static int[] dir
+
+    public static void main(String[] args) throws Exception {
+        n = read();
+        m = read();
+        dir = new int[] { -m, 1, m, -1 }; // 방향 증감
+        board = new int[n * m];
+        for (int i = 0; i < n * m; i++)
+            board[i] = read();
+        recursive(0, 0, new boolean[n * m]);
+        System.out.println(maxValue);
+    }
+
+    // 재귀로 부메랑 만들기
+    private static void recursive(int cur, int sumValue, boolean[] visited) {
+        maxValue = Math.max(maxValue, sumValue); // 최댓값 갱신
+        for (int i = cur; i < n * m; i++) {
+            // 사용되지 않은 재료
+            if (!visited[i])
+                for (int j = 0; j < 4; j++) {
+                    int next1 = i + dir[j];
+                    int next2 = i + dir[(j + 1) % 4];
+                    // 사용이 가능하다면
+                    if (isPossible(i, next1, next2, visited)) {
+                        visited[i] = visited[next1] = visited[next2] = true;    // 사용
+                        int value = board[i] * 2 + board[next1] + board[next2]; // 부메랑의 강도 계산
+                        recursive(i + 1, sumValue + value, visited);            // 다음 재귀 호출
+                        visited[i] = visited[next1] = visited[next2] = false;   // 백 트래킹
+                    }
+                }
+        }
+    }
+
+    private static boolean isPossible(int idx, int idx1, int idx2, boolean[] visited) {
+        return isValid(idx, idx1) && isValid(idx, idx2) && !visited[idx1] && !visited[idx2];
+    }
+
+    private static boolean isValid(int cur, int next) {
+        if (next < 0 || next >= n * m)
+            return false;
+        // 행의 차이가 하나 이하
+        if (Math.abs(cur % m - next % m) > 1)
+            return false;
+        return true;
+    }
+
+    private static int read() throws Exception {
+        int c, n = System.in.read() & 15;
+        while ((c = System.in.read()) >= 48)
+            n = (n << 3) + (n << 1) + (c & 15);
+        if (c == 13)
+            System.in.read();
+        return n;
+    }
+}

CodeTree/2017-2018년/JW_병원_거리_최소화하기.java

@@ -0,0 +1,63 @@
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+
+public class JW_병원_거리_최소화하기 {
+
+    static int n, m, minDistance = Integer.MAX_VALUE;
+    static ArrayList<int[]> pArr = new ArrayList<>(); // 사람들의 좌표
+    static ArrayList<int[]> hArr = new ArrayList<>(); // 병원들의 좌표
+    static int[][] distances; // 사람 → 병원의 거리
+    static int[] choices; // 조합 배열
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        n = Integer.parseInt(st.nextToken());
+        m = Integer.parseInt(st.nextToken());
+        for (int i = 0; i < n; i++) {
+            st = new StringTokenizer(br.readLine());
+            for (int j = 0; j < n; j++) {
+                int p = Integer.parseInt(st.nextToken());
+                if (p == 1)
+                    pArr.add(new int[] { i, j });
+                else if (p == 2)
+                    hArr.add(new int[] { i, j });
+            }
+        }
+        // 좌표로 거리 계산
+        distances = new int[pArr.size()][hArr.size()];
+        for (int i = 0; i < pArr.size(); i++)
+            for (int j = 0; j < hArr.size(); j++) {
+                int py = pArr.get(i)[0], px = pArr.get(i)[1];
+                int hy = hArr.get(j)[0], hx = hArr.get(j)[1];
+                distances[i][j] = Math.abs(py - hy) + Math.abs(px - hx);
+            }
+        choices = new int[m];
+        recursive(0, 0);
+        System.out.println(minDistance);
+    }
+
+    // 재귀로 조합 계산
+    private static void recursive(int depth, int p) {
+        // 종료 조건
+        if (depth == m) {
+            int totalDistance = 0;
+            for (int i = 0; i < pArr.size(); i++) {
+                int distance = Integer.MAX_VALUE;
+                // 뽑은 병원들까지의 거리들 중 최소 거리
+                for (int j = 0; j < m; j++)
+                    distance = Math.min(distance, distances[i][choices[j]]);
+                totalDistance += distance;
+            }
+            minDistance = Math.min(minDistance, totalDistance);
+            return;
+        }
+        // 다음 재귀 호출
+        for (int i = p; i < hArr.size(); i++) {
+            choices[depth] = i;
+            recursive(depth + 1, i + 1);
+        }
+    }
+}

Programmers/Level3/JW_67258.java

@@ -0,0 +1,34 @@
+import java.util.HashMap;
+import java.util.HashSet;
+
+class JW_67258 {
+    public int[] solution(String[] gems) {
+        int[] rs = { 0, 100_001 };
+        int len = gems.length, cnt = 0;
+        int l = 0, r = 0;
+        {
+            HashSet<String> hs = new HashSet<>();
+            for (String gem : gems)
+                hs.add(gem);
+            cnt = hs.size(); // 총 보석의 수
+        }
+        HashMap<String, Integer> hm = new HashMap<>();
+        // 투 포인터
+        while (r < len) {
+            String gem = gems[r++];
+            hm.put(gem, hm.getOrDefault(gem, 0) + 1);
+            while (hm.size() == cnt) {
+                // 인덱스 갱신
+                if (rs[1] - rs[0] > r - l - 1) {
+                    rs[0] = l + 1;
+                    rs[1] = r;
+                }
+                gem = gems[l++];
+                hm.put(gem, hm.get(gem) - 1);
+                if (hm.get(gem) == 0)
+                    hm.remove(gem);
+            }
+        }
+        return rs;
+    }
+}

SQL/22주차/JW_상품을_구매한_회원_비율_구하기.sql

@@ -0,0 +1,24 @@
+SELECT
+    YEAR(SALES_DATE) `YEAR`
+    , MONTH(SALES_DATE) `MONTH`
+    , COUNT(DISTINCT(A.USER_ID)) `PURCHASED_USERS`
+    , ROUND(COUNT(DISTINCT(A.USER_ID)) / (
+        SELECT
+            COUNT(USER_ID)
+        FROM
+            USER_INFO
+        WHERE
+            YEAR(JOINED) = 2021
+      ), 1) `PUCHASED_RATIO`
+FROM
+    ONLINE_SALE A
+    INNER JOIN USER_INFO B
+        ON A.USER_ID = B.USER_ID
+WHERE
+    YEAR(B.JOINED) = 2021
+GROUP BY
+    YEAR
+    , MONTH
+ORDER BY
+    YEAR
+    , MONTH