cons

[JAVA]388351 유연근무제

cons-ps — Sat, 24 May 2025 00:19:41 +0900

문제

https://school.programmers.co.kr/learn/courses/30/lessons/388351

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

아이디어

시간을 60분 단위로 계산하는 것이 포인트.

또한 시간이 0530과 같은 형식이 아닌 530과 같이 들어오기에 잘 잘라서 계산해야한다.

풀이

import java.util.*;
class Solution {
    public int solution(int[] schedules, int[][] timelogs, int startday) {
        int answer = 0;
        int peopleCnt = timelogs.length;
        
        int[] schedulesTime = new int[schedules.length];
        for(int i=0;i<schedulesTime.length;i++){
            String temp = String.valueOf(schedules[i]);
            schedulesTime[i] = Integer.valueOf(temp.substring(0,temp.length()/2))*60+Integer.valueOf(temp.substring(temp.length()/2));
        }
        
        boolean[] servive = new boolean[peopleCnt];
        Arrays.fill(servive,true);
        for(int i=0;i<7;i++){
            int nowDay = (startday-1+i)%7;
            if(nowDay < 5 ) {
                for(int j=0;j<peopleCnt;j++){
                    if(servive[j]){
                        String temp = String.valueOf(timelogs[j][i]);
                        int now= Integer.valueOf(temp.substring(0,temp.length()/2))*60+Integer.valueOf(temp.substring(temp.length()/2));
                        if(now>schedulesTime[j]+10){
                            servive[j] = false;
                        }
                    }
                }
                
            }
        }
        
        for(boolean s: servive){
            if(s) answer++;
        }
        return answer;
    }
}

[JAVA]389480 완전 범죄

cons-ps — Sat, 24 May 2025 00:17:40 +0900

[JAVA]389480 완전 범죄

문제

https://school.programmers.co.kr/learn/courses/30/lessons/389480

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

아이디어

bfs를 통한 완전 탐색형 구현.

but 확인했던것은 재확인하지 않도록 해야 시간 초과를 면할 수 있다.

풀이

import java.util.*;

class Solution {
   public int solution(int[][] info, int n, int m) {
        int min = Integer.MAX_VALUE;
        boolean[][] saved;
        Queue<int[]> queue = new ArrayDeque<>();
        queue.add(new int[]{0, 0});
        for (int[] in : info) {
            int now = queue.size();
            saved = new boolean[n][m];

            for (int j = 0; j < now; j++) {
                int[] poll = queue.poll();
                int nowA = poll[0];
                int nowB = poll[1];
                int mvA = nowA + in[0];
                int mvB = nowB + in[1];
                if (mvA < n && !saved[mvA][nowB]) {
                    queue.add(new int[]{mvA, nowB});
                    saved[mvA][nowB] = true;
                }
                if (mvB < m && !saved[nowA][mvB]) {
                    queue.add(new int[]{nowA, mvB});
                    saved[nowA][mvB] = true;
                }
            }
        }

        while (!queue.isEmpty()) {
            int[] poll = queue.poll();
            min = Math.min(poll[0], min);
        }
        return (min == Integer.MAX_VALUE) ? -1 : min;
    }

}

[JAVA]389479 서버 증설 횟수

cons-ps — Sat, 24 May 2025 00:15:13 +0900

[JAVA]389479 서버 증설 횟수

문제

https://school.programmers.co.kr/learn/courses/30/lessons/389479

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

아이디어

서버를 증설해야할 타이밍에 생성하고 k시간이후에 자동으로 해제 되도록 한다.

풀이

import java.util.*;
class Solution {
    public int solution(int[] players, int m, int k) {
        int servers = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int i = 0; i < 24; i++) {
            while (!pq.isEmpty() && pq.peek() <= i) {
                Integer poll = pq.poll();
                //System.out.println(poll + " 반납");
            }

            int needServers = players[i] / m;
            if (pq.size() < needServers) {
                for (int j = pq.size(); j < needServers; j++) {
                    //System.out.println(i+" 생성");
                    pq.add(i + k);
                    servers++;
                }
            }
        }

        return servers;
    }
}

[JAVA]1111 IQ 테스트

cons-ps — Mon, 14 Apr 2025 20:21:35 +0900

문제

https://www.acmicpc.net/problem/1111

아이디어

절댓값 내의 범위가 -100, 100 사이라 하여 완전 탐색을 고려하였다.

1. 실수 포인트 : -100 ~ 100 사이에서 A가 반드시 나오지 않는다. B가 커버칠수도 있다 (-100 , 99 와 같은 케이스 )

input:
3
-100 -99 2

output:
10203

// 수열의 세 번째 수로 2가 아니라 2 이상 100 이하의 수 중 아무거나 사용하여도
// 모두 곱해지는 수의 절댓값이 100을 넘습니다.
// -100 * 101 + 10001 = -99, -99 * 101 + 10001 = 2

출처 : https://www.acmicpc.net/board/view/107405

2. 실수 포인트 : 중복 값을 비교하는 부분에서 if (isAble && next != foundNum) {

next의 값의 초기값을 잘 정해야 한다. 처음에 next로 -1을 지정해두니 -1이 다음값으로 나올 수 있는 경우가 무시된다.

Integer.MAX_VALUE로 변경 후 통과하였다.

풀이

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        StringTokenizer st;

        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

        if (n == 2) {
            if (arr[0] == arr[1]) {
                System.out.println(arr[0]);
                return;
            }
        }

        if (n <= 2) { //1 또는 2
            System.out.println("A");
            return;
        }

        int foundCnt = 0;
        int next = Integer.MAX_VALUE;
        int tempB;
        for (int a = -200; a <= 200 && foundCnt < 2; a++) {
            boolean isAble = true;
            tempB = arr[1] - arr[0] * a;
            for (int i = 1; i < n; i++) {
                if (arr[i - 1] * a + tempB != arr[i]) {
                    isAble = false;
                    break;
                }
            }

            int foundNum = arr[n - 1] * a + tempB;
            if (isAble && next != foundNum) {
//                System.out.println("FOUND : " + foundNum);
//                System.out.println("ABLE: " + a + " " + tempB);
                next = foundNum;
                foundCnt++;
            }
        }
//        System.out.println(foundCnt);
        System.out.println(foundCnt == 0 ? "B" : (foundCnt >= 2 ? "A" : next));
    }
}

[JAVA]1153 네 개의 소수

cons-ps — Sun, 13 Apr 2025 21:24:13 +0900

문제

https://www.acmicpc.net/problem/1153

반례 확인 : https://testcase.ac/problems/1153

1153번 네 개의 소수 - Testcase AC

반례 찾기 실행 횟수11번 반례 찾은 횟수6번 최근 1주일 실행 횟수3번

testcase.ac

아이디어

1. N미만의 소수를 모두 미리 찾는다.

2. 골드 바흐의 추측 짝수는 두개의 소수로 반드시 표현 가능하다. ( 즉, 짝수 + a + b 의 조합으로 만든다)

2-1. 짝수인 경우는 ( 2+2 + (짝수) 로 가능한지 확인)

2-2 홀수 인 경우는 ( 2+3 +(짝수)로 가능한지 확인)

풀이

package 백준.수학.에라토스테네스의체;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Boj_1153_네개의소수 {
    private static List<Integer> primes = new ArrayList<>();
    private static boolean[] isPrime;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());
        if (N < 8) {
            System.out.println("-1");
            return;
        }

        findPrimes(N);
        List<Integer> path = new ArrayList<>();
//      골드바흐의 추측 ( 짝수는 항상 두 소수의 합으로 표현이 가능하다 => 짝수가 되면 찾을수 있음)
        if (N % 2 == 0) {
            path.add(2);
            path.add(2);
            N -= 4;
        } else {
            path.add(2);
            path.add(3);
            N -= 5;
        }
        for (int prime : primes) {
            int other = N - prime;
            if (other >= 2 && isPrime[other]) {
                path.add(prime);
                path.add(other);
                break;
            }
        }

        for (int num : path) {
            System.out.print(num + " ");
        }
    }

    private static void findPrimes(int n) {
        isPrime = new boolean[n + 1];
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;

        for (int i = 2; i * i <= n; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= n; j += i) {
                    isPrime[j] = false;
                }
            }
        }

        for (int i = 2; i <= n; i++) {
            if (isPrime[i]) {
                primes.add(i);
            }
        }
    }
}

더 빠른 코드 ( 쓸모없이 이진 탐색 넣기..)

package 백준.수학.에라토스테네스의체;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class Boj_1153_수정완료 {
    private static List<Integer> primes = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        findPrimes(N);

        if (N % 2 == 0) {
            //짝수
            if (findDfs(N - 4, 2, new ArrayList<>(List.of(2, 2)))) {
                return;
            }
        } else if (N != 1) {
            //홀수 (하나는 짝수여야 한다 - 2가 포함)
            if (findDfs(N - 5, 2, new ArrayList<>(List.of(2, 3)))) {
                return;
            }
        }

        System.out.println("-1");
    }

    private static boolean findDfs(int n, int depth, List<Integer> path) {
        if (path.size() > 4)
            return false;

        if (depth == 0) {
            if (path.size() == 4 && n == 0) {
                for (Integer number : path) {
                    System.out.print(number + " ");
                }
                return true;
            }
            return false;
        }

        for (int i = upperBound(n); 0 <= i; i--) {
            path.add(primes.get(i));
            //찾음
            if (findDfs(n - primes.get(i), depth - 1, path)) {
                return true;
            }
            path.remove(path.size() - 1);
        }
        return false;
    }

    private static int upperBound(int n) {
        int start = 0;
        int end = primes.size() - 1;
        int upperBound = 0;

        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (primes.get(mid) <= n) {
                start = mid + 1;
                upperBound = mid;
            } else {
                end = mid - 1;
            }
        }
        return upperBound;
    }

    private static void findPrimes(int n) {
        boolean[] isNotPrime = new boolean[n + 1];
        isNotPrime[0] = isNotPrime[1] = true;
        for (int i = 1; i <= n; i++) {
            if (!isNotPrime[i]) {
                primes.add(i);
                for (int j = i; j <= n; j += i) {
                    isNotPrime[j] = true;
                }
            }
        }
    }
}

[JAVA]16947 서울 지하철 2호선

cons-ps — Sun, 13 Apr 2025 20:15:28 +0900

문제

https://www.acmicpc.net/problem/16947

아이디어

1. Cycle을 찾는다. -> DFS

2. Cycle에 속한 것들만 추려 거기서 부터 시작되는 것들의 Depth(distance)을 찾는다. -> BFS

실수 했던점 :

casting 오류 (Integer 과 Integer을 비교하면 reference만 비교한다. 주의 필요)

Cycle을 찾는법 : (하기 두 개의 방법은 싸이클이 하나일때만 생각한 것입니다)

1. union find ( findParents(a) == findParents(b) 인 경우면 이미 두개가 같은 부모를 향하는 것으로 싸이클임 존재함을 의미)

2. DFS (이미 방문된 노드라면 싸이클이 존재함을 의미한다)

풀이

package 백준.구현;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Boj_16947_서울지하철2호선 {
    private static List<List<Integer>> graphs = new ArrayList<>();
    private static boolean[] visited;
    private static boolean[] isInCycle;
    private static int[] distance;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        StringTokenizer st;

        int N = Integer.parseInt(br.readLine());

        for (int i = 0; i < N; i++) {
            graphs.add(new ArrayList<>());
        }
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken()) - 1;
            int b = Integer.parseInt(st.nextToken()) - 1;
            graphs.get(a).add(b);
            graphs.get(b).add(a);
        }

        visited = new boolean[N];
        isInCycle = new boolean[N];
        findCycle(0, -1, new ArrayList<>());

        distance = new int[N];
        foundDepth();

        for (int d : distance) {
            sb.append(d).append(" ");
        }
        System.out.println(sb);
    }

    //bfs
    private static void foundDepth() {
        Queue<Integer> queue = new LinkedList<>();
        visited = new boolean[graphs.size()];

        for (int i = 0; i < isInCycle.length; i++) {
            if (isInCycle[i]) {
                queue.add(i);
                visited[i] = true;
                distance[i] = 0;
            }
        }

        int tempDepth = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int current = queue.poll();
                for (Integer child : graphs.get(current)) {
                    if (!visited[child]) {
                        distance[child] = tempDepth;
                        queue.add(child);
                        visited[child] = true;
                    }
                }
            }
            tempDepth++;
        }
    }

    //dfs
    private static boolean findCycle(int current, int parent, ArrayList<Integer> path) {
        visited[current] = true;
        path.add(current);

        for (Integer next : graphs.get(current)) {
            //방향 간선으로 부모는 무시한다.
            if (next == parent) continue;

            if (visited[next]) {
                //path내의 현재 노드가 시작한 위치부터 현재까지를 싸이클로 취급한다.
                coloredCycle(next, path);
                return true;
            }

            if(findCycle(next, current, path)) return true;
        }
        path.remove(path.size() - 1);
        return false;
    }

    private static void coloredCycle(int cycleStart, ArrayList<Integer> containsPath) {
        boolean marking = false;
        //Integer을 형변화 하여 변환해야 비교 된다.
        for (int node : containsPath) {
            if (cycleStart == node) marking = true;
            if (marking) isInCycle[node] = true;
        }
    }
}

[JAVA]1377 버블 소트, 정렬

cons-ps — Sat, 12 Apr 2025 18:46:22 +0900

문제

https://www.acmicpc.net/problem/1377

아이디어

버블 소트

버블 소트는 왼쪽에서 오른쪽으로 인접한 두 값을 비교하면서,
큰 값을 오른쪽으로 한 칸씩 밀어내는 방식으로 작동한다. (즉 작은값을 기준으로 오름차순 하고 있다)
한 패스를 돌 때마다 가장 큰 값이 끝으로 보내진다.

핵심 인사이트

버블 소트에서는 큰 값이 오른쪽으로 한 칸씩 이동하므로,
가장 많이 움직인 원소가 정렬 완료 시점을 결정한다. (왼쪽으로 이동한것들)
이때 그 원소가 정렬된 위치에 도달하기까지 몇 번의 패스가 필요한지가 관건이다.

계산 방식

정렬 전 배열에서 각 값의 원래 인덱스 - 정렬된 인덱스를 계산한다.(정렬된 위치보다 원래 인덱스가 뒤에 있는 값, 앞으로 이동한 것들)
가장 큰 이동 거리에 +1을 해주면 정답이 된다. (마지막으로 움직인 그 값이 제자리 간 다음 패스에 swap이 더 이상 없어서 종료되기 때문.)

풀이

package 백준.정렬;

import java.io.*;
import java.util.*;

public class Boj_1377_버블소트 {
    static class Pair {
        int value, index;
        Pair(int value, int index) {
            this.value = value;
            this.index = index;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        Pair[] arr = new Pair[n];

        for (int i = 0; i < n; i++) {
            int num = Integer.parseInt(br.readLine());
            arr[i] = new Pair(num, i); // 값 + 원래 인덱스 저장
        }

        Arrays.sort(arr, Comparator.comparingInt(a -> a.value)); // 값 기준 정렬

        int maxMove = 0;
        for (int i = 0; i < n; i++) {
            // 원래 인덱스 - 정렬된 인덱스
            int move = arr[i].index - i;
            maxMove = Math.max(maxMove, move);
        }

        System.out.println(maxMove + 1); // 패스 수 = 최대 이동 거리 + 1
    }
}

[JAVA]22856 트리 순회 (골드 4)

cons-ps — Wed, 20 Sep 2023 22:47:38 +0900

문제

https://www.acmicpc.net/problem/22856

22856번: 트리 순회

노드가 $N$개인 이진 트리가 있다. 트리를 중위 순회와 유사하게 순회하려고 한다. 이를 유사 중위 순회라고 하자. 순회의 시작은 트리의 루트이고 순회의 끝은 중위 순회할 때 마지막 노드이다.

www.acmicpc.net

아이디어

만약 현재 노드가 유사 중위 순회의 끝이라면 유사 순위를 종료한다는 부분을 잘못 이해해서 여러 번 틀렸던 문제였습니다. 이 구문은 현재 노드가 중위 순회가 끝났다면 다시 올라가지 않아도 된다는 것을 의미합니다. 즉 왼쪽으로 가는 경우는 반드시 루트로 다시 올라와야 하지만 오른쪽의 경우는 중위순회가 끝난 상태라면 다시 올라오지 않아도 됩니다. (중위 순회 : 왼쪽 자식 -> root -> 오른쪽 자식)

따라서 왼쪽 자식을 가는 경우는 내려갔다 올라오는 점수를 모두 세 주었지만

오른쪽 자식으로 가는경우는 모든 노드를 방문한 상태라면 다시 올라오지 않고 종료하도록 하였습니다.

풀이

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Boj_22856_트리순회 {
    private static class Node {
        int root;
        Node left;
        Node right;

        public Node(int root) {
            this.root = root;
        }

        public void set(Node left, Node right) {
            this.left = left;
            this.right = right;
        }
    }

    private static int visitedCnt = 0;
    private static boolean[] visited;
    private static int n;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        n = Integer.parseInt(br.readLine());
        Node[] nodes = new Node[n];
        visited = new boolean[n];
        for (int i = 0; i < n; i++) {
            nodes[i] = new Node(i);
        }
        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken()) - 1;
            int left = Integer.parseInt(st.nextToken()) - 1;
            int right = Integer.parseInt(st.nextToken()) - 1;

            if (left != -2 && right != -2) {
                nodes[a].set(nodes[left], nodes[right]); //자식이 없는경우
            } else if (left != -2) {
                nodes[a].set(nodes[left], null); //왼쪽 자식만 있는 경우
            } else if (right != -2) {
                nodes[a].set(null, nodes[right]); //오른쪽 자식만 있는 경우
            }
        }
        System.out.println(dfs(nodes[0]));
    }

    private static int dfs(Node now) {
        //왼쪽만 있으면 다시 올라가야 하고
        //오른쪽에서 중위 순회가 끝났으면 올라가지 않아도 됨
        int score = 0;

        if (now.left != null && !visited[now.left.root]) {
            score++; //내려가는 비용
            score += dfs(now.left);
            score++; //다시 올라가는 비용
        }

        //중위 순회함을 체크한다.
        visited[now.root] = true;
        visitedCnt++;

        if (now.right != null && !visited[now.right.root]) {
            score++; //내려가는 비용
            score += dfs(now.right);
            if (visitedCnt == n) { //오른쪽에서 중위 순회가 종료되었다.다시 올라가지 않아도 된다.
                return score;
            }
            score++;
        }

        return score;

    }
}

[JAVA]11437 LCA 공통 부모 노드 찾기(골드 3)

cons-ps — Wed, 20 Sep 2023 22:35:22 +0900

문제

https://www.acmicpc.net/problem/11437

11437번: LCA

첫째 줄에 노드의 개수 N이 주어지고, 다음 N-1개 줄에는 트리 상에서 연결된 두 정점이 주어진다. 그 다음 줄에는 가장 가까운 공통 조상을 알고싶은 쌍의 개수 M이 주어지고, 다음 M개 줄에는 정

www.acmicpc.net

아이디어

공통 조상을 찾는 문제입니다.

각 노드의 깊이를 먼저 BFS, DFS를 이용하여 계산합니다. (이때 부모 노드도 함께 지정해줍니다, parents 배열)

이후에 a,b 노드의 공통 조상을 찾는 경우 a의 깊이, b의 깊이를 비교하여 두 노드의 깊이가 동일할 때까지 부모로 이동하며 올라옵니다

두 노드의 깊이가 같아졌으면 두 노드를 함께 부모로 노드로 올리는것을 반복합니다. 해당 과정을 반복하다 동일 노드가 되면 해당 노드가 공통 부모 노드입니다.

참고로 해당문제는 더욱 최적화할 수 있어 플레티넘 5문제가 있습니다.

여기서 주의해야 할 점은 부모 노드가 반드시 적은 숫자인 것이 아니라는 것입니다.

즉 아래와 같은 경우도 있을 수 있기 때문에 parents배열을 bfs/dfs 탐색하면서 채워주어야 정확한 값을 구해줄 수 있습니다.

풀이

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Boj_11437_LCA {
    private static int[] depths;
    private static int[] parents;
    private static final List<List<Integer>> graph = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        StringBuilder sb = new StringBuilder();

        int nodeCnt = Integer.parseInt(br.readLine());
        //부모 노드를 적는다.
        parents = new int[nodeCnt];
        for (int i = 0; i < nodeCnt; i++) {
            graph.add(new ArrayList<>());
        }

        for (int i = 0; i < nodeCnt - 1; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken()) - 1;
            int b = Integer.parseInt(st.nextToken()) - 1;

            graph.get(a).add(b);
            graph.get(b).add(a);
        }

        //각 정점의 깊이를 구한다.
        depths = new int[nodeCnt];
        bfs();

        //두 정점의 같은 노드 구한다.
        int tc = Integer.parseInt(br.readLine());
        for (int i = 0; i < tc; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken()) - 1;
            int b = Integer.parseInt(st.nextToken()) - 1;
            sb.append(lca(a, b)).append("\n");
        }
        System.out.println(sb);

    }

    private static int lca(int a, int b) {
        //일단 두 깊이가 같아 질때까지 끌어올린다.
        if (depths[a] > depths[b]) {
            //a를 끌어 올린다.
            while (depths[a] != depths[b]) {
                a = parents[a];
            }

        } else if (depths[a] < depths[b]) {
            //b를 끌어 올린다.
            while (depths[a] != depths[b]) {
                b = parents[b];
            }
        }

        //두 노드를 같이 올린다.
        while (a != b) {
            a = parents[a];
            b = parents[b];
        }

        return a + 1;
    }

    private static void bfs() {
        Queue<Integer> q = new LinkedList<>();
        q.add(0);
        int level = 1;
        depths[0] = level;
        parents[0] = 0;

        while (!q.isEmpty()) {
            level++;
            int size = q.size();

            for (int i = 0; i < size; i++) {
                Integer parent = q.poll();
                for (Integer child : graph.get(parent)) {
                    if (depths[child] == 0) { //방문하지 않은 경우만 방문한다
                        depths[child] = level;
                        parents[child] = parent;
                        q.add(child);
                    }
                }
            }
        }
    }
}

[JAVA]13418 학교 탐방하기, 골드 3

cons-ps — Mon, 21 Aug 2023 11:49:20 +0900

문제

https://www.acmicpc.net/problem/13418

13418번: 학교 탐방하기

입력 데이터는 표준 입력을 사용한다. 입력은 1개의 테스트 데이터로 구성된다. 입력의 첫 번째 줄에는 건물의 개수 N(1 ≤ N ≤ 1,000)과 도로의 개수 M(1 ≤ M ≤ N(N-1)/2) 이 주어진다. 입력의 두 번

www.acmicpc.net

아이디어

mst를 활용하여 풀이하였습니다.

*(다른 분들과 풀이가 달라 맞는 풀이인지 확신이 들지 않습니다. 참고 부탁드립니다)

가장 힘이 드는경우는 가장 많은 경사로(같은 길이 나오지 않기때문)를 이용하는 경우라고 생각하였습니다

따라서 먼저 경사로를 이용하는 경우의 모든 경로를 연결합니다. 이때 연결된 경사로의 개수의 제곱이 점수가 됩니다.

가장 힘이 적게 드는 경우는 경사로를 이용하지 않고 내리막길을 가장 많이 이용해야 합니다.

이때는 만약 union하는 경우에 사용한 길의 개수에서 빼서 경사로로 가야만 하는 길의 개수를 구할 수 있습니다.

이렇게 구한 두개의 점수의 차를 구하여 제출하여 통과하였습니다.

풀이

package 백준.graph.mst.kruskal;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class Boj_13418_학교탐방하기 {
    private static class Road {
        int start;
        int end;

        public Road(int start, int end) {
            this.start = start;
            this.end = end;
        }
    }

    private static int[] parents;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken()) + 1; //city
        int m = Integer.parseInt(st.nextToken()) + 1;

        List<Road> slopes = new ArrayList<>(); //경사로들만
        List<Road> descs = new ArrayList<>(); //내리막길말


        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            int start = Integer.parseInt(st.nextToken());
            int end = Integer.parseInt(st.nextToken());
            int slope = Integer.parseInt(st.nextToken());
            if (slope == 0) {
                slopes.add(new Road(start, end));
            } else {
                descs.add(new Road(start, end));
            }
        }
        parents = new int[n];

        //경사로 연결할 수 있는 만큼 연결하는 경우
        for (int i = 0; i < n; i++) {
            parents[i] = i;
        }

        int maxCnt = 0;
        for (Road slope : slopes) {
            if (union(slope.start, slope.end)) {
                maxCnt++;
            }
        }

        //내려가는 길을 연결할 수 있는 만큼 연결하는 경우
        int minCnt= n-1;
        for (int i = 0; i < n; i++) {
            parents[i] = i;
        }

        for (Road desc : descs) {
            if(union(desc.start, desc.end)){
                minCnt--;
            }
        }

        System.out.println((maxCnt * maxCnt) - (minCnt * minCnt));
    }

    private static boolean union(int a, int b) {
        a = findParent(a);
        b = findParent(b);

        if (a != b) {
            if (a < b) parents[b] = a;
            else parents[a] = b;
            return true;
        }
        return false;
    }

    private static int findParent(int a) {
        if (a == parents[a]) return a;
        return parents[a] = findParent(parents[a]);
    }
}