워니의 개발 기록

[Algorithm] 6987 - 월드컵

aeeazip — Tue, 23 Sep 2025 13:58:36 +0900

1. 문제 설명

승패를 기록한 결과를 보고 가능한 결과인지, 불가능한 결과인지를 검사하는 문제다.

이때 가능한 결과라면 "1"을 출력하고, 불가능한 결과라면 "0"을 출력한다.

2. 접근 방식

조별 예선은 총 6개의 국가가 같은 조에 속한 국가들과 한 번씩 경기를 치룬다.

⭐⭐⭐ 즉, 총 경기 횟수는 6C2로 15개가 된다. ⭐⭐⭐

이때 15개의 가능한 경기쌍을 구하고 해당 경기에 대해 승, 무, 패 결과를 백트래킹한다면

모든 경기를 순회했을 때 입력받은 예제의 가능 여부를 판별할 수 있다.

이를 코드로 구현해보자.

3. 코드

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

public class Main {
    public static List<int[]> matches;
    public static boolean possible;

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

        // 가능한 경기쌍 만들기
        matches = new ArrayList<>();
        for(int i = 0; i < 6; i++) {
            for(int j = i + 1; j < 6; j++) {
                matches.add(new int[]{ i, j });
            }
        }

        for(int i = 0; i < 4; i++) {
            int[][] result = new int[6][3];
            int[] info = Arrays.stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt)
                    .toArray();

            int index = 0;
            for (int j = 0; j < 6; j++) {
                for (int k = 0; k < 3; k++) result[j][k] = info[index++];
            }

            possible = false;
            dfs(0, result);

            if(possible) System.out.print("1 ");
            else System.out.print("0 ");
        }
    }

    public static void dfs(int round, int[][] result) {
        if(possible) return;

        if(round == 15) {
            for(int i = 0; i < 6; i++) {
                for(int j = 0; j < 3; j++) {
                    if(result[i][j] != 0) possible = false;
                }
            }
            possible = true;
            return;
        }

        int[] match = matches.get(round);
        int a = match[0];
        int b = match[1];

        // 1. a 승, b 패
        if(result[a][0] > 0 && result[b][2] > 0) {
            result[a][0]--; result[b][2]--;
            dfs(round + 1, result);
            result[a][0]++; result[b][2]++;
        }

        // 2. a 패, b 승
        if(result[a][2] > 0 && result[b][0] > 0) {
            result[a][2]--; result[b][0]--;
            dfs(round + 1, result);
            result[a][2]++; result[b][0]++;
        }

        // 3. a 무, b 무
        if(result[a][1] > 0 && result[b][1] > 0) {
            result[a][1]--; result[b][1]--;
            dfs(round + 1, result);
            result[a][1]++; result[b][1]++;
        }
    }
}

먼저 가능한 경기쌍을 구한다. (총 15개로 고정)

matches = new ArrayList<>();
for(int i = 0; i < 6; i++) {
    for(int j = i + 1; j < 6; j++) {
        matches.add(new int[]{ i, j });
    }
}

(A, B) = (B, A)로 각 국가들은 한 번씩만 경기를 치룬다.

중복되는 경우의 수가 발생하지 않도록 경기쌍 (i, j)를 구한다.

for(int i = 0; i < 4; i++) {
    int[][] result = new int[6][3];
    int[] info = Arrays.stream(br.readLine().split(" "))
            .mapToInt(Integer::parseInt)
            .toArray();

    int index = 0;
    for (int j = 0; j < 6; j++) {
        for (int k = 0; k < 3; k++) result[j][k] = info[index++];
    }

    possible = false;
    dfs(0, result);

    if(possible) System.out.print("1 ");
    else System.out.print("0 ");
}

입력받은 예제를 result[6][3]에 저장한다.

국가는 총 6개, 승무패 3가지 결과를 저장하기 때문에 6 * 3으로 생성해준다.

dfs 메소드로는 경기 결과를 백트래킹해가면 가능 여부를 검사한다.

int[] match = matches.get(round);
int a = match[0];
int b = match[1];

// 1. a 승, b 패
if(result[a][0] > 0 && result[b][2] > 0) {
    result[a][0]--; result[b][2]--;
    dfs(round + 1, result);
    result[a][0]++; result[b][2]++;
}

// 2. a 패, b 승
if(result[a][2] > 0 && result[b][0] > 0) {
    result[a][2]--; result[b][0]--;
    dfs(round + 1, result);
    result[a][2]++; result[b][0]++;
}

// 3. a 무, b 무
if(result[a][1] > 0 && result[b][1] > 0) {
    result[a][1]--; result[b][1]--;
    dfs(round + 1, result);
    result[a][1]++; result[b][1]++;
}

dfs의 일부다.

먼저 matches에서 검사할 경기쌍에서 국가 A, B를 구한다.

A 승 / B 패
A 패 / B 승
A 무 / B 무

총 3가지 경우의 수가 가능하다.

각각의 경우의 수에 대해 result값을 감소시킨채로 다음 경기 결과를 구하고 (dfs 호출)

현재 결과는 원복시켜준다. → 백트래킹 기본 원칙

이때 result는 남아있는 승부의 개수로 생각했다.

만약 result값이 0보다 작다면 남아있는 승부가 없다는 뜻으로, 모든 경기를 검사한 뒤에는

if(possible) return;

if(round == 15) {
    for(int i = 0; i < 6; i++) {
        for(int j = 0; j < 3; j++) {
            if(result[i][j] != 0) possible = false;
        }
    }
    possible = true;
    return;
}

result가 0인지 검사한다.

백트래킹 전에 경기쌍의 결과만큼 감소시켜줬기 때문에 result가 0이 아니라면 경기가 남아있다는 뜻이며

이는 곧 불가능한 결과임을 의미한다.

가능한 결과라면 더 이상 dfs로 검사할 필요가 없다.

그래서 possible을 전역변수로 만들고, true일 땐 dfs 자체를 탈출할 수 있도록 처리해주었다.

[Algorithm] 1027 - 고층 건물

aeeazip — Mon, 22 Sep 2025 12:10:37 +0900

1. 문제 설명

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

문제는 비교적 간단하다.

빌딩들의 높이가 주어졌을 때 가장 많이 보이는 고층 빌딩의 개수를 찾는 것이다.

빌딩 A에서 빌딩 B를 보려면 두 지붕을 잇는 선분이 A와 B를 제외한 다른 고층 빌딩을 지나거나 접하지 않아야 한다.

2. 접근 방식

빌딩의 높이는 계속 달라지고, 앞의 계산 결과를 활용하기 어렵기 때문에 슬라이딩 윈도우나 dp는 고려하지 않았다.

문제에서 주어진 "빌딩을 보기 위한 조건"은 기울기의 사전적 정의와 유사해보였다.

좌표 평면에 아래의 입력 예제를 그린 그림이다.

3 // 빌딩 개수
1 3 2 // 빌딩 높이

(1, 1)을 기준으로 볼 때 (2, 3)은 볼 수 있다. (O)

(1, 1)을 기준으로 볼 때 (3, 2)는 볼 수 없다. (X)

빌딩1과 빌딩 3을 연결하는 선분이 다른 고층 빌딩을 지나고 있기 때문이다.

따라서 빌딩1부터 빌딩 N까지는 아래와 같은 규칙을 따른다.

자신을 기준으로 오른쪽 건물들은 기울기가 커져야 볼 수 있다.
자신을 기준으로 왼쪽 건물들은 기울기가 작아져야 볼 수 있다.

반복문으로 빌딩을 하나씩 검사하며, 다음의 조건을 만족하면 볼 수 있는 건물로 카운팅한 뒤 max를 구하면 된다.

이를 코드로 구현해보자.

3. 코드

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

// 기울기
// 자신 기준 오른쪽 : 기울기가 커야 보임
// 자신 기준 왼쪽 : 기울기가 작아야 보임
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine()); // 빌딩의 수

        int[] buildings = Arrays.stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt)
                .toArray();

        int[] dpLeft = new int[N];
        int[] dpRight = new int[N];
        
        for(int i = 0; i < N; i++) {
            float leftMin = Integer.MAX_VALUE;
            float rightMax = Integer.MIN_VALUE;

            // 1. 왼쪽 검사
            for(int j = i - 1; j >= 0; j--) {
                int x = i - j;
                int y = buildings[i] - buildings[j];

                if((float) y / x >= leftMin) continue;

                leftMin = (float) y / x;
                dpLeft[i]++;
            }

            // 2. 오른쪽 검사
            for(int j = i + 1; j < N; j++) {
                int x = i - j;
                int y = buildings[i] - buildings[j];

                if((float) y / x <= rightMax) continue;

                rightMax = (float) y / x;
                dpRight[i]++;
            }
        }

        int max = 0;
        for(int i = 0; i < N; i++) {
            max = Math.max(dpLeft[i] + dpRight[i], max);
        }

        System.out.print(max);
    }
}

기울기를 계산할 때는 형 변환에 주의해야 한다.

dx, dy는 각각 int로 정의되어있다. (정수형)

그런데 기울기는 정수가 아닌 값도 가능하므로 소숫점까지 비교해주고자 y / x는 float으로 캐스팅해주었다.

빌딩1 ~ 빌딩N까지 검사한 뒤에는 각 위치별로 볼 수 있는 고층 건물의 개수를 취합하여 max를 계산해주면 된다.

[Algorithm] 홀짝트리

aeeazip — Tue, 16 Sep 2025 14:10:39 +0900

1. 문제 설명

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

프로그래머스

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

programmers.co.kr

문제에는 각 노드에 대한 정의가 나와있다.

모든 노드는 홀수 노드, 짝수 노드, 역홀수 노드, 역짝수 노드 중 하나이며 홀짝 트리와 역홀짝 트리는 아래의 노드로만 이루어진 트리를 의미한다.

홀짝 트리	역홀짝 트리
홀수 노드	역홀수 노드
짝수 노드	역짝수 노드

2. 접근 방식

문제에서 주어진 트리는 루트 노드가 설정되어 있지 않다.

루트 노드와 루트 노드가 아닌 일반 노드는 어떤 차이점이 있을까?
.
.
바로 자식 수에서 차이가 드러난다.

왼쪽 트리는 루트가 2이다.

이때 루트 2는 자식 3을 가지므로 자식의 개수는 1개이다.

반면 오른쪽 트리는 루트가 6이다.

이때 리프 2는 3을 부모로 갖기 때문에 자식의 개수는 0개가 된다.

즉, 루트 노드는 간선의 개수만큼 자식 수를 갖는다.

하지만 루트가 아닌 일반 노드는 (간선의 개수 - 1) 만큼 자식 수를 갖게 된다.

루트 노드 자식 수	루트가 아닌 노드의 자식 수
간선의 개수	간선의 개수 - 1

이 그래프는 어떤 트리인가?

노드 숫자	자식 수	노드 판별
3 (홀수)	3 (홀수)	홀수 노드
2 (짝수)	0 (짝수)	짝수 노드
4 (짝수)	0 (짝수)	짝수 노드
6 (짝수)	0 (짝수)	짝수 노드

0은 짝수로 취급한다.

문제 속 규칙을 따라 3은 홀수 노드, 2 ~ 6은 짝수 노드로 [ 홀수 노드와 짝수 노드로만 이루어진 ] 홀짝 트리가 된다.

우리는 자식 수로 새로운 관계를 도출해낼 수 있다.

일반 노드를 루트 노드로 만든다면, 일반 노드일 때의 자식 수 + 1 인 값을 자식 수로 갖게 된다.

일반 노드일 때는 연결은 되어있으나 부모로 삼았던 노드를 자식 노드로 만들었기 때문이다.

그럼 노드의 색깔도 변화한다.

일반 노드일때 노란색이였다면, 자식 수가 변화하면서 빨간색이 된다.

반대의 경우도 성립한다.

일반 노드일 때 빨간색이였다면, 자식 수가 변환하면서 노란색이 된다.

자, 그럼 모든 노드를 루트가 아닌 일반 노드라고 가정해보자. ⭐⭐⭐

Q. 노란색이 1개, 나머지는 빨간색 노드로 이루어져 있다면 무슨 트리가 될까?

노란색인 노드를 루트로 올리면 빨간색 노드가 된다. (자식 수가 변화하니까)

그러면 모든 노드가 빨간색이 되면서 역홀짝 트리가 된다.

Q. 빨간색 1개, 나머지는 노란색 노드로 이루어져 있다면 무슨 트리가 될까?

빨간색인 노드를 루트로 올리면 노란색 노드가 된다. (자식 수가 변화하니까)
그러면 모든 노드가 노란색이 되면서 홀짝 트리가 된다.

이제 로직을 코드로 구현해보자.

3. 코드

import java.util.*;

class Solution {
    public static Map<Integer, List<Integer>> graph;
    public static Set<Integer> visited;
    
    public int[] solution(int[] nodes, int[][] edges) {
        graph = new HashMap<>();
        visited = new HashSet<>();
        
        int[] answer = new int[2];
        
        // 1. graph 정보 기록
        for(int n : nodes) {
            graph.put(n, new ArrayList<>());
        }
        
        for(int[] edge : edges) {
            graph.get(edge[0]).add(edge[1]);
            graph.get(edge[1]).add(edge[0]);
        }                                    
        
        // 2. 트리 검사
        for(int n : nodes) {
            if(!visited.contains(n)) {  
                int[] color = dfs(n);
                
                if(color[0] == 1) answer[1]++;
                if(color[1] == 1) answer[0]++;   
            }           
        }
        
        return answer;
    }
    
    public static int[] dfs(int start) {      
       int yellow = 0;
       int red = 0;
        
       visited.add(start);
       
       boolean isYellow = (start % 2 == (graph.get(start).size() - 1) % 2);
       if(isYellow) yellow++;
       else red++;
        
       for(int n : graph.get(start)) {
           if(!visited.contains(n)) {
               int[] child = dfs(n);
               
               yellow += child[0];
               red += child[1];
           }
       }
        
       return new int[]{ yellow, red };
    }
}

① 특정 노드가 속한 트리 속에서 노드의 색깔을 구분하고

② 노드의 개수로 홀짝 트리 / 역홀짝 트리 여부를 검사한다.

nodes, edges의 길이를 보라...

그래프 문제를 풀 때 애용하는 리스트 배열은 nodes 원소가 1 ~ 1,000,000이니 비효율적이므로

간선 정보를 저장하는 graph는 Map으로 만드는 편이 좋다고 판단했다.

+ 더불어 방문 배열도 boolean 보다는 Set 이 최적화하기 용이하다고 생각했다.

public static Map<Integer, List<Integer>> graph;
public static Set<Integer> visited;
    
public int[] solution(int[] nodes, int[][] edges) {
    graph = new HashMap<>();
    visited = new HashSet<>();

    int[] answer = new int[2];

    // 1. graph 정보 기록
    for(int n : nodes) {
        graph.put(n, new ArrayList<>());
    }

    for(int[] edge : edges) {
        graph.get(edge[0]).add(edge[1]);
        graph.get(edge[1]).add(edge[0]);
    } 
}

graph 해시맵을 초기화한 뒤

입력받은 edges를 순회하며 양방향 간선을 저장해주었다.

for(int n : nodes) {
    if(!visited.contains(n)) {  
        int[] color = dfs(n);

        if(color[0] == 1) answer[1]++;
        if(color[1] == 1) answer[0]++;   
    }           
}

다음은 트리 검사다.

방문하지 않은 노드라면, dfs로 트리 속 노드들 중 yellow와 red의 개수를 센다.

yellow = 1 ) 해당 노드를 루트 노드로 올리면 all RED가 된다. → 역홀짝 트리

red = 1 ) 해당 노드를 루트 노드로 올리면 all YELLOW가 된다. → 홀짝 트리

public static int[] dfs(int start) {      
   int yellow = 0;
   int red = 0;

   visited.add(start);

   boolean isYellow = (start % 2 == (graph.get(start).size() - 1) % 2);
   if(isYellow) yellow++;
   else red++;

   for(int n : graph.get(start)) {
       if(!visited.contains(n)) {
           int[] child = dfs(n);

           yellow += child[0];
           red += child[1];
       }
   }

   return new int[]{ yellow, red };
}

dfs로는 위에 언급한 것처럼 yellow, red 노드의 개수를 센다.

노드의 숫자와 자식 수의 홀짝 여부를 비교하여 그 결과가 같다면 홀수 노드 또는 짝수 노드가 되어 yellow++

그렇지 않은 경우엔 역홀수 노드 또는 역짝수 노드가 되어 red++ 해준다.

[Algorithm] 경주로 건설

aeeazip — Tue, 9 Sep 2025 14:17:00 +0900

1. 문제 설명

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

프로그래머스

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

programmers.co.kr

경주로는 상, 하, 좌, 우로 인접한 두 빈 칸을 연결하여 건설할 수 있고, 벽이 있는 칸에는 경주로를 건설할 수 없다.

인접한 두 빈 칸을 상하 또는 좌우로 연결한 경주로를 직선 도로라고 한다. (개당 100원)
두 직선 도로가 서로 직각으로 만나는 지점을 코너라고 부른다. (개당 500원)

경주로를 건설하는데 필요한 최소 비용을 구하는 문제이다.

이때 언제 코너가 만들어지는지 계산하려면 방향을 고려해야한다.

각 칸마다 비용이 동일하다면 bfs를 사용하면 되지만

직선도로는 100원 / 코너는 500원으로 비용이 다르기 때문에 가중치가 다른 간선의 최소 비용을 구하는 다익스트라를 적용해야 한다.

2. 접근 방식

다익스트라를 적용하기 위해 우선순위큐에서 사용할 내부 클래스를 새로 정의한다.

내부 클래스는 아래와 같은 정보를 저장해야 한다.

① x좌표

② y좌표

③ 방향 정보

④ 현재 좌표까지의 최소 비용

이때 경주로는 인접한 두 칸만 연결할 수 있으므로 방향 정보는 다음과 같이 저장한다.

상 (0)

하 (1)

좌 (1)

우 (1)

마찬가지로 인접한 두 칸을 연결한다는 뜻은, 방문 가능한 칸은 무조건 직선 도로라는 의미이다. 그렇다면 코너는 어떻게 식별할 수 있을까?

간단하다.

우선순위큐에서 꺼낸 노드의 방향과 새롭게 만든 노드의 방향이 일치하는지만 검사하면 된다. 방향이 일치한다면 직선 도로만 해당되며, 방향이 일치하지 않는다면 직선 도로 + 코너인 것이다.

다만 격자 도면이 1로 채워져 있다면 해당 칸은 벽이기 때문에 지나갈 수 없다.

이를 코드로 구현하면 다음과 같다.

3. 코드

import java.util.*;

class Solution {
    public static class Node implements Comparable<Node> {
        int x; // x 좌표
        int y; // y 좌표
        int dir; // 방향 (0 : 상 / 1 : 하 / 2 : 좌 / 3 : 우)
        int cost; // 최소 비용

        public Node(int x, int y, int dir, int cost) {
            this.x = x;
            this.y = y;
            this.dir = dir;
            this.cost = cost;
        }

        @Override
        public int compareTo(Node n) {
            return Integer.compare(this.cost, n.cost);
        }
    }

    public static int[][][] distance;

    public int solution(int[][] board) {
        distance = new int[board.length][board.length][4];
        for(int i = 0; i < board.length; i++) {
            for(int j = 0; j < board.length; j++) {
                Arrays.fill(distance[i][j], Integer.MAX_VALUE);
            }
        }

        bfs(board);
        return Arrays.stream(distance[board.length - 1][board.length - 1])
                .min()
                .getAsInt();
    }

    public static void bfs(int[][] board) {
        int[] dX = { -1, 1, 0, 0 };
        int[] dY = { 0, 0, -1, 1 };

        PriorityQueue<Node> queue = new PriorityQueue();
        queue.add(new Node(0, 0, -1, 0));
        for(int i = 0; i < 4; i++) {
            distance[0][0][i] = 0;
        }

        while(!queue.isEmpty()) {
            Node node = queue.poll();

            for(int i = 0; i < 4; i++) {
                int newdX = node.x + dX[i];
                int newdY = node.y + dY[i];

                if(newdX < 0 || newdX >= board.length || newdY < 0 || newdY >= board.length) continue;
                if(board[newdX][newdY] == 1) continue;

                int newCost = node.cost + 100;
                if(node.dir != i && node.dir != -1) newCost += 500;
                
                if(distance[newdX][newdY][i] > newCost) {
                    distance[newdX][newdY][i] = newCost;
                    queue.add(new Node(newdX, newdY, i, distance[newdX][newdY][i]));
                }
            }
        }
    }
}

코드를 하나씩 뜯어보자.

public static class Node implements Comparable<Node> {
    int x; // x 좌표
    int y; // y 좌표
    int dir; // 방향 (0 : 상 / 1 : 하 / 2 : 좌 / 3 : 우)
    int cost; // 최소 비용

    public Node(int x, int y, int dir, int cost) {
        this.x = x;
        this.y = y;
        this.dir = dir;
        this.cost = cost;
    }

    @Override
    public int compareTo(Node n) {
        return Integer.compare(this.cost, n.cost);
    }
}

우선순위큐를 적용하기 위해 내부 클래스는 Comparable 구현체로 만들었다.

최소 비용을 구하는 문제로, 정렬 조건은 현재 좌표까지 도달하는데 필요한 비용으로 삼았다.

int[][][] distance = new int[board.length][board.length][4];
for(int i = 0; i < board.length; i++) {
    for(int j = 0; j < board.length; j++) {
        Arrays.fill(distance[i][j], Integer.MAX_VALUE);
    }
}

최종적으로 최소 비용을 저장하는 배열 distance를 만들었다.

2차원 배열이 아닌 3차원 배열로 생성한 이유는 각 방향에서 만들어지는 최소 비용이 다를 수 있기 때문이다.

따라서 상, 하, 좌, 우 총 4가지 방향을 고려하기 위해 마지막 차원으로 방향 정보를 저장하는 3차원 배열을 생성했다.

while(!queue.isEmpty()) {
    Node node = queue.poll();

    for(int i = 0; i < 4; i++) {
        int newdX = node.x + dX[i];
        int newdY = node.y + dY[i];

        if(newdX < 0 || newdX >= board.length || newdY < 0 || newdY >= board.length) continue;
        if(board[newdX][newdY] == 1) continue;

        int newCost = node.cost + 100;
        if(node.dir != i && node.dir != -1) newCost += 500;

        if(distance[newdX][newdY][i] > newCost) {
            distance[newdX][newdY][i] = newCost;
            queue.add(new Node(newdX, newdY, i, distance[newdX][newdY][i]));
        }
    }
}

코너를 검사하기 위해 큐에서 뺀 노드의 방향과 새로운 노드의 방향을 비교한다.

다만 시작점 (0, 0)은 어느 방향으로 가더라도 코너가 없기 때문에 node.dir이 -1인 경우는 제외한다.

bfs처럼 처음 방문한 경로가 최소 비용이 보장되는 것은 아니므로 visited 배열은 사용하지 않는다.

대신 newCost를 계산한뒤 distance[newdX][newdY]가 갱신의 여지가 있다면

distance[newdX][newdY] > newCost

갱신한뒤, 우선순위큐에 해당 노드를 추가해 최소 비용을 기준으로 탐색을 이어나가도록했다.

[Algorithm] 5052 - 전화번호 목록

aeeazip — Mon, 8 Sep 2025 21:52:04 +0900

1. 문제 설명

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

전화번호 목록이 주어질 때, 목록에 일관성이 있는가를 검사하는 문제이다.

일관성은 한 번호가 다른 번호의 접두어가 되는가를 기준으로 평가한다.

한 번호가 다른 번호의 접두어가 된다. → 일관성 X
- 긴급전화 : 911
- 선영 : 91 12 54 26
한 번호가 다른 번호의 접두어가 아니다. → 일관성 O
- 긴급전화 : 911
- 수연 : 91 22 54 26

2. 접근 방식

일관성이 없는 경우는 접두어가 같다는 조건을 활용하기 위해 정렬 을 떠올렸다.

입력값이 다음과 같이 주어졌을 때

911

910

9112

912

9113

전화번호 목록을 String을 기준으로 정렬하면 아래와 같은 순서가 된다.

910

911

9112

9113

912

이때 911, 9112, 9113은 접두어가 911로 같기 때문에 일관성이 없다고 할 수 있다.

즉, 정렬 뒤 전화번호[i + 1]가 전화번호[i]로 시작한다면 일관성이 없는 목록인 것이다.

다만, input값을 유의해야한다.

예제 입력1은 우리를 낚기 위해서 전화번호 목록을 공백 없는 아름다운 숫자로 보여주고 있다.

하지만 아름다움에 속아 전화번호 목록을 입력받은 그대로 사용하면 그대로 나락행에 빠진다.

문제를 자세히 읽어보면 예제 전화번호는 공백이 있는 것을 확인할 수 있다.

ex) 상근, 선영의 전화번호

따라서 입력값을 그대로 활용하지 말고, 공백을 제거한 문자열을 활용하자.

이를 코드로 구현하면 다음과 같다.

3. 코드

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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(br.readLine()); // 테스트 케이스의 개수

        for(int i = 0; i < t; i++) {
            int n = Integer.parseInt(br.readLine()); // 전화번호의 수

            String[] phones = new String[n];
            for(int j = 0; j < n; j++) {
                phones[j] = br.readLine().replace(" ", "");
            }

            bw.write(isConsistent(phones) + "\n");
        }

        bw.flush();
        bw.close();
        br.close();
    }

    public static String isConsistent(String[] phones) {
        // 오름차순 정렬
        Arrays.sort(phones);

        // i + 1번째 i번째 포함한다면 일관성이 없는 것
        for(int i = 0; i < phones.length - 1; i++) {
            if(phones[i + 1].startsWith(phones[i])) return "NO";
        }

        return "YES";
    }
}

코드를 자세히 살펴보자.

① replace 메소드

String[] phones = new String[n];
for(int j = 0; j < n; j++) {
    phones[j] = br.readLine().replace(" ", "");
}

전화번호 목록을 입력받을 때는 공백을 제거해주기 위해 replace 메소드를 활용했다.

" "을 ""로 대체 = 공백을 제거한 문자열을 phones[j]에 담는다.

② startsWith 메소드

// i + 1번째 i번째 포함한다면 일관성이 없는 것
for(int i = 0; i < phones.length - 1; i++) {
    if(phones[i + 1].startsWith(phones[i])) return "NO";
}

일관성이 없는가를 판단하기 위해 i + 1번째가 i번째로 시작하는지를 검사했다.

이때 접두어를 확인해야하므로 startsWith 메소드를 활용했다.

[Algorithm] 여행경로

aeeazip — Fri, 5 Sep 2025 20:21:22 +0900

1. 문제 설명

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

프로그래머스

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

programmers.co.kr

"ICN"에서 출발해 방문하는 모든 공항 경로를 출력하는 문제이다.

이때 공항 수는 3개 이상 10,000개 이하이다.

출발지	도착지
ICN	SFO
ICN	ATL

예제 2처럼 가능한 경로가 2개 이상인 경우엔 알파벳 순서가 앞서는 경로를 먼저 방문한다.

가능한 경로가 2개 이상이면 오름차순 정렬된 결과를 선택해야 한다는 의미로

위의 표를 기준으로 ATL을 먼저 방문해야 한다.

2. 접근 방식

방문 가능한 모든 경로를 만든 뒤, 가장 적합한 최적해를 고르는 방식으로 접근했다.

출발지를 기준으로 가능한 목적지 리스트를 저장하는 graph가 필요하다고 생각했다.

List<String>[] graph = new ArrayList[n];

n은 출발지 개수가 들어가야하는데...

주어진 공항 수는 3개 이상 10000개 이하로 무척 곤란한 크기가 된다.

다음으로 떠올린 방법은 HashMap이였다.

Map<String, List<String>> graph = new HashMap<>();

물론 이렇게 구현하는 방법도 가능하다.

1. 출발지 기준으로 목적지는 오름차순 정렬

2. 목적지 하나씩 뽑아서 dfs

하지만 코드가 꽤나 더럽다.

▼ Dirty work

import java.util.*;

class Solution {
    public static Map<String, LinkedList<String>> graph;
    public static boolean[] visited;
    public static List<String> answer;
    
    public List<String> solution(String[][] tickets) {
        // 1. 출발지 - 목적지 기록
        graph = new HashMap<>();
        for(int i = 0; i < tickets.length; i++) {
            graph.computeIfAbsent(tickets[i][0], k -> new LinkedList<>()).add(tickets[i][1]);
        }
        
        // 2. value 기준 오름차순 정렬
        List<String> keys = new ArrayList<>(graph.keySet());
        for(String key : keys) {
            Collections.sort(graph.get(key));
        }
        
        // 3. dfs 호출
        List<String> path = new ArrayList<>();
        path.add("ICN");
        answer = new ArrayList<>();
        
        dfs("ICN", path, tickets);
        return answer;
    }
    
    public static boolean dfs(String now, List<String> path, String[][] tickets) {
        if(path.size() == tickets.length + 1) { // 다 방문
            answer.addAll(new ArrayList<>(path));
            return true;
        }
        
        if (!graph.containsKey(now)) return false;

        LinkedList<String> destinations = graph.get(now);
        for (int i = 0; i < destinations.size(); i++) {
            String next = destinations.remove(i); // 티켓 사용
            path.add(next);

            if (dfs(next, path, tickets)) return true;

            path.remove(path.size() - 1); // 백트래킹
            destinations.add(i, next);     // 티켓 복원
        }
        
        return false;
    }
}

목적지 정렬과 graph 없이도 구현 가능한 방법이 있다.

정렬을 먼저 하고 dfs를 호출하면 위의 코드처럼 로직이 복잡하지만

dfs를 먼저 호출하고 정렬을 나중에 해주는 방법도 가능하다.

정렬 시점이 문제의 핵심이다.

① 먼저 ICN을 출발지로 시작해 가능한 경로라면 방문 표시를 해주고 다시 dfs를 호출한다.

② 최적해가 아님을 고려하여 방문 표시를 제거한뒤 다시 경로를 탐색하는 로직도 필요하다.

가능한 최종 경로를 리스트를 담고 리스트를 정렬하면,

가능한 경로가 2개 이상일 때 알파벳 순서대로 방문한 결과를 얻을 수 있다.

이때 이를 코드로 구현하면 다음과 같다.

3. 코드

import java.util.*;

class Solution {
    public static boolean[] visited;
    public static List<String> answer;
    
    public static String[] solution(String[][] tickets) {
        visited = new boolean[tickets.length];
        answer = new ArrayList<>();
        dfs("ICN", "ICN", tickets, 0);
        
        Collections.sort(answer);
        return answer.get(0).split(" ");
    }
    
    public static void dfs(String now, String path, String[][] tickets, int count) {
        if(count == tickets.length) {
            answer.add(path);
            return;
        }
        
        for(int i = 0; i < tickets.length; i++) {
            if(!visited[i] && tickets[i][0].equals(now)) {
                visited[i] = true;                    
                dfs(tickets[i][1], path + " " + tickets[i][1], tickets, count + 1);       
                visited[i] = false;        
            }
        }
        
        return;
    }
}

now는 출발지를 의미한다.

무조건 "ICN"에서 출발하기 때문에 호출할 때 하드 코딩된 값을 넣어줬다.

path는 방문한 경로를 저장하는 값으로 출발지와 목적지 사이에 padding을 넣어 String 배열로 만들기 용이하게 해주었다.

이처럼 dfs 마치고 정렬하믄, 비교적으로 간단하게 최적해를 구할 수 있다.

[Algorithm] 1197 - 최소 스패닝 트리

aeeazip — Wed, 3 Sep 2025 16:09:26 +0900

1. 문제 설명

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

최소 스패닝 트리의 가중치를 구하는 문제이다.

최소 스패닝 트리는 그래프의 모든 정점들을 연결해야 하기 때문에 간선의 수는 노드 - 1개를 가진다.

예시

또한 가중치의 합이 최소로 만들기 위해 사이클을 가지면 안 된다.

1 - 2 / 1 - 3이 연결되어 있을 때 이미 모든 정점을 움직일 수 있기 때문에

2 - 3을 포함하면 가중치에 불필요한 값이 추가되며, 사이클이 발생한다.

2. 접근 방식

가중치의 합을 최소로 만들어야 한다 = 가중치가 작은값부터 쏙쏙 골라간다

1. 먼저 모든 간선들을 가중치를 기준으로 오름차순 정렬

2. 해당 간선을 포함했을 때 사이클이 안생긴다 → 최소 스패닝 트리에 포함

3. 스패닝 트리의 간선의 개수 = [노드의 개수 - 1]이 되면 멈춤

위의 과정의 핵심은 '사이클을 어떻게 검사하는가' 이다.

당연히~ bfs를 먼저 떠올렸다.

이 그림을 기준으로 1 - 3 이 사이클이 없는지 검사하기 위해

1부터 bfs 탐색을 시작해서 큐에서 꺼낸 값이 3이면 사이클이 있다.
3이 나오지 않으면 사이클이 없다.

간단하게 생각했다.

메모리 초과가 떴다.

문제에서 정점의 개수는 최대 1만개라고 제한해두었기 때문에 bfs로 접근하면

정점 = V (최대 10,000) , 간선 = E (최대 100,000)이므로 최악의 경우 O(1000000000.......

안될 수 밖에 없다 ^^..

▼ 망한 코드

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

public class Main {
    public static List<Integer>[] graph;
    public static int[][] arr;
    public static boolean[] visited;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[] input = Arrays.stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt)
                .toArray(); // 정점 개수, 간선 개수

        graph = new ArrayList[input[0] + 1];
        for (int i = 0; i < input[0] + 1; i++) {
            graph[i] = new ArrayList<>();
        }

        arr = new int[input[1]][3];
        for (int i = 0; i < input[1]; i++) {
            arr[i] = Arrays.stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt)
                    .toArray();
        }

        // 가중치를 기준으로 오름차순 정렬
        Arrays.sort(arr, new Comparator<int[]>() {
            @Override
            public int compare(int[] a1, int[] a2) {
                return Integer.compare(a1[2], a2[2]);
            }
        });

        int sum = 0;
        int count = 0;

        visited = new boolean[input[0] + 1];
        for (int i = 0; i < arr.length; i++) {
            Arrays.fill(visited, false);

            if (!isCycle(input[0], arr[i][0], arr[i][1])) {
                graph[arr[i][0]].add(arr[i][1]);
                graph[arr[i][1]].add(arr[i][0]);
                sum += arr[i][2];
                count++;
            }

            if (count == input[0] - 1) break;
        }

        System.out.println(sum);
    }

    public static boolean isCycle(int v, int start, int end) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(start);
        visited[start] = true;

        while(!queue.isEmpty()) {
            int n = queue.poll();

            if(n == end) return true;

            for(Integer i : graph[n]) {
                if(!visited[i]) {
                    queue.add(i);
                    visited[i] = true;
                }
            }
        }

        return false;
    }
}

사이클을 효과적으로 검사하려면 Kruskal 알고리즘 (Union find) 를 활용해야한다.

핵심 알고리즘은 "같은 집합에 속한 노드끼리는 연결하지 않는다" 가 된다.

구성요소는 크게 3가지이다.

① parent 배열 : 각 노드가 속한 집합의 대표(루트)를 저장

int[] parent = new int[n];
for(int i = 0; i < n; i++) parent[i] = i; // 자기자신만 갖도록 초기화

② find 메소드 : 노드가 속한 집합의 대표를 반환

 public static int find(int x) {
    if(parent[x] == x) return parent[x];
    return parent[x] = find(parent[x]);
}

③ union 메소드 : 두 집합을 하나로 합침

public static void union(int a, int b) {
    a = find(a);
    b = find(b);

    if(a != b) parent[b] = a; // b를 a에 합치기
}

가중치를 기준으로 오름차순 정렬하면 아래와 같다.

노드	노드	가중치
1	2	1
1	3	2
2	3	3

parent 배열은 초기화를 마치면 자기 자신을 갖는다.

즉, 각 집합의 대표가 자신이 되는 것이다.

가장 가중치가 작은 [ 노드 1 - 노드 2 ] 가 사이클이 있는지 검사해보자.

노드1 집합 대표와 노드2 집합 대표가 같다면 사이클이 존재한다고 판단한다.

if(find(1) == find(2)) = 사이클 O

노드1 집합 대표는 자기 자신인 1

노드2 집합 대표는 자기 자신인 2

둘은 서로 다른 값을 가지기 때문에 사이클이 존재하지 않는다.

사이클이 존재하지 않는다면 두 집합을 합친다.

사이클 X → union(1, 2)

public static void union(int a, int b) {
    a = find(a);
    b = find(b);

    if(a != b) parent[b] = a; // b를 a에 합치기
}

노드1과 노드2 집합 대표는 서로 다르기 때문에 parent[2] = 1이 되므로

노드2 집합의 대표는 1이 된다. (노드1, 노드2 집합이 합쳐진 것)

이를 코드로 구현하면 아래와 같다.

3. 코드

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

public class Main {
    public static List<Integer>[] graph;
    public static int[][] arr;
    public static int[] parent;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int[] input = Arrays.stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt)
                .toArray(); // 정점 개수, 간선 개수

        graph = new ArrayList[input[0] + 1];
        for (int i = 0; i < input[0] + 1; i++) {
            graph[i] = new ArrayList<>();
        }

        arr = new int[input[1]][3];
        for (int i = 0; i < input[1]; i++) {
            arr[i] = Arrays.stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt)
                    .toArray();
        }

        // 가중치를 기준으로 오름차순 정렬
        Arrays.sort(arr, new Comparator<int[]>() {
            @Override
            public int compare(int[] a1, int[] a2) {
                return Integer.compare(a1[2], a2[2]);
            }
        });

        int sum = 0;
        int count = 0;
        parent = new int[input[0] + 1]; // union find용 배열

        // 초기화
        for(int i = 0; i < input[0] + 1; i++) parent[i] = i;
        for(int i = 0; i < arr.length; i++) {
            // 사이클 검사
            if(find(arr[i][0]) != find(arr[i][1])) {
                union(arr[i][0], arr[i][1]);
                sum += arr[i][2];
                count++;
            }

            if(count == input[0] - 1) break;
        }

        System.out.print(sum);
    }

    // 집합 대표 찾기
    public static int find(int x) {
        if(parent[x] == x) return parent[x];
        return parent[x] = find(parent[x]);
    }

    // 두 집합 합치기
    public static void union(int a, int b) {
        a = find(a);
        b = find(b);

        if(a != b) parent[b] = a; // b를 a에 합치기
    }
}

[Algorithm] 서버 증설 횟수

aeeazip — Tue, 2 Sep 2025 14:21:24 +0900

1. 문제 설명

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

프로그래머스

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

programmers.co.kr

문제 핵심 조건은 아래와 같다.

같은 시간대에 게임을 이용하는 사람이 m명 늘어날 때마다 서버 1대 추가
n * m <= 어느 시간대의 이용자 < (n + 1) * m → 최소 n대의 증설된 서버가 필요
k = 5 ) 10시에 증설한 서버는 10 ~ 15시에만 운영

0 ~ 23시까지의 모든 게임 이용자를 감당하기 위한 최소 서버 증설 횟수를 구하면 된다.

2. 접근 방식

players의 길이, m, k가 각각 충분히 작고

"매 시각마다 최소한의 서버만 증설"하기 때문에 그리디를 떠올렸다.

( 게임 이용자 수 / m )으로 나누면 시각별로 증설해야 할 서버의 수를 구할 수 있다.

이때 현재 시각에 이미 증설되어 있던 서버가 있다면 그 값을 제해야 실제 증설 횟수를 구할 수 있다.

즉, 현재 시각에 증설된 서버 개수 = ( 게임 이용자 수 / m ) - ( 이미 증설되어 있던 서버 개수 )

그렇다면 이미 증설되어 있던 서버 개수는 어디에 기록하면 되는가?

int[] time = new int[24]; // i시각에 증설된 서버의 개수
Arrays.fill(time, 0);

어차피 시각은 0 ~ 24시까지만 보면 된다.

따라서 크기가 24인 int형 배열에 i시에 이미 증설되어 있는 서버의 개수를 저장한다.

ex) time[0] = 0시에 운영되고 있는 증설 서버 개수

현재 시각에 증설된 서버 개수를 구했다면, 해당 서버의 운영 시간을 기록해야 한다.

서버 한 대가 운영 가능한 시간은 k와 같으므로 현재 시각이 i시라면 i + k시 까지 운영된다.

이를 코드로 구현하면 다음과 같다.

3. 코드

import java.util.*;

class Solution {
    public int solution(int[] players, int m, int k) {
        int count = 0; // 서버 증설 횟수 기록
        int[] time = new int[24]; // i시각에 증설된 서버의 개수
        Arrays.fill(time, 0);
        
        for(int i = 0; i < players.length; i++) {
            int player = players[i]; // i ~ i + 1 시각의 게임 이용자 수 
            int nServerCount = player / m; // 증설된 서버의 수
            int now = time[i]; // 현재 시각에 이미 증설되어 있는 서버 개수
            
            if(nServerCount < now || nServerCount < 1) continue;
            count += (nServerCount - now); // 증설 횟수
            
            // 증설된 서버 운영 시간 기록
            for(int j = i; j < i + k; j++) {
                if(j < 24) time[j] += (nServerCount - now);
            }
        }
        
        return count;
        
    }
}

다 풀고 고민해보니까 만약 players의 길이가 충분히 길었다면 이 방식은 유효하지 않을 것이다.

players의 길이가 수십만 이상인 경우엔, 우선순위큐로 풀이하는 것이 좋을 것 같다.

아래는 우선순위큐로 풀이한 코드이다.

import java.util.*;

class Solution {
    public int solution(int[] players, int m, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>(); // 서버 만료 시각 저장
        int count = 0; // 서버 증설 횟수 기록
        
        for (int i = 0; i < 24; i++) {
            // 1. 만료된 서버 제거
            while (!pq.isEmpty() && pq.peek() <= i) {
                pq.poll();
            }
            
            // 2. 현재 필요한 서버 수
            int player = players[i];
            int nServerCount = player / m;
            int now = pq.size(); // 현재 살아 있는 서버 개수
            
            // 3. 부족하면 증설
            if (now < nServerCount) {
                int add = nServerCount - now;
                count += add;
                
                for (int j = 0; j < add; j++) {
                    pq.offer(i + k); // k시간 뒤 만료
                }
            }
        }
        
        return count;
    }
}

4. 시간 복잡도 및 공간 복잡도 계산

for (int i = 0; i < players.length; i++) {       // 24번 반복
    int nServerCount = player / m;
    int now = time[i];
    if (nServerCount < now || nServerCount < 1) continue;

    // 증설된 서버 운영 시간 기록
    for (int j = i; j < i + k; j++) {            // 최대 k번 반복
        if (j < 24) time[j] += (nServerCount - now);
    }
}

먼저 그리디 코드에서 바깥쪽 반복문은 반복 횟수가 24번으로 고정이고 안쪽 루프는 최대 k번 반복하므로

시간 복잡도는 O(24 * k) = O(1)가 된다. (k는 24 이하)

공간 복잡도는 time 배열로 인해 O(1)의 복잡도를 갖는다.

for (int i = 0; i < 24; i++) {
    // 1. 만료된 서버 제거
    while (!pq.isEmpty() && pq.peek() <= i) {
        pq.poll();
    }
 }

우선순위큐를 사용한 방식 역시 바깥쪽 반복문은 반복 횟수가 24번으로 고정이고

안쪽 반복문의 힙 연산은 log(heap 크기)와 같으므로

전체 증설 횟수가 X번이라고 가정할 때 시간 복잡도는 O(X logX)가 된다.

공간 복잡도는 우선순위큐에 증설된 서버 개수를 저장하므로 O(X)와 같다.

[Algorithm] 1138 - 한 줄로 서기

aeeazip — Mon, 1 Sep 2025 23:46:14 +0900

1. 문제 설명

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

사람들은 자기보다 큰 사람이 왼쪽에 몇 명 있었는지만을 기억한다.

입력값으로 키가 1인 사람부터 차례대로 자기보다 큰 사람이 왼쪽에 몇 명 있었는지 주어지면, 실제로 줄을 선 순서대로 키를 출력해주면 된다.

2. 접근 방식

예제 입력 1을 기준으로 아래와 같이 해석할 수 있다.

키 1 : 왼쪽에 자기보다 키 큰 사람 2명

키 2 : 왼쪽에 자기보다 키 큰 사람 1명

키 3 : 왼쪽에 자기보다 키 큰 사람 1명

키 4 : 왼쪽에 자기보다 키 큰 사람 0명

int[] arr에 [ 2, 1, 1, 0 ] 을 저장한다고 가정할 때

✅️ 만약 작은 키 (키 1)부터 줄을 세우기 시작한다면

나보다 큰 사람이 왼쪽에 몇 명 있는가를 확인하기 위해 아직 줄에 들어오지 않은 큰 사람들이 어디에 올 지 알아야 한다.
작은 키를 먼저 배치하면 앞으로 올 사람들의 배치를 미리 알 수 없어서 조건을 맞추기 어렵다.

✅️ 만약 큰 키 (키 4)부터 줄을 세우기 시작한다면

키 = N ) 자신보다 키 큰 사람이 없음 = 조건은 무조건 0명 = 줄 맨 앞에 둬야 한다.
키 = N - 1 ) 줄에 이미 서 있는 사람들은 전부 자기보다 큰 사람
→ 키 N - 1 인 사람의 arr 인덱스는 N - 2 (키 1 → 인덱스 0 이니까)
→ arr[N - 2] 위치에 꽂아넣으면 된다.
점점 작은 키로 내려갈수록, 이미 줄에 선 사람들은 자신보다 키가 크기 때문에 arr[i]번째 위치에 넣어주면 조건 충족

즉, 큰 키부터 배치하면 arr[i] 값을 줄 서는 인덱스로 해석할 수 있다.

index	[1]	[2]	[3]	[4]
arr[i]	2	1	1	0

list에 줄을 서는 순서대로 키를 저장하려고 할 때

index 4 ) list[0] = 4가 된다. (줄 선 순서 : 4)

index 3 ) list[1] = 3이 된다. (줄 선 순서 : 4 3)

index 2일 때 문제가 발생한다.

arr[2]와 arr[3]이 모두 1로 같기 때문에 list[1] = 2을 넣게 되면 3이 증발 하게 된다.

따라서 줄 선 순서가 자연스럽게 4 2 3 이 될 수 있도록 list 구현체를 LinkedList로 해주어야한다.

이를 코드로 구현해보겠다.

3. 코드

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

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

        int N = Integer.parseInt(br.readLine()); // 사람의 수
        int[] arr = Arrays.stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt)
                .toArray(); // 키가 1인 사람부터 자신보다 키 큰 사람이 왼쪽에 몇 명 있는지 저장하는 배열

        List<Integer> list = new LinkedList<>(); // 결과 저장용 리스트
        for(int i = N - 1; i >= 0; i--) {
            list.add(arr[i], i + 1);
        }

        for(Integer i : list) {
            System.out.print(i + " ");
        }
    }
}

4. 시간 복잡도 및 공간 복잡도 계산

List<Integer> list = new LinkedList<>(); // 결과 저장용 리스트
for(int i = N - 1; i >= 0; i--) {
    list.add(arr[i], i + 1);
}

반복문은 N번 연산하지만

LinkedList.add(index, value)는 지정된 index 위치만큼 앞에서부터 순서대로 탐색해야 하므로 O(N)이다.

따라서 시간 복잡도는 O(N * N)이 된다.

공간 복잡도는 입력 배열 arr와 출력 저장용 list 모두 길이가 N이므로 O(N)이 된다.

문제에서 N은 10보다 작은 자연수라고 주어졌기 때문에 주어진 시간과 메모리 내에서 충분히 실행 가능하다.

[Network] HTTP와 HTTPS의 차이

aeeazip — Fri, 25 Jul 2025 15:22:50 +0900

1. HTTP

HTTP는 HyperText Transfer Protocol의 약자로 웹 표준 프로토콜을 의미한다.

일반적으로 HTTP 요청/응답은 메소드, 헤더, 바디의 응답 구조를 가지며 기본 포트는 80번이다.

[HTTP 메시지 구조] https://mangkyu.tistory.com/98 참고

평문을 바이트 스트림 형태로 전송한다는 특징으로

로그인 정보
쿠키
API 키

등 민감한 정보가 그대로 노출될 수 있기 때문에 이를 보완하는 암호화 프로토콜 HTTPS가 등장하게 되었다.

2. HTTPS

HTTPS는 SSL/TLS 인증서로 암호화해서 데이터를 전송한다.

포트는 443번을 사용하며, 중간에 데이터가 탈취되더라도 복호화하기 어렵다.

HTTPS는 대칭키와 비대칭키 알고리즘을 모두 사용한다.

1) 대칭키 알고리즘

https://2jinishappy.tistory.com/338 참고

먼저 대칭키 알고리즘은 암호화, 복호화 모두 같은 키를 사용한다.

평문을 A키로 암호화하면, 암호문을 A키로 복호화 할 수 있다는 뜻으로

키만 알면 누구나 암호문을 해독할 수 있기 때문에 '비밀키를 공유해야 한다는 점에서' 비밀키 알고리즘이라고도 부른다.

대표적으로 AES, DES 방식이 있지만

DES는 56비트 키를 사용하기 때문에 키 크기가 2 ^ 56으로, 컴퓨터 성능이 크게 발달한 현대에서는 안전하지 못하다.

JAVA 코드 구현은 아래 링크를 확인하길 바란다.

https://github.com/aeeazip/WebCodeSecurity/tree/main/Practice06/W06_02

WebCodeSecurity/Practice06/W06_02 at main · aeeazip/WebCodeSecurity

4학년 1학기 웹코드보안 실습 과제. Contribute to aeeazip/WebCodeSecurity development by creating an account on GitHub.

github.com

2) 비대칭키 알고리즘

https://2jinishappy.tistory.com/338 참고

[ 상황 : 영희가 철수만 읽을 수 있는 문서를 보낸다. ]

1. 영희는 철수의 공개키로 암호화 한 암호문을 보낸다.

2. 철수는 비밀키로 암호문을 복호화한다.

3. 철수가 문서를 읽는다.

이때 영희가 철수의 공개키로 암호화하는 이유는 철수만 읽을 수 있도록 하기 위함이다. (철수만 복호화할 수 있기 때문)

하지만 비대칭키 방식은 공개키에 비해 안전하지만 느리다는 특징이 있다.

대표적으로 RSA, DSA, Diffie-Hellman 방식이 있으며 HTTPS 방식에서는 가장 고전적인 RSA 알고리즘을 사용하고 있다.

JAVA 코드 구현은 아래 링크를 확인하길 바란다.

https://github.com/aeeazip/WebCodeSecurity/tree/main/Practice07/W07_02

WebCodeSecurity/Practice07/W07_02 at main · aeeazip/WebCodeSecurity

4학년 1학기 웹코드보안 실습 과제. Contribute to aeeazip/WebCodeSecurity development by creating an account on GitHub.

github.com

Q. 그럼 HTTPS는 언제 대칭키를 쓰고, 언제 비대칭키를 쓰는가?

A. HTTPS는 초기에 비대칭키로 안전하게 키를 교환한 다음, 데이터 통신은 빠른 대칭키로 처리한다.

클라이언트가 대칭키(세션키)를 랜덤하게 생성한다.

이 키를 서버의 공개키로 암호화한다.

서버는 서버 개인키로 복호화해서 클라이언트의 대칭키(세션키)를 획득한다. → 비대칭키 알고리즘

이후에 데이터는 세션키를 활용해 대칭키 암호화로 주고 받는다. → 대칭키 알고리즘

이 과정은 TLS Handshake라고 부르며, 보안과 속도를 모두 확보할 수 있다는 장점이 있다.

3. HTTP → HTTPS로 전환하는 방법

일단 필수적인 준비물은 다음과 같다.

항목	설명
도메인	HTTPS는 도메인 기반 인증서가 필요하기 때문에 도메인이 필요
(공인 IP) 서버	외부에서 접속 가능한 웹서버가 필요 (80, 443 포트 방화벽을 허용)
DNS 설정	도메인에서 A레코드를 서버 IP로 연결해줘야 함
SSL 인증서	웹사이트 신원을 증명해주는 핵심 파일 인증서가 필요 (무료/유료 발급 가능)

도메인이 없다면 가비아에서 구매하면 된다. 그리고 도메인을 IP와 매핑시켜주는 DNS 설정이 필요하다.

https://domain.gabia.com

가비아: 대한민국 도메인 점유율 1위

대한민국 100만 도메인 등록 업체

domain.gabia.com

AWS에서는 도메인 이름을 등록하는 서비스 Route53을 제공한다.

가비아에서 도메인을 구매한 뒤에, 도메인명을 ALB가 제공하는 애플리케이션에 연결한다.

아래 링크를 참고하면 도메인 연결 방법이 자세하게 나와있다.

https://aws.amazon.com/ko/getting-started/hands-on/get-a-domain/

Route 53을 사용해 도메인 이름을 등록하는 방법

aws.amazon.com

다음으로 SSL 인증서를 발급받아야 한다. 무료 방식은 Let's Encrypt가 있다.

가난한 거지 대학생 개발자(주인장)한테 한 줄기 빛 같은 무료 서비스!

현업에서도 자주 사용한다.

하지만 인증서 유효기간이 90일로 짧기 때문에 계속해서 갱신해줘야 한다.

대규모 시스템에서는 Certbot으로 자동 갱신 스크립트를 돌린다.

Certbot을 컨테이너로 관리하고 싶다면 아래 블로그를 참고하면 좋을 것 같다.

https://velog.io/@rockaria/Certbot-SSL-%EC%9D%B8%EC%A6%9D%EC%84%9C-%EC%9E%90%EB%8F%99-%EA%B0%B1%EC%8B%A0

SSL 인증서 발급 및 자동 갱신 - [HTTPS, Let's Encrypt, Certbot]

무료로 SSL인증 해주는Let's Encrypt

velog.io

최근엔 AWS Certificate Manager를 사용하는 추세다.

퍼블릭 인증서는 무료로 발급되며, 기간이 만료되면 자동으로 갱신된다.

ALB나 API Gateway에 붙여놓기만하면 간단하게 관리할 수 있기 때문에 시스템 내부적으로 AWS 인프라가 갖춰진 경우에 많이 사용한다.

마지막으로 서버로 AWS EC2를 사용하는 경우에는 VPC 인바운드 보안 정책에서 80, 443 포트를 필수로 열어두어야 한다.

+ 탄력적 IP도 할당받기

80, 443을 꼭 열어주십셔

실제로 HTTPS로 전환하는 상세한 과정은 아래 첨부한 링크를 확인하길 바란다!

https://aeeazip.tistory.com/52

[CI/CD] Github Actions + Elastic Beanstalk를 활용한 Node.js CI/CD 구축 (3) - 完

목차 1. CI/CD 개념 2. OverView 3. VPC 생성 및 연결 4. Github Actions 설정 5. AWS IAM 생성 6. AWS Elastic Beanstalk 설정 7. 프로젝트 파일 생성 및 수정 8. HTTPS 적용 https://aeeazip.tistory.com/51 [CI/CD] Github Actions + Elastic

aeeazip.tistory.com