Hyun's Wonderwall

Run for music: 바이브코딩으로 나한테 필요한 러닝앱을 자급자족하고 APK 배포까지 한 후기

Hyun_! — Tue, 28 Apr 2026 01:22:24 +0900

요즘 러닝에 빠져서 주에 2번씩은 뛰고 있다. 아직 초보라 혼자 뛸 때는 페이스 조절이 어렵게 느껴진다. 방힘하면 5분대 단거리 달리기와 10분대 걷기를 반복하기 일쑤다. 과감하게 훨씬 먼 거리를 달려봐야지 하는 것도 내일 출근할 체력을 생각하면 좀처럼 쉽지 않다. 혼자 러닝을 하며 이런저런 회고를 해보던 중, 적당한 속도로 '꾸준히 재밌게' 뛸 수 있는 좋은 방법이 없을까 생각했다.

음악을 듣던 중이었어서 불현듯 "뛰는 속도가 늦춰지면 노래가 멈춰버리는" 앱 아이디어가 떠올랐다. 내가 느려졌다는 사실을 시각 대신 청각을 통해 알 수 있으면 어떨까? (내가 페이스 조절에 실패하게 되는 이유에, 스마트워치를 쓰지 않아서 달리는 중 내 속도를 잘 모르겠던 것도 있었다.)
이 아이디어가 꽤 흥미롭게 느껴져서, 그날 밤 바로 앱 기획 구체화에 착수했다.

나는 직접 앱 개발을 해본 적은 없지만, 앱 개발자와의 협업 경험과 평소 앱 사용경험으로부터 쌓은 배경지식이 있었다. 즉 구현을 위해 어떤 기술이 필요할지 바로 예상이 됐다. 챗지피티와 클로드를 활용해 바이브코딩으로 데모 앱을 만들었다. 처음에 바로 완벽히 동작하지는 않았고, 직접 몸을 움직이면서 테스팅해 버그를 수정하고 UX를 개선했다. 문제없이 동작하는 앱을 완성하는 데 총 3시간이 걸렸다.

앱 이름은 "Run For Music". 바로 떠오른 직관적인 제목을 붙였다.
UI 및 사용 방법은 아래와 같이 단순하다. 서버도 로그인도 없는 로컬 앱이다.

추적 시작 전의 인터페이스는 위와 같다.

설정에서 테마색, 목표 페이스, 음악 정지 지연 시간을 설정할 수 있다.
시스템 설정에 따라 라이트/다크모드를 지원한다.

[라이트 모드] 추적을 시작하고, 내가 설정해 둔 목표 페이스 이내로 빠르게 달리면 음악이 재생된다.

내가 설정해 둔 목표 페이스보다 천천히 달리면 음악이 정지되어버린다.
빠르게 달리면 자동으로 음악이 다시 재생된다.

직접 사용해 본 결과 잘 작동했고, 기대보다 더 만족스러웠다!
느려진다 싶으면 음악이 멈춰버리니까 걸을 수 없었다. 특히 좋아하는 노래가 나올 때, 하이라이트가 끊기지 않도록 일정한 속도로 뛰게 됐다 ‍♀️ 음악이 페이스메이커 역할을 해준 것이다. 그 덕분에 혼자 하는 러닝도 지루하지 않게 느껴져, 평소 뛰던 거리보다 1km나 더 뛰었다!
인스타그램으로 친구들에게 보여주었는데, 무려 3명이나 쓰고 싶다고 APK 다운 링크를 요청했다! 아이디어가 공감을 얻었고, 사람들에게 실질적인 가치를 전달했다는 것이 정말 기뻤다

[Do it! 알고리즘 코딩테스트 - 자바 편] 09. 그래프

Hyun_! — Fri, 10 Apr 2026 23:32:20 +0900

에지 리스트와 인접 리스트가 헷갈림: https://u-it.tistory.com/491

09. 그래프

그래프: 노드와 에지로 구성된 집합
- 노드: 데이터를 표현하는 단위
- 에지: 노드를 연결
(트리도 그래프의 일종)

09-1. 그래프의 표현

그래프를 구현하는 방법은 3가지.

1. 에지 리스트(edge list): "에지를 중심"으로 그래프를 표현.
- 배열에 "출발 노드, 도착 노드"를 저장하여 에지를 표현
- 또는 "출발 노드, 도착 노드, 가중치"를 저장하여 가중치가 있는 에지를 표현.

에지 리스트로 가중치 없는 그래프 표현하기
- 가중치가 없는 그래프는 출발 노드와 도착 노드만 표현 -> 배열 열은 2개면 충분.
노드는 여러 자료형을 사용할 수 있는데 다음의 경우 노드는 Integer형.
방향 그래프: 1->2, 1->3, 2->4, 2->5, 3->4, 4->5
=> [[1, 2]], [1, 3], [2, 4], [2, 5], [4, 5]] = A[N][2]

이처럼 방향이 있는 그래프는 순서에 맞게 노드를 배열에 저장하는 방식으로 표현한다.
그리고 노드를 배열에 저장하여 에지를 표현하므로 에지 리스트라고 한다.
- 만약 방향이 없는 그래프라면 1<->2는 [1, 2], [2, 1]

에지 리스트로 가중치 있는 그래프 표현하기
가중치가 있는 그래프는 열을 3개로 늘려 3번째 열에 가중치를 저장하면 된다.
1->2로 향하는 가중치가 8인 에지는 이제 [1, 2, 8]로 표현된다.
[[1, 2, 8], [1, 3, 3], ...] = A[N][3]

에지 리스트는 구현하기 쉬운데 특정 노드와 관련되어있는 에지를 탐색하기는 지 않다.
에지 리스트는 벨만 포드나 크루스칼(MST) 알고리즘에 사용한다.

2. 인접 행렬(adjacency matrix)은 2차원 배열을 자료구조로 이용하여 그래프를 표현한다.
노드 중심으로 그래프를 표현한다.

인접 행렬로 가중치 없는 그래프 표현하기
1~5번 노드가 각각 간선 가짐. 출발노드: 행, 도착노드: 열
x->y가 있으면 5*5 행렬에서 arr[x][y]=1로 설정

인접 행렬로 가중치 있는 그래프 표현하기
x-num->y가 있으면 5*5 행렬에서 arr[x][y]=가중치값num 으로 설정

인접 행렬을 이용한 그래프 구현은, 쉽고 두 노드를 연결하는 에지의 여부와 가중치값을 배열에 직접 접근해 바로 확인할 수 있는 게 장점.
하지만 노드와 관련되어있는 에지를 탐색하려면 N번 접근해야 하므로, 노드 개수에 비해 에지가 적을 때는 공간 효율성이 떨어진다.
또한 노드 개수가 많은 경우 아예 2차원 배열 선언 자체를 할 수 없음.
=> 따라서 인접 행렬은 노드 개수에 따라 사용 여부를 적절하게 판단해야 함
예를 들어 노드가 3만 개를 넘으면 자바 힙 스페이스 에러가 발생한다.

3.인접 리스트: 리스트 배열.
인접 리스트는 ArrayList로 그래프를 표현한다. 노드 개수만큼 ArrayList를 선언. 자료형은 경우에 맞게 사용.
ArrayList<Integer>[5]
- 인접 리스트에는 N번 노드와 연결되어 있는 노드를 배열의 위치 N에 연결된 노드 개수만큼 배열을 연결하는 방식으로 표현한다.
- 예를 들어 노드 1과 연결된 2, 3 노드는 ArrayList[1]에 [2, 3]을 연결하는 방식으로 표현한다.
ArrayList<Integer>[N] = [1]->[2],[3] [2]->[4],[5] ... 이런식
- 여기서도 방향이 있는 그래프를 표현한것

인접 리스트로 가중치 있는 그래프 표현하기
- 가중치가 있는 경우 자료형을 클래스로 사용한다.
(도착 노드, 가중치)를 갖는 Node 클래스를 선언하여 ArrayList에 사용한다.
ArrayList<Node>[N] = [1]->[2,8],[3,3] [2]->[4,4][5,15] ...

ArrayList[1]에 [(2,8), (3,3)]
노드 1과 2가 가중치 8 에지로, 노드 1과 3이 가중치 3 에지로 연결되어있다는 것을 보여줌. 방향성도 고려되어있음
인접리스트 구현은 복잡한 편이지만, 노드와 연결되어있는 에지를 탐색하는 시간이 매우 뛰어남
노드 개수가 커도 공간 효율이 좋아 메모리 초과 에러 발생 X
이런 장점으로 실제 코딩 테스트에서는 인접 리스트를 이용한 그래프 구현을 선호한다.

[18352번: 특정 거리의 도시 찾기] / 실2
Java

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

public class Main {
    static List<Integer>[] graph;
    static int N, M, K, X;

    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());
        K = Integer.parseInt(st.nextToken());
        X = Integer.parseInt(st.nextToken());
        graph = new ArrayList[N+1];
        for(int i=1; i<=N; i++){
            graph[i] = new ArrayList<>();
        }

        for(int i=0; i<M; i++){
            st = new StringTokenizer(br.readLine());
            int A = Integer.parseInt(st.nextToken());
            int B = Integer.parseInt(st.nextToken());
            graph[A].add(B); 
        }

        int[] dist = new int[N+1];
        Arrays.fill(dist, -1); // 방문 안 한 상태 초기화
        
        Queue<Integer> q = new ArrayDeque<>();
        q.add(X);
        dist[X] = 0;
        while(!q.isEmpty()){
            int cur = q.poll();
            for(int next : graph[cur]){
                if(dist[next] == -1){ // 첫 방문일 때만
                    dist[next] = dist[cur] + 1;
                    q.add(next);
                }
            }
        }

        boolean printed = false;
        for(int i=1; i<=N; i++){
            if(dist[i] == K){
                System.out.println(i);
                printed = true;
            }
        }
        if(!printed) System.out.println(-1);
    }
}

C++

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int dist[300001];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n, m, k, x;
    cin >> n >> m >> k >> x;

    vector<vector<int>> graph(n+1);
    for (int i = 0; i < m; i++) {
        int a, b;
        cin >> a >> b;
        graph[a].push_back(b);
    }

    // dist 초기화 (-1 = 미방문)
    fill(dist, dist+n+1, -1);

    queue<int> q;
    q.push(x);
    dist[x] = 0;

    // BFS
    while (!q.empty()) {
        int curr = q.front();
        q.pop();
        for (int next : graph[curr]) {
            if (dist[next] == -1) {
                dist[next] = dist[curr] + 1;
                q.push(next);
            }
        }
    }

    bool found = false; // 1개라도 찾았는지 확인용
    // 오름차순 출력
    for (int i = 1; i <= n; i++) {
        if (dist[i] == k) {
            cout << i << "\n";
            found = true;
        }
    }
    if (!found) cout << -1;
}

[1325번: 효율적인 해킹] / 실1
Java

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

public class Main {
    static List<Integer>[] graph;
    static int N, M;
    static int[] count;
    static int[] visited;
    static int visitId = 1; // 현재 visited하는 번호

    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());
        graph = new ArrayList[N+1];
        count = new int[N+1];
        visited = new int[N+1];

        for (int i = 1; i <= N; i++) graph[i] = new ArrayList<>();
        
        // 방향: b -> a
        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            graph[b].add(a);
        }

        int max = 0;
        for (int i = 1; i <= N; i++) {
            count[i] = bfs(i);
            max = Math.max(max, count[i]);
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= N; i++) {
            if (count[i] == max) {
                sb.append(i).append(' ');
            }
        }
        System.out.println(sb);
    }

    static int bfs(int start) {
        visitId++;
        ArrayDeque<Integer> q = new ArrayDeque<>();
        q.add(start);
        visited[start] = visitId;
        
        int cnt = 1;
        while (!q.isEmpty()) {
            int cur = q.poll();
            for (int nxt : graph[cur]) {
                if (visited[nxt] != visitId) { // 이번에 아직 방문 안 했는지
                    visited[nxt] = visitId;
                    cnt++;
                    q.add(nxt);
                }
            }
        }
        return cnt;
    }
}

C++

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    cin >> n >> m;
    vector<vector<int>> graph(n+1);
    for(int i=0; i<m; i++){
        int a, b;
        cin >> a >> b;
        graph[b].push_back(a); // b로인해 a로 가는걸 확인해야
    }
    //BFS
    int maxCnt=0;
    vector<int> comp;
    for(int i=1; i<=n; i++){
        queue<int> q;
        bool visited[n+1]={};
        int cnt=0;
        
        q.push(i);
        visited[i]=true;
        while(!q.empty()){
            int c=q.front();
            q.pop();
            for(int j : graph[c]){
                if(!visited[j]){
                    cnt++;
                    visited[j]=true;
                    q.push(j);
                }
            }
        }
        if(maxCnt==cnt) {
            comp.push_back(i);
        } else if(maxCnt<cnt){
            maxCnt=max(maxCnt,cnt);
            comp.assign(1, i);
        }
    }
    for(int c : comp)
        cout<<c<<" ";
    return 0;
}

[1707번: 이분그래프] / 골4
Java

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

public class Main {
    static List<Integer>[] graph;
    static int[] color;
    static int V, E;
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        int K = Integer.parseInt(br.readLine());
        while (K-- > 0) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            V = Integer.parseInt(st.nextToken());
            E = Integer.parseInt(st.nextToken());
            graph = new ArrayList[V + 1];
            for (int i = 1; i <= V; i++) 
                graph[i] = new ArrayList<>();
            for (int i = 0; i < E; i++) {
                st = new StringTokenizer(br.readLine());
                int a = Integer.parseInt(st.nextToken());
                int b = Integer.parseInt(st.nextToken());
                graph[a].add(b);
                graph[b].add(a);
            }
            color = new int[V+1]; // 0: 미방문, 1/-1: 두 그룹
            if (check()) sb.append("YES\n");
            else sb.append("NO\n");
        }
        System.out.print(sb.toString());
    }

    static boolean check() {
        for (int i = 1; i <= V; i++) {
            if (color[i] == 0) {
                if (!bfs(i)) {
                    return false;
                }
            }
        }
        return true;
    }

    static boolean bfs(int start) {
        Queue<Integer> q = new ArrayDeque<>();
        q.add(start);
        color[start] = 1;

        while (!q.isEmpty()) {
            int cur = q.poll();
            for (int next : graph[cur]) {
                if (color[next] == 0) {
                    color[next] = -color[cur]; // 반대 색으로 칠하기
                    q.add(next);
                } else {
                    if (color[next] == color[cur]) { // 이미 색이 있는데, 인접한 두 정점의 색이 같다면 이분 그래프 X
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

C++
오랜만에 풀어서 이분그래프 뜻을 까먹었었는데... 노드마다 두가지 색을 칠할 수 있는데, 연결된 것끼리는 다 색이 다르면 이분그래프.

 #include <iostream>
#include <vector>
#include <queue>

using namespace std;

bool check(vector<vector<int>> graph, int v){
    int visited[v+1];
    fill(visited, visited+v+1, 0);
    
    for(int i=0; i<v; i++){
        queue<int> q;
        q.push(i);
        
        if(visited[i]==0) visited[i]=1;
        while(!q.empty()){
            int c=q.front();
            q.pop();
            for(int j : graph[c]){
                if(visited[j]==0) {
                    q.push(j);
                    visited[j]=3-visited[c];
                }if(visited[j]==visited[c]) {
                    return false;
                }
            }
        }
    }
    return true;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int tk, v, e;
    cin>>tk;
    while(tk-->0){
        cin>>v>>e;
        vector<vector<int>> graph(v+1);
        for(int i=0; i<e; i++){
            int a, b;
            cin>>a>>b;
            graph[a].push_back(b);
            graph[b].push_back(a);
        }
        if(check(graph, v))
            cout<<"YES\n";
        else    
            cout<<"NO\n";
    }
}

유니온파인드

[1717]

[1976]

[1043]

위상 정렬 (Topological Sort)

방향 그래프에서 노드들을 선후관계를 지키면서 일렬로 나열하는 것
[과목 수강] 수학 → 물리 → 양자역학, 수학 → 통계. "위상 정렬 결과: 수학 → 물리 → 통계 → 양자역학"
순서. 줄세우기. 하면 위상정렬.
진입차수(indegree): 어떤 노드로 들어오는 간선의 수. (진입차수 0 = 선행 조건 없음 = 지금 당장 처리 가능)

알고리즘 동작 (BFS 방식)
1. 모든 노드의 진입차수 계산 (a->b면 v[a].push_back(b))
2. 진입차수 == 0인 노드를 큐에 삽입
3. 큐에서 노드를 꺼내 출력
4. 해당 노드의 이웃 노드들의 진입차수 -1
5. 진입차수가 0이 된 노드를 큐에 삽입
6. 큐가 빌 때까지 반복

DFS로도 할 수 있는데 BFS가 더 좋음. 아래는 DFS...

DFS로 끝까지 내려간 뒤
스택에 쌓고 역순 출력
void dfs(int x){
    visited[x] = true;
    for(int nxt : graph[x]){
        if(!visited[nxt]) dfs(nxt);
    }
    stk.push(x); // 끝난 뒤 push
}
→ 마지막에 스택 pop하면 위상정렬

dfs(1)
  dfs(2)
    dfs(4)
      갈 곳 없음 → stack push(4)
    stack push(2)
  dfs(3)
    4는 이미 visited
    stack push(3)
  stack push(1)

stack: [1, 3, 2, 4] (top이 1)
출력:    1  3  2  4

중요한 조건

DAG (Directed Acyclic Graph) 에서만 가능
사이클이 있으면 위상 정렬 불가 (큐가 비었는데 출력한 노드 수 < 전체 노드 수 → 사이클 존재)

사이클 어떻게 감지?
BFS는 if (출력한 노드 수 != n) { cout << "사이클 존재"; } 면 사이클 있음. 사이클 유무만 판단 가능.
DFS는 vector<int> state(n + 1, 0); 로 미방문했었으면 state[nxt]=0, 방문 중이면 state[nxt]=1, 완료했으면 state[nxt]=2로 체크.
사이클 경로를 추적할 수 있다.

void printCycle(int start, int cur) {
    vector<int> cycle;
    cycle.push_back(cur);
    
    while (cur != start) {  // 시작점 만나면 종료
        cur = parent[cur];
        cycle.push_back(cur);
    }
    reverse(cycle.begin(), cycle.end()); // 가장 부모부터 출력위해
    for (int node : cycle) cout << node << ' ';
}

void dfs(int cur) {
    state[cur] = 1;
    for (int nxt : graph[cur]) {
        if (state[nxt] == 1) {
            printCycle(nxt, cur);  // nxt가 사이클 시작점
            return;
        }
        if (state[nxt] == 0) {
            parent[nxt] = cur;
            dfs(nxt);
        }
    }
    state[cur] = 2;
}

다익스트라

벨만포드

플로이드워셜

최소신장트리

undefined로 검색이 안 되는 버그를 발견한 일

Hyun_! — Sat, 4 Apr 2026 22:16:14 +0900

카카오톡 이용 중 의도치 않게도 흥미로운 버그를 발견했다.
프로필 뮤직에 Xdinary Heroes의 UNDEFINED라는 노래를 설정하고 싶어서 undefined를 검색했다.

그런데 "검색어를 입력해주세요"라고 표시되며 검색이 되지 않았다.

처음에 단순 오류인 줄로 생각해서 5번 이상 반복 입력했다가, '설마 JavaScript 데이터 타입으로 인식되는 건가??' 추측했다.

검색어를 UNDEFINED 대문자로 작성하니 잘 검색되는 것을 확인할 수 있었다.

어떤 구조 때문에 발생하는 걸까? 사용자 입력을 "undefined" 문자열로 처리하면 이런 문제가 발생할 가능성이 없지 않나?

너무 궁금해져서 클로드에게 물어보았다.

클로드 왈:

카카오톡 앱은 내부적으로 검색어를 처리할 때 아마 이런 식의 코드를 쓰고 있을 겁니다:

// 문제가 되는 코드 (추정)
function search(query) {
  if (!query) {
    showMessage("검색어를 입력해주세요");
    return;
  }
  // 검색 실행...
}

사용자가 "undefined"를 문자열로 입력했는데, 어딘가에서 이 값이 실제 undefined로 평가되는 상황이 발생한 거죠.

이게 왜 일어날까?

1. 가장 유력한 시나리오는 타입 변환(type coercion) 과정입니다.

// 입력값을 파싱하거나 객체에서 꺼내는 과정에서
let query = searchInput.value;  // "undefined" (문자열)

// 어딘가에서 이런 처리가 일어났을 가능성
let parsed = JSON.parse(someData);
let keyword = parsed.query; // 키가 없으면 → 실제 undefined

// 혹은 문자열 비교 없이 falsy 체크만 했을 때
if (!keyword) { ... }  // undefined → falsy → "검색어 입력" 메시지 출력

2. 문자열 "undefined"를 명시적으로 예외 처리했을 가능성도 있습니다:

// 방어 코드를 잘못 작성한 경우
if (!query || query === "undefined") {
  showMessage("검색어를 입력해주세요");
  return;
}

이런 코드는 다른 곳에서 실제 undefined가 문자열로 변환된 채로 넘어오는 걸 막으려고 쓰는 패턴인데, 진짜로 "UNDEFINED"라는 곡을 검색하는 사람도 막아버리는 부작용이 생깁니다.

명시적으로 예외 처리했다면, 어떤 역사에서 생겨났을까? (추측)

1. 레거시 코드에서 undefined를 문자열로 넘기는 실수

옛날 JavaScript 코드(혹은 지금도 종종)에서 이런 패턴이 흔했습니다.

// 어딘가에서 값이 없을 때
let keyword = getUserInput(); // 실패하면 undefined 반환

// 문자열 템플릿이나 URL에 그냥 붙여버림
fetch(`/search?q=${keyword}`);
// → /search?q=undefined  ← "undefined"라는 문자열이 서버로 전송됨

서버가 "undefined"라는 쿼리를 받으면 빈 검색처럼 처리하고 싶으니, 프론트나 백엔드 양쪽에서 이걸 걸러내는 코드가 생겨났습니다.

2. localStorage / URL 파라미터에서 꺼낼 때

// 저장할 때 실수로 undefined가 저장됨
localStorage.setItem("lastSearch", undefined);
// → 실제로 "undefined"라는 문자열로 저장됨

// 나중에 꺼내면 문자열 "undefined"가 나옴
const query = localStorage.getItem("lastSearch"); // "undefined"

이 경우 "undefined"를 그대로 검색창에 넣으면 사용자 입장에서 이상한 경험이 되니까, 이걸 막으려는 코드가 추가됐을 겁니다.

3. 서버에서 JSON으로 받을 때

const data = await response.json();
const query = data.lastKeyword; // 키가 없으면 → undefined
const queryStr = String(query);  // → "undefined" (문자열)

// 이걸 그냥 검색창 초기값으로 넣어버리면...
searchInput.value = queryStr; // "undefined"가 입력창에 표시됨

예외 처리가 필요했던 역사가 있지 않았을까 추측해본다. undefined라는 제목의 노래가 꽤 있기 때문에 다른 이용자들도 동일한 버그를 경험했을 수 있을 것 같아서 고객센터 문의로 제보하였다. 나중에는 undefined를 검색할 수 있게 될지 궁금하다.

회사에서 서비스 개발할 때 테스팅도 많이 해서 "버그 발견 -> 재현 -> 원인 분석 -> 보고 및 해결" 과정을 완전히 체득해버린 것 같다. 재미있다

p.s.

이전에 각종 웹사이트에서 유저네임으로 프로그래밍 관련 특수한 이름들을 사용할 수 없도록 막아놓은 것이 흥미로웠는데

위와 같은 일이 발생하는 것을 막고자 한 것이었다.

GitHub는 undefined가 안 되고 null은 된다

Instagram은 null이 안 되고 undefined는 된다

[Do it! 알고리즘 코딩테스트 - 자바 편] 07. 그리디

Hyun_! — Thu, 6 Nov 2025 20:59:48 +0900

07. 그리디

그리디 알고리즘: '현재 상태에서 보는 선택지 중 최선의 선택지'가 전체 선택지 중 최선의 선택지라고 가정하는 알고리즘

그리디 알고리즘의 핵심 이론:

1. 해 선택: 현재 상태에서 가장 최선이라고 생각되는 해를 선택한다.

2. 적절성 검사: 현재 선택한 해가 전체 문제의 제약 조건에 벗어나지 않는지 검사한다.

3. 해 검사: 현재까지 선택한 해 집합이 전체 문제를 해결할 수 있는지 검사한다. 전체 문제를 해결하지 못한다면 1로 돌아가 같은 과정을 반복한다.

[11047번: 동전 0] / 실4

동전을 최소로 사용해 K를 만들기 위해서는 가장 가격이 큰 동전부터 차례대로 사용하면 된다.

import java.util.Scanner;

public class Main {
    public static void solution() throws Exception {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int count = 0;
        int[] coins = new int[n];

        for (int i = 0; i < n; i++) {
            coins[i] = sc.nextInt();
        }
        for (int i = n - 1; i >= 0; i--) {
            if (k == 0)
                break;
            count += k / coins[i];
            k %= coins[i];
        }
        System.out.print(count);
    }

    public static void main(String[] args) throws Exception {
        solution();
    }
}

[1715번: 카드 정렬하기] / 골5

카드 묶음의 카드의 개수가 작은 순서대로 먼저 합치는 것이 전체 비교 횟수를 줄일 수 있는 방법이다.

현재 데이터 중 가장 작은 카드의 개수를 가진 묶음 2개를 뽑아야 하고, 이 2개를 기준으로 합친 새로운 카드 묶음을 다시 데이터에 넣고 정렬해야 한다. -> 데이터의 삽입 삭제 정렬이 자주 일어남 -> 우선순위 큐를 이용.

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

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for(int i=0; i<n; i++) {
            pq.add(Integer.parseInt(br.readLine()));
        }
        int sum=0;
        while(pq.size() >= 2){
            int a = pq.poll();
            int b = pq.poll();
            pq.add(a+b);
            sum += (a+b);
        }
        System.out.println(sum);
    }
}

[1744번: 수 묶기]

절댓값이 큰 것들부터 서로 곱해야 결과값이 커지고, 음수의 갯수가 홀수 개일 때 0이 있다면 곱해서 없애주어야 한다.

양수/음수 큐를 따로 만들어야 했는데 이 부분을 놓쳤다..!

=> 음수를 오름차순으로 양수를 내림차순으로 정렬하는 큐에 넣은 뒤 절댓값이 큰 것부터 소모시키기. 1은 항상 곱하지 말고 더해야 한다.

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

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());
        PriorityQueue<Integer> plus = new PriorityQueue<>(Collections.reverseOrder()); // 양수는 내림차순 정렬
        PriorityQueue<Integer> minus = new PriorityQueue<>(); // 음수는 오름차순 정렬
        int oneCount = 0;
        int zeroCount = 0;
        int result = 0;

        for (int i = 0; i < n; i++) {
            int k = Integer.parseInt(br.readLine());
            if (k > 1) plus.add(k);
            else if (k == 1) oneCount++;
            else if (k == 0) zeroCount++;
            else minus.add(k);
        }
        
        // 양수 처리 (내림차순)
        while (plus.size() > 1) {
            int a = plus.poll();
            int b = plus.poll();
            result += a * b;
        }
        if (!plus.isEmpty())
            result += plus.poll();

        // 음수 처리 (오름차순)
        while (minus.size() > 1) {
            int a = minus.poll();
            int b = minus.poll();
            result += a * b;
        }
        if (!minus.isEmpty()) { // 음수 하나 남은 경우
            if (zeroCount == 0)
                result += minus.poll(); // 0 없으면 더함
        }

        // 1은 전부 더하기
        result += oneCount;

        System.out.println(result);
    }
}

[1931번: 회의실 배정] / 골5

정렬을 사용해, 무조건 빨리 끝나는 회의를 선택하는 것이 이득이다.

https://hereishyun.tistory.com/209

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

public class Main{
    public void solution() throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        int n = Integer.parseInt(br.readLine());
        int[][] meetings = new int[n][2];
        for(int i=0; i<n; i++){
            StringTokenizer st = new StringTokenizer(br.readLine());
            meetings[i][0] = Integer.parseInt(st.nextToken());
            meetings[i][1] = Integer.parseInt(st.nextToken());
        }
        // 끝나는 시간이 작은 것부터 오름차순 정렬
        Arrays.sort(meetings, (a, b) -> {
            if (a[1] != b[1]) return Integer.compare(a[1], b[1]);
            return Integer.compare(a[0], b[0]);
        });
        
        int count = 0, prevEnd = 0;
        for (int i=0; i<meetings.length; i++) {
            if (meetings[i][0] >= prevEnd) {
                prevEnd = meetings[i][1];
                count++;
            }
        }
        System.out.println(count);
    }
	public static void main(String[] args) throws Exception {
		new Main().solution();
	}
}

[1541번: 잃어버린 괄호] / 실2

괄호를 적절히 쳐서 식의 값을 최소로 만드려 한다.

-를 기준으로 식을 분리(->그룹), 첫번째 그룹(숫자합)을 구하고 나머지 그룹(숫자합)들을 뺀다.

Python

expr = input().strip()

parts = expr.split('-')

initial = sum(map(int, parts[0].split('+')))

rest = 0
for part in parts[1:]:
    rest += sum(map(int, part.split('+')))

print(initial - rest)

Java

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String expr = br.readLine();
        String[] minusSplit = expr.split("-");
        int result = 0;
        for (int i = 0; i < minusSplit.length; i++) {
            int groupSum = 0;
            // '+'로 나눈 부분을 모두 더하기
            String[] plusSplit = minusSplit[i].split("\\+");
            for (String num : plusSplit) {
                groupSum += Integer.parseInt(num);
            }
            // 첫 그룹은 더하고, 이후 그룹들은 모두 빼기
            if (i == 0) result = groupSum;
            else result -= groupSum;
        }

        System.out.println(result);
    }
}

[Do it! 알고리즘 코딩테스트 - 자바 편] 06. 탐색 (DFS, BFS, 백트래킹, 이진탐색)

Hyun_! — Thu, 30 Oct 2025 19:59:44 +0900

06. 탐색

탐색: 주어진 데이터에서 자신이 원하는 데이터를 찾아내는 알고리즘. 주어진 데이터의 성질(정렬/비정렬)에 따라 적절한 탐색 알고리즘을 선택하는 것이 중요, 직접 구현해 원리를 완벽하게 이해해야 한다.
그래프를 자주 이용한다.
( c.f. [알고리즘] 완전탐색 기법 https://velog.io/@717lumos/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EC%99%84%EC%A0%84%ED%83%90%EC%83%89-%EA%B8%B0%EB%B2%95 )

06-1. 깊이 우선 탐색

DFS: 그래프 완전 탐색 기법 중 하나.
- 특징: 재귀 함수로 구현, 스택 자료구조 이용
- 시간 복잡도: O(V+E)
- 실제 구현 시 재귀 함수를 이용하므로 스택 오버플로우에 유의해야 한다.
- DFS로 풀 수 있는 대표 문제 유형: 단절점 찾기, 단절선 찾기, 사이클 찾기, 위상 정렬

DFS의 핵심 이론 - 한 번 방문한 노드를 다시 방문하면 안 되므로, 노드의 방문 여부를 체크할 배열 필요. 인접 리스트로 표현.

1. DFS를 시작할 노드를 정한 후 사용할 자료구조 초기화하기
- DFS를 위해 필요한 초기 작업은 (1) 인접 리스트로 그래프 표현하기, (2) 방문 배열 초기화하기, (3) 시작 노드 스택에 삽입하기 (재귀 시작하기. 방문 체크.)
2. 스택에서 노드를 꺼낸 후 꺼낸 노드의 인접 노드를 다시 스택에 삽입하기
- pop을 수행해 노드 꺼내기.
- 꺼낸 노드를 탐색 순서에 기록하고, 인접 리스트의 인접 노드를 스택에 삽입하며 방문 배열을 체크.
(1->2, 3 이라면 1을 꺼내고 2, 3을 넣을 때 2, 3의 방문여부를 T로 변경)
3. 스택 자료구조에 값이 없을 때까지 반복하기
- 이미 다녀간 노드는 방문 배열을 바탕으로 재삽입하지 않기

[11724번: 연결 요소의 개수] / 실2
방향 없는 그래프가 주어졌을 때, 연결 요소(Connected Component)의 개수를 구하는 프로그램을 작성하는 문제.
입력: 정점의 개수 N, 간선의 개수 M, 간선(양 끝 점 u, v번호로서 주어짐)
- 같은 간선은 한 번만 주어진다.
출력: 첫째 줄에 연결 요소의 개수를 출력

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

public class Main {
    static List<Integer>[] graph; // 그래프 나타내는 리스트 배열
    static boolean[] visited; // 방문 확인용 배열

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] nm = br.readLine().split(" ");
        int n = Integer.parseInt(nm[0]);
        int m = Integer.parseInt(nm[1]);

        graph = new ArrayList[n+1]; // 0번은 사용하지 않음
        for (int i=1; i<=n; i++) graph[i] = new ArrayList<>();

        for (int i=0; i<m; i++) { // 간선 m개
            String[] uv = br.readLine().split(" ");
            int u = Integer.parseInt(uv[0]);
            int v = Integer.parseInt(uv[1]);
            // graph 각각의 리스트에 원소 삽입
            graph[u].add(v);
            graph[v].add(u);
        }

        visited = new boolean[n+1]; // 방문 확인용 배열
        int count = 0; // 연결 요소의 개수 세는 변수
        for (int i=1; i<=n; i++) {
            if (!visited[i]) {
                dfs(i);
                count++;
            }
        }
        System.out.println(count);
    }
    
    // 연결되어있는 노드는 모드 방문 처리
    static void dfs(int node) {
        visited[node] = true;
        for (int neighbor : graph[node]) {
            if (!visited[neighbor]) {
                dfs(neighbor);
            }
        }
    }
}

[2023번: 신기한 소수] / 골5
앞에서부터 한 자리씩 추가하며 읽었을 때 모두 소수이면 '신기한 소수'.
N이 입력되면, N자리 수 중에서 신기한 소수를 오름차순으로 정렬해 한 줄에 하나씩 출력.
처음에 에라토스테네스의 체를 사용해 풀었는데 메모리 초과가 발생했다. 크기가 1억인 배열을 만든 것이 문제였다...

소수 여부를 확인하기 위해 boolean 배열 대신 boolean 메소드를 이용해, i를 약수로 갖는지 확인하는 방식으로 풀어야 했다. (i는 2 이상, i*i<=num)
사실 맨 처음에 떠올렸던 방법인데 아쉽다..! 너무 큰 메모리를 잡지 않도록 주의하자.

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

public class Main {
    static int n;

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

        // 1자리 소수에서 시작
        int[] primes = {2, 3, 5, 7};
        for (int p : primes) {
            dfs(1, p);
        }
    }
    
    // curr이 소수인 경우 계속 탐색, digit이 n자리 도달 시 출력
    static void dfs(int digit, int curr) {
        if (!isPrime(curr))
            return;
        if (digit == n) {
            System.out.println(curr);
            return;
        }

        // 다음 자릿수 붙이기 (1~9)
        for (int i=1; i<=9; i++) {
            dfs(digit+1, curr*10+i);
        }
    }

    static boolean isPrime(int num) {
        if (num < 2)
            return false;
        for (int i=2; i*i<=num; i++) {
            if (num%i==0)
                return false;
        }
        return true;
    }
}

[13023번: ABCDE] / 골5
총 N명이 있다. A-B-C-D-E 이렇게 5명이 이어진 관계가 존재하는지, 즉 dfs 깊이가 5이상이 되는 것이 있는지 여부를 출력.
쓸데없이 사이클 형성에 대해 고민했는데...; 사이클을 생각할 필요 없었다.
이 문제에서는 visited 방문 배열을 연결 요소 문제처럼 '한 번이라도 연결되어있는지' 확인 목적이 아니라, '이번의 쭉 긴 탐색에서 거쳤는지' 목적으로 사용해야 했다. 따라서 백트래킹 식으로 visited를 true/false 바꿔주어야 했다...!!
visited 방문 배열 사용 목적에 대해 정확하게 고민할 것!! 이건 백트래킹!!

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

public class Main {
    static int N, M;
    static ArrayList<Integer>[] graph;
    static boolean[] visited;
    static boolean found = false;

    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());
        
        graph = new ArrayList[N];
        for (int i = 0; i < N; i++) {
            graph[i] = new ArrayList<>();
        }

        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            graph[a].add(b);
            graph[b].add(a);
        }

        visited = new boolean[N];
        for (int i = 0; i < N; i++) {
            dfs(i, 1);
            if (found) break;
        }
        System.out.println(found ? 1 : 0);
    }

    static void dfs(int node, int depth) {
        if (found) return; // 이미 찾았으면 중단
        if (depth == 5) {
            found = true;
            return;
        }

        visited[node] = true;
        for (int next : graph[node]) {
            if (!visited[next]) {
                dfs(next, depth + 1);
            }
        }
        visited[node] = false;
    }
}

06-2. 백트래킹

백트래킹: 문제를 해결하는 모든 경로를 탐색하는 기법. (조건에 맞는)
- 특징: 재귀 함수로 구현, 가지치기로 성능 향상(pruning-유효하지 않는 경로 조기 차단)
- 시간 복잡도: O(N^d)
- 백트래킹을 활용 가능한 대표 문제: 조합, 순열, N-Queens

백트래킹의 핵심 이론 - 문제를 해결하기 위해 가능한 경로를 탐색하면서, 조건을 만족하지 않는 경로를 가지치기해 탐색 범위를 줄임. 재귀로 구현. (바로 이전 단계로 되돌아가 다른 경로를 시도)

1. 가능한 선택지 탐색하기: 현재 상태에서 가능한 모든 선택지를 탐색
2. 유효성 검사 및 가지치기: 각 선택지가 문제의 조건을 만족하는지 검사. 만약 조건을 만족하지 않으면, 해당 경로는 더이상 탐색하지 않고 즉시 이전 단계로 되돌아감.
3. 해답 도출하기: 조건을 만족하는 해답을 찾으면 이를 기록하고, 필요에 따라 다른 경로도 계속 탐색.

[15649번: N과 M] / 실3
자연수 N과 M이 주어졌을 때, "1부터 N까지 자연수 중에서 중복 없이 M개를 고른 수열"(길이가 M)을 모두 구하기
아래처럼 풀었는데, 사용한 값인지 확인하는 코드와 현재 수열의 값을 보관하는 코드를 어느 줄에 써야 할지 약간 헷갈렸다...
이건 매 회차 사용여부가 달라지는 백트래킹 문제! if문 안에서 재귀함수 진입지점 주위로 t/f 감싸자!

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

public class Main {
    static int n, m;
    static boolean[] visited;
    static int[] nums;

    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());
        visited = new boolean[n+1]; // n번이 사용되었는지를 확인 (1~n)
        nums = new int[m];
        for(int i=1; i<=n; i++) {
            dfs(i, 0);
        }
    }

    static void dfs(int curr, int idx) {
        if(visited[curr]) {
            return;
        }
        visited[curr] = true;
        nums[idx]=curr;
        if(idx==m-1){
            for(int i=0; i<m; i++) {
                System.out.print(nums[i]+" ");
            }
            System.out.println();
        } else {
            for(int i=1; i<=n; i++){
                dfs(i, idx+1);
            }
        }
        visited[curr] = false;
    }
}

이 풀이가 더 직관적인 것 같다.
이건 매 회차 사용여부가 달라지는 백트래킹 문제! 사용되지 않았음을 확인한 if문 내에서, 재귀함수 호출지점 위아래로 check t/f 업데이트 코드를 두어서 감싸자!

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

public class Main {
    static int n, m;
    static int[] num;
    static boolean[] check;

    static void backtracking(int cnt) {
        if (cnt == m) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < m; i++) {
                sb.append(num[i]).append(' ');
            }
            System.out.println(sb);
            return;
        }

        for (int i = 1; i <= n; i++) {
            if (!check[i]) {
                num[cnt] = i;
                check[i] = true;
                backtracking(cnt + 1);
                check[i] = false;
            }
        }
    }

    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());

        num = new int[m];
        check = new boolean[n + 1];

        backtracking(0);
    }
}

[N-Queen 배치하기] / 골4
https://www.acmicpc.net/problem/9663

[17136번: 색종이 붙이기] / 골2
https://www.acmicpc.net/problem/17136

06-3. BFS

BFS: 그래프 완전 탐색 기법 중 하나. 시작 노드에서 출발해 시작 노드를 기준으로 가까운 노드를 먼저 방문하면서 탐색하는 알고리즘.
- 특징: FIFO 탐색, Queue 자료구조 이용
- 시간 복잡도: O(V+E)

BFS는 FIFO 방식으로 탐색하므로 큐를 이용해 구현한다.
BFS는 탐색 시작 노드와 가까운 노드를 우선하여 탐색하므로, 목표 노드에 도착하는 경로가 여러 개일 때 최단 경로를 보장한다.

BFS의 핵심 이론:
1. BFS를 시작할 노드를 정한 후 사용할 자료구조 초기화하기
2. 큐에서 노드를 꺼낸 후 꺼낸 노드의 인접 노드를 다시 큐에 삽입하기
3. 큐 자료구조에 값이 없을 때까지 반복하기

[1260번: DFS와 BFS] / 실2
DFS와 BFS를 구현하는 문제. 이 형태 완전히 암기하기!!

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

public class Main
{
    static int n, m, v;
    static List<Integer>[] A; // 그래프
    static boolean[] visited;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken()); // 정점 수
        m = Integer.parseInt(st.nextToken()); // 간선 수
        v = Integer.parseInt(st.nextToken()); // 탐색 시작 정점 수
        
        A = new ArrayList[n+1]; // n+1 크기의 배열 (A[0]은 사용하지 않음)
        for(int i=1; i<=n; i++){
            A[i] = new ArrayList<>();
        }
        for(int i=0; i<m; i++){
            st = new StringTokenizer(br.readLine());
            int s = Integer.parseInt(st.nextToken());
            int e = Integer.parseInt(st.nextToken());
            // 양방향
            A[s].add(e);
            A[e].add(s);
        }
        
        // 번호가 작은 것부터 먼저 방문하기 위해 정렬
        for(int i=1; i<=n; i++){
            Collections.sort(A[i]);
        }
        
        visited = new boolean[n+1];
        dfs(v);
        System.out.println();
        
        visited = new boolean[n+1];
        bfs(v);
        System.out.println();
	}
	
	//for문+재귀
	static void dfs(int node){
	    System.out.print(node+" ");
	    visited[node]=true;
	    for(int i : A[node]){
	        if(!visited[i])
	            dfs(i);
	    }
	}
	// while문+for문+큐
	static void bfs(int node){
	    Queue<Integer> q = new LinkedList<>();
	    q.add(node);
	    visited[node]=true;
	    
	    while(!q.isEmpty()){
	        int now = q.poll();
	        System.out.print(now+" ");
	        for(int i : A[now]) {
	            if(!visited[i]){
	                visited[i]=true;
	                q.add(i);
	            }
	        }
	    }
	}
}

[2176번: 합리적인 이동경로] / 실1
https://www.acmicpc.net/problem/2176

[1167번: 트리의 지름] / 실1
https://www.acmicpc.net/problem/1167

06-4. 이진 탐색

이진 탐색: 데이터가 '정렬'되어 있는 상태에서 '원하는 값'을 찾아내기 위해 사용하는 알고리즘.
대상 데이터의 중앙값과 찾고자 하는 값을 비교해 데이터의 크기를 절반씩 줄이면서 대상을 찾는다.
- 기능: 타깃 데이터 탐색
- 특징: 중앙값 비교를 이용한 대상 축소 방식
- 시간 복잡도: O(logN)

이진 탐색의 핵심 이론: 오름차순으로 정렬된 데이터에서 다음 4가지 과정을 반복. (내림차순이라면 조건을 반대로 하여 과정을 반복)
1. 현재 데이터셋의 중앙값을 선택.
2. 중앙값 > 타깃 데이터 일 때 중앙값 기준으로 왼쪽 데이터셋을 선택.
3. 중앙값 < 타깃 데이터 일 때 중앙값 기준으로 오른쪽 데이터셋을 선택.
4. 과정 1~3을 반복하다가 중앙값==타깃 데이터일 때 탐색을 종료.

[1920번: 수 찾기] / 실4
https://www.acmicpc.net/problem/1920

[2343번: 기타 레슨] / 골5
강의 순서를 유지하면서 M개의 블루레이에 모든 강의를 나누되, 블루레이 용량의 최소값을 구하는 문제.
이진 탐색으로 가능한 최소 용량을 찾아야 함 => 각 블루레이 용량을 mid로 가정해 필요한 블루레이 개수를 계산!!

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

public class Main {
    static int n, m;
    static int[] a;

    static boolean can(int cap) {
        int cnt = 1, sum = 0;
        for (int x : a) {
            if (sum + x > cap) {
                cnt++;
                sum = 0;
            }
            sum += x;
        }
        return cnt <= m;
    }

    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());
        a = new int[n];
        st = new StringTokenizer(br.readLine());

        int l = 0, r = 0;
        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(st.nextToken());
            l = Math.max(l, a[i]);
            r += a[i];
        }

        int ans = r;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (can(mid)) {
                ans = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        System.out.println(ans);
    }
}

[1300번: K번째 수]
https://www.acmicpc.net/problem/1300

[CS 지식의 정석] 3. 네트워크

Hyun_! — Fri, 24 Oct 2025 14:02:06 +0900

네트워크 기초

네트워크: 노드(서버·라우터·스위치 등)와 링크(유선·무선)가 연결된 구조로 자원 공유를 목표로 함.
트래픽: 특정 시점에 흐르는 데이터 총량 (단위 bps).
처리량: 성공적으로 전송된 데이터량 → 트래픽 처리 성능 지표.
대역폭: 일정 시간 동안 흐를 수 있는 최대 비트 수(=최대 처리용량). 대역폭↑ → 서비스 속도↑.
RTT: 왕복지연시간. 송신~수신확인까지 걸리는 시간.

네트워크 토폴로지

버스형: 하나의 회선에 모든 노드 연결. 설치 간단·저비용 / 회선 장애 시 전체 영향.
스타형: 중앙 노드(허브·스위치) 중심 별모양 연결. 보안관리 용이 / 중앙노드 장애 시 전체 마비.
트리형: 계층 구조. 리프노드 확장 용이 / 루트노드 장애 시 전체 영향.
링형: 노드들이 고리 형태로 연결. 토큰 기반 충돌 無 / 전송 지연·고장 노드 탐지 용이.
메시형: 모든 노드가 서로 직접 연결. 안정성↑ / 비용·설계 복잡도↑.

병목현상과 토폴로지 필요성

병목현상: 특정 구간에 트래픽 집중으로 속도 저하. 원인=대역폭 부족, 서버 처리 한계, 토폴로지 설계 미흡.
토폴로지 분석을 통해 병목 구간 파악→로드밸런싱·서버 분산 등 해결 가능.

데이터 전송 방식

유니캐스트: 1:1 전송 (예: HTTP).
멀티캐스트: 1:N(특정 그룹 대상).
브로드캐스트: 1:N(모든 노드). 대표 예: ARP.

네트워크 분류

LAN: 근거리망(가정·사무실). 속도↑, 안정성↑.
MAN: 대도시망, 여러 LAN 연결.
WAN: 국가 간 통신망, 인터넷.

TCP/IP 4계층과 OSI 7계층

TCP/IP 4계층:
① 애플리케이션(HTTP, FTP, SSH, SMTP)
② 전송(TCP, UDP)
③ 인터넷(IP, ICMP, ARP)
④ 링크(Ethernet 등 물리적 전송).
캡슐화: 상위 데이터에 하위 계층 헤더 추가.
비캡슐화: 수신측이 헤더 역으로 제거.
PDU: 계층별 데이터 단위 (메시지–세그먼트–패킷–프레임–비트).
체크섬: 전송 오류 검증용 값. (IPv4, TCP/UDP=1의보수합, Ethernet=CRC32).

MTU와 단편화

MTU(Maximum Transmission Unit): 한 번에 전송 가능한 최대 프레임 크기(이더넷 기준 1500B). MTU 초과 시 IP 단편화(Fragmentation) 발생 → 성능 저하 위험. TCP는 MSS(Max Segment Size)로 MTU 이하로 조절, UDP는 자체 제어 없음.

TCP와 UDP

TCP(Transmission Control Protocol): 연결형, 신뢰성 보장, 순서 보장, 흐름·혼잡 제어 지원. 3-way handshake(연결)와 4-way handshake(해제) 사용. 전송 단위=세그먼트.
UDP(User Datagram Protocol): 비연결형, 신뢰성·순서 미보장, 빠른 전송(스트리밍, DNS 등). 전송 단위=데이터그램.
TCP 흐름 제어(Sliding Window): 송신측이 수신측 버퍼 크기 고려해 전송량 조절.
혼잡 제어(Congestion Control): 네트워크 혼잡 시 윈도우 크기 줄이는 알고리즘 (Slow Start, Congestion Avoidance 등).

포트와 소켓

포트(Port): 애플리케이션 식별 번호(0~65535). TCP/UDP 각각 독립 관리.
소켓(Socket): IP + Port 결합한 통신 단위. (예: 192.168.0.1:8080).
Ephemeral Port: 임시 세션용 포트(보통 49152~65535).

라우팅과 NAT

라우팅(Routing): 패킷 전달 경로를 결정하는 과정. 정적 라우팅(관리자 수동 설정), 동적 라우팅(라우터 간 정보 교환: RIP, OSPF, BGP).
NAT(Network Address Translation): 사설 IP ↔ 공인 IP 변환 기술. IPv4 주소 절약, 내부망 보호.
PAT(Port Address Translation): 여러 내부 IP를 하나의 공인 IP로 변환 시 포트번호로 구분.

IP 주소 체계

IPv4: 32비트(4옥텟), 예: 192.168.0.1. 클래스 A~E(네트워크/호스트 구분). 사설 IP: A(10.0.0.0/8), B(172.16.0.0/12), C(192.168.0.0/16).
IPv6: 128비트, 16진수 표기(예: 2001:db8::1). 주소 부족 해결, 자동 설정, 보안 강화(IPsec 내장).
서브넷 마스크: 네트워크/호스트 영역 구분. (예: 255.255.255.0 → /24).
CIDR(Classless Inter-Domain Routing): 클래스 구분 없이 네트워크 경계 자유 설정.

DNS(Domain Name System)

도메인명 ↔ IP 주소 변환.
계층 구조: Root → TLD(.com/.kr) → 2차 도메인 → 서브도메인.
동작: 클라이언트 → 로컬 DNS → 루트 DNS → 권한 DNS → IP 반환.
레코드 유형: A(IPv4), AAAA(IPv6), MX(메일), CNAME(별칭), TXT(인증).
캐싱으로 성능 향상(TTL 기반).

DHCP(Dynamic Host Configuration Protocol)

IP 자동 할당 프로토콜. Discover → Offer → Request → Acknowledge(DORA 과정).
임대 기간(Lease time) 만료 시 재갱신 요청.
수동 IP 충돌 방지, 대규모 네트워크 자동화.

HTTP 프로토콜

HTTP(HyperText Transfer Protocol): 클라이언트와 서버 간 요청·응답 기반 통신 규약.
Stateless 구조로, 각 요청은 독립적으로 처리.
요청 구성: Method(행위), Header(메타데이터), Body(데이터).
응답 구성: Status Line(코드), Header, Body.
주요 Method: GET(조회), POST(생성), PUT(전체 수정), PATCH(부분 수정), DELETE(삭제).
주요 Status Code: 200 OK, 301 Redirect, 400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 500 Internal Server Error.
HTTP/1.1: Keep-Alive로 다중 요청 가능, 파이프라이닝 지원.
HTTP/2: 멀티플렉싱, 헤더 압축(HPACK), 서버 푸시.
HTTP/3: QUIC 기반 UDP 프로토콜로 지연 최소화, 연결 복원성 강화.

HTTPS 프로토콜

HTTP + SSL/TLS 암호화 계층을 더한 보안 통신 프로토콜.
핸드셰이크 과정에서 인증서 기반 공개키 교환 및 세션키 생성.
대칭키로 데이터 암호화, 비대칭키로 키 교환.
SSL 인증서: 인증기관(CA)이 발급, 사이트 신뢰성 검증.
이점: 데이터 암호화, 무결성 보장, 중간자 공격 방지.

쿠키와 세션

쿠키: 브라우저에 저장되는 Key-Value 데이터. 로그인 유지, 사용자 맞춤 기능에 사용. 서버 응답 시 Set-Cookie 헤더로 전달.
세션: 서버 메모리 또는 DB에 사용자 상태를 저장. 클라이언트는 Session ID만 쿠키로 저장.
쿠키는 클라이언트 중심, 세션은 서버 중심 관리.
세션이 보안상 유리하나 서버 부하가 커짐.

브라우저 렌더링 과정

HTML 파싱 → DOM 트리 생성
CSS 파싱 → CSSOM 트리 생성
두 트리를 결합해 Render Tree 구성
Layout(배치 계산) → Paint(화면 출력)
JavaScript 실행: DOM 조작, 이벤트 처리
렌더링 차단 요소: <script> 태그의 동기 로드. 해결: async/defer 속성 사용.
Reflow(Layout 재계산)과 Repaint(화면 갱신)는 성능 저하 요인.

CORS 정책

CORS(Cross-Origin Resource Sharing): 다른 도메인 간 리소스 요청 제한 정책.
브라우저 보안상 SOP(Same-Origin Policy) 기반으로 동작.
Origin: 프로토콜 + 도메인 + 포트가 모두 동일해야 동일 출처로 간주.
Preflight Request: 실제 요청 전 OPTIONS 메서드로 서버 허용 여부 확인.
해결 방법: 서버에서 Access-Control-Allow-Origin, Access-Control-Allow-Methods, Access-Control-Allow-Headers 지정.

보안 취약점

XSS(Cross-Site Scripting): 악성 스크립트를 삽입해 사용자 브라우저에서 실행. 방지: 입력값 이스케이프, CSP(Content Security Policy) 적용.
CSRF(Cross-Site Request Forgery): 사용자의 인증 정보를 도용해 원치 않는 요청 수행. 방지: CSRF Token 검증, Referer 검증, SameSite 쿠키 설정.
SQL Injection: 쿼리 조작을 통한 DB 침투. 방지: Prepared Statement 사용, 입력값 검증.

네트워크 계층 요약

물리 계층: 전기적 신호 전송.
데이터링크 계층: 프레임 단위 전송, MAC 주소 기반.
네트워크 계층: IP 주소 기반 라우팅.
전송 계층: TCP/UDP 전송 관리.
세션 계층: 연결 관리 및 동기화.
표현 계층: 암호화·압축 처리.
응용 계층: 사용자 서비스 (HTTP, FTP, SMTP 등).

[CS 지식의 정석] 2. 디자인패턴

Hyun_! — Fri, 24 Oct 2025 13:46:06 +0900

[디자인패턴의 소개]

[디자인패턴의 의의]
프로그램 설계 시 반복적 문제를 객체 간 관계를 이용해 해결하도록 정의된 규약.
라이브러리·프레임워크 설계의 기초 원리로 사용됨.
패턴 학습을 통해 문제 해결력 및 팀 내 의사소통 효율 향상.

[디자인패턴의 종류]

생성패턴: 객체 생성 규약
ex) 싱글톤, 팩토리, 추상팩토리, 빌더, 프로토타입
구조패턴: 클래스·객체 구조 설계 규약
ex) 프록시, 어댑터, 브리지, 복합체, 데코레이터, 퍼사드, 플라이웨이트
행동패턴: 객체 간 알고리즘·책임 할당 규약
ex) 이터레이터, 옵저버, 전략, 책임연쇄, 커맨드, 중재자, 메멘토, 상태, 템플릿메서드, 비지터
(추가 예: Flux, MVC, MVVM 등)

[라이브러리와 프레임워크의 차이]

공통점: 재사용 가능한 기능을 모듈화한 구성 요소 집합
라이브러리: 폴더·파일 구조 규약 없음, 호출 주도권이 사용자에게 있음
예시 → axios: .get(), .then() 등 일정한 호출 규약 존재
프레임워크: 폴더·파일 구조 등 엄격한 규약 존재, 제어 흐름이 프레임워크 중심
예시 → Vue.js: 컴포넌트 기반 구조, 명확한 코드 작성 규약

[싱글톤패턴]

의의: 하나의 클래스가 단 하나의 인스턴스만 갖도록 하는 생성패턴 규약
활용: 인스턴스 생성 비용이 큰 객체(DB 연결 모듈 등)에 사용
장점: 인스턴스 생성 효율화, 자원 절약
단점:
- 전역 상태 → 결합도 증가
- 단위 테스트 어려움
- 멀티스레드 환경 동기화 복잡
- 객체 생명주기 관리 어려움
- OOP 원칙(캡슐화, DI) 위반 가능성

[JAVA에서의 싱글톤 구현 방식]

단순 메서드 호출
- 인스턴스 존재 여부 확인 후 생성
- 멀티스레드 환경에서 원자성 결여
synchronized 사용
- 메서드 단위 잠금으로 동시성 보장
- 호출 시마다 lock 발생 → 성능 저하
정적 멤버 (Eager Initialization)
- 클래스 로드 시 즉시 인스턴스 생성
- 호출 전에도 메모리 점유
정적 블록 초기화
- static 블록에서 인스턴스 초기화
- 즉시 초기화로 메모리 비효율 가능
정적 내부 클래스 (Lazy Holder)
- 내부 클래스 로딩 시 최초 생성
- thread-safe, lazy-loading 보장
- 외부 new 호출 방지를 위한 private 생성자 필요
이중 확인 잠금 (Double Checked Locking)
- 두 번의 null 검사로 동기화 최소화
- volatile로 메모리 일관성 보장
- 멀티스레드 환경 안전
enum 방식
- JVM이 인스턴스 생성·동기화 보장
- thread-safe, 직렬화 안전
- Joshua Bloch(Effective Java) 추천 방식

추천 구현 방식: 정적 내부 클래스(5번) 또는 enum 방식(7번)

[팩토리패턴]

의의: 상속 관계 클래스 간 객체 생성 책임을 하위 클래스에 위임하는 생성패턴 규약
특징:
- 상위 클래스 → 객체 생성 방식 모름
- 하위 클래스 → 구체적 생성 로직 관리
- 객체 생성 구조의 유연성 및 유지보수성 향상

[이터레이터패턴]

의의: 이터레이터(iterator)를 통해 컨테이너 요소에 순차 접근하는 행동패턴 규약
특징:
- 자료구조(배열, 맵 등)와 무관한 동일 인터페이스 제공
- 데이터 순회 로직 분리로 코드 일관성 확보
- 예시 → for...of (JavaScript)

[DI (Dependency Injection)와 DIP (Dependency Inversion Principle)]

DI 의의:
- 메인 모듈이 직접 하위 모듈을 생성하지 않고 외부 주입자를 통해 의존성 전달
- 의존성 결합 완화, 모듈 교체 용이 구조 확보
DI 코드 예시:
- Project 클래스가 BackendDeveloper, FrontEndDeveloper 객체를 생성자 주입으로 전달받음
- 생성자 주입은 DI 형태이지만, 구체 클래스에 직접 의존 → DIP 위반
DIP 의의:
- 상위 모듈과 하위 모듈 모두 추상화에 의존해야 함
- 세부 구현이 추상화에 따라 변경되어야 함
DIP 규칙:
1. 상위 모듈은 하위 모듈에 의존하지 않아야 함
2. 추상화는 세부사항에 의존하지 않아야 함
DI 장점: 모듈 교체 용이 (외부 주입 구조), 단위 테스트 및 마이그레이션 용이, 의존 방향 일관성 확보
DI 단점: 모듈 증가로 인한 복잡도 상승, 런타임 의존 주입 → 컴파일 시 오류 검출 어려움

[전략패턴]

의의: 캡슐화된 알고리즘(전략)을 컨텍스트 내에서 상호 교체 가능하게 하는 행동패턴 규약
특징:
- 실행 중 전략 교체 가능
- 알고리즘 독립성 및 유연성 확보

[옵저버패턴]

의의: 주체(subject)가 상태 변화를 감지해 옵저버(observer)들에게 통지하는 행동패턴 규약
특징:
- 주체-옵저버 간 느슨한 결합
- 이벤트 기반 구조 구현에 적합
- 예시 → 트위터 알림 로직, MVC 패턴

[프록시패턴]

의의: 객체 접근 전 중간 계층(proxy)을 두어 접근 제어, 로깅, 캐싱 등을 수행하는 구조패턴 규약
특징:
- 실제 객체 접근 전 필터링·제어 가능
- 대표 사례 → 프록시 서버(Cloudflare 등), 캐싱·보안 필터
- 코드 예시 → Proxy 객체로 변경 감지 및 콜백 실행

[MVC, MVP, MVVM 패턴]

[MVC 패턴]

의의: Model–View–Controller로 구성된 대표적 아키텍처 규약
구성요소:
- Model: 데이터 및 비즈니스 로직 관리 계층 (DB, 상수, 변수 등)
- View: 사용자 인터페이스(UI) 계층, 데이터 표시 담당
- Controller: Model과 View를 연결하며 이벤트 및 로직 처리 담당
특징:
- Controller가 Model↔View 간 데이터 흐름 제어
- 각 계층의 책임 분리로 재사용성·확장성 확보
장점:
1. 역할 분리로 병렬 개발 및 유지보수 용이
2. 재사용성과 확장성 우수
단점:
- 복잡한 애플리케이션에서는 Model–View 간 의존관계 복잡화
적용사례:
- Spring Web MVC (DispatcherServlet 중심 아키텍처)

[Spring MVC 적용 사례]

구조: DispatcherServlet(Front Controller)이 중심이 되어 요청–응답 흐름 제어
처리 과정:
1. 클라이언트 요청 → DispatcherServlet 수신
2. HandlerMapping 참고 후 적절한 Controller 선택
3. Controller가 비즈니스 로직 수행 및 Model 생성
4. ViewResolver가 뷰 위치 결정
5. View 렌더링 및 사용자 응답 반환
핵심 역할: DispatcherServlet이 요청 분배자이자 중앙 제어기 역할 수행

[MVP 패턴]

의의: MVC의 Controller를 Presenter로 교체한 구조
특징:
- View와 Presenter가 1:1 관계
- View가 Presenter를 직접 참조
- Controller보다 강한 결합 구조
장점:
- 뷰 로직 테스트 용이
- 프레젠테이션 로직 분리로 코드 가독성 향상
단점:
- View–Presenter 간 결합도 증가로 복잡도 상승

[MVVM 패턴]

의의: MVC의 Controller를 ViewModel로 대체한 패턴
구조:
- ViewModel은 View를 추상화한 계층
- ViewModel : View = 1 : N 관계
핵심 개념:
- Command: 여러 UI 동작을 하나의 액션으로 처리
- Data Binding: 화면(UI) 데이터와 메모리 데이터의 자동 동기화
특징:
- View와 ViewModel 간 양방향 데이터 바인딩
- UI와 비즈니스 로직 분리로 유지보수성 향상
대표 프레임워크: Vue.js
관계 비교:

구분 MVC MVP MVVM

관계 Controller–View: 1:N Presenter–View: 1:1 ViewModel–View: 1:N

View 참조 Controller X Presenter O ViewModel O

구분	MVC	MVP	MVVM
관계	Controller–View: 1:N	Presenter–View: 1:1	ViewModel–View: 1:N
View 참조	Controller X	Presenter O	ViewModel O

[Flux 패턴]

의의: 데이터의 흐름을 단방향(One-way)으로 유지하는 구조 패턴
등장 배경:
- MVC 구조의 양방향 데이터 흐름으로 인한 복잡성 및 일관성 문제 해결
구성요소:
- Action: 사용자 이벤트(입력·클릭 등) 발생 및 디스패처로 전달
- Dispatcher: Action의 유형(type)에 따라 로직 결정 및 Store로 전달
- Store: 애플리케이션의 상태(state) 저장 및 관리 계층
- View: Store 데이터를 기반으로 UI 렌더링
장점:
- 데이터 일관성 강화
- 버그 추적 및 단위 테스트 용이
대표 구현체: Redux
예시 코드:
- switch(action.type) 구문으로 Action 타입별 상태 갱신 로직 수행

[전략패턴 vs 의존성주입]

공통점:
교체 가능한 구조를 설계하기 위한 패턴 규약
차이점:
- 전략패턴:
  동일한 행동 계약(인터페이스)을 정의하고, 이를 기반으로 다양한 알고리즘 구현체를 교체 가능하게 하는 행동패턴 규약
  → “어떤 전략(행동)을 사용할지 결정하는 구조”
- 의존성주입(DI):
  객체 간 의존성을 외부에서 주입하여 결합도를 낮추는 설계 패턴이자 구조적 원칙
  → “어떤 객체를 사용할지 외부에서 주입하는 구조”

핵심 구분:

구분	전략패턴	의존성주입(DI)
목적	알고리즘 교체	의존성 관리
구성 요소	인터페이스 + 다형성	생성자/세터/인터페이스 주입
제어 흐름	런타임에 전략 변경	외부 컨테이너(Spring 등)가 제어
관계 성격	내부 객체 간 캡슐화 중심	외부 주입자 중심의 의존성 제어

[컨텍스트(Context)]

의의:
특정 상태나 환경을 캡슐화하거나, 중단된 작업을 재개할 수 있도록 저장하는 최소 데이터 집합을 의미하는 개념적 규약
두 가지 의미:
1. 상태·환경의 캡슐화 — 실행 중인 상황(환경)을 묶어 관리하는 개념
2. 작업 재개용 정보 저장 — 예: 컨텍스트 스위칭 시 프로세스의 레지스터 값, 스택 포인터 등을 저장
구분:
- Context: 환경 자체 (예: 병원 방문 상황)
- Contextual Information: 해당 환경에서 의미를 갖는 부가 정보 (예: 이름, 주민번호 등)
예시:
1. 병원 방문 context → “이름”은 contextual information
2. HTTP 요청 context → “HTTP Header”는 contextual information

[React의 Context API 예시]

의의:
전역적으로 상태(state)를 전달하기 위한 React 내장 상태 전파 API 규약

구조:

const ThemeContext = React.createContext('light');

class App extends React.Component {
  render() {
    return (
      <ThemeContext.Provider value="dark">
        <Toolbar />
      </ThemeContext.Provider>
    );
  }
}

function Toolbar() {
  return (
    <div>
      <ThemedButton />
    </div>
  );
}

class ThemedButton extends React.Component {
  static contextType = ThemeContext;
  render() {
    return <Button theme={this.context} />;
  }
}

[CS 지식의 정석] 1. 개발자 필수 지식

Hyun_! — Thu, 16 Oct 2025 12:59:50 +0900

[데이터교환형식 #1. JSON과 직렬화와 역직렬화]

JSON(JavaScript Object Notation): Javascript 객체 문법으로 구조화된 데이터 교환형식.
- 프로그래밍 언어와 플랫폼에 독립적 -> 서로 다른 시스템간에 데이터를 교환하기 좋음.
- 여러 언어에서 객체, 해시테이블, 딕셔너리 등으로 변환되어 쓰임. (ex. javascript에서는 javascript object, python에서는 dict)

- 주로 API 반환 형태, 시스템 구성 설정 파일에 활용

Javascript 객체 문법: 키(key)와 값(value)으로 구성.

- 이미 존재하는 키 중복 선언 시 나중에 선언한 해당 키에 대응한 값이 덮어씌워짐.

- 객체 문법 뿐 아니라 단순 배열, 문자열도 표현 가능 (ex. [1, 2, 3, 4] / "문자열")

- 배열은 대괄호 []를 기반으로 표현. 배열의 원소는 [0], [1] 와 같이 접근, 해당 key에 대한 value는 .key 또는 ["key"] 방식으로 접근

- JSON의 타입: 수(Number), 문자열(String), 참/거짓(Boolean), 배열(Array), 객체(Object), null

- javascript object와 유사. undefined, 메서드 등은 포함 불가.

JSON 직렬화, 역직렬화

- 직렬화 Serialization: 외부 시스템에서도 사용할 수 있도록 바이트(byte) 형태로 데이터를 변환하는 기술.

- JSON.stringify()로 JS Object에서 JSON 구조 문자열로 바꾸는 것이 직렬화.

- 역직렬화 Deserialization: 바이트->JSON.

- JSON.parse()로 JSON 에서 객체로 바꾸기 위해서 파싱하는 것이 역직렬화.

[데이터 포맷 #2. XML]

XML(Extensible Markup Language): 마크업 형태를 쓰는 데이터 교환형식.
- 마크업(markup): 태그 등을 이용하여 문서나 데이터의 구조를 나타냄. (속성 부여도 가능)

구성
1. 프롤로그 : 버전, 인코딩
2. 루트요소(단 1개)
3. 하위 요소들

<?xml version="1.0" encoding="UTF-8"?>
<OSTList>
<OST like="1">
      <name>마녀 배달부 키키</name> <song>따스함에 둘러쌓인다면</song>
  </OST>
  <OST like="2">
      <name>하울의 움직이는 성</name> <song>세계의 약속</song>
  </OST>
</OSTList>

HTML과 XML 비교

1. [용도] HTML 용도: 데이터를 표시 / XML 용도: 데이터 저장 및 전송
2. [태그] HTML은 태그가 미리 정해져 있음*. / XML은 태그가 정해져 있지 않음.
3. [대소문자] HTML은 대소문자 구분 X / XML은 대소문자 구분 O

*보충: html 자체적으로는 고유한 태그를 만들 수 없음. JS의 웹 컴포넌트(Web Components) API를 사용하면 커스텀 태그 작성 가능.

JSON과 XML 비교

- [용량] XML은 닫는 태그가 계속 들어가므로 JSON과 비교하면 무거움.
- [Javascript Object 변환 용이성] JSON은 JSON.parse()면 되어서 간단하지만, XML은 JSON보다는 많은 노력이 필요.

xml의 대표 용례는 sitemap.xml

sitemap.xml: 서비스 내 모든 페이지들을 리스트업한 데이터.

- 크롤러가 사이트 데이터 수집 시 일부 페이지를 누락할 수 있는 문제를 방지. (원인: 사이트가 매우 큼, 서로 링크가 종속적으로 연결되지 않음)

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
  <loc>http://www.example.com/foo.html</loc>
  <lastmod>2018-06-04</lastmod>
  </url>

<url>
<loc>http://www.example.com/abc.html</loc>
<lastmod>2018-06-04</lastmod>
</url>
</urlset>

API (Application Programming Interface): 두 시스템 간 통신 규약을 정의한 중계 계층.

- 서로 다른 소프트웨어 컴포넌트나 시스템 간에 데이터나 기능을 교환하기 위한 명세이자 인터페이스로, 한 프로그램이 다른 프로그램의 기능을 표준화된 방식으로 호출·이용할 수 있도록 정의한 중간 계층을 의미.

- 요청자(A 컴퓨터)와 응답자(B 컴퓨터) 간 데이터 교환 방식(HTTP, HTTPS, GET, POST 등)을 정의함.

- 과거에는 라이브러리·프레임워크 명세서를 포함했으나, 현재는 WEB API(REST API, WebSocket API 등)를 중심으로 사용됨.

인터페이스 (Interface): 서로 다른 두 개의 시스템, 장치 사이에서 정보나 신호를 주고받는 경우의 접점이나 경계면
- 특징: 내부 서버 구현과 무관하게 통신 가능, 직접 DB 접근 방지(보안·추상화 역할)

[API의 장점]

보안성 강화
- DB 구조, 테이블 정보, 상수값 등 내부 로직을 노출하지 않아도 됨.
- 필요한 데이터만 선택적으로 공개 가능.
유연한 서비스 구조
- 내부 DB나 서버 로직 변경 시에도 API 규격만 유지되면 클라이언트 업데이트 불필요.
- 예: DB 튜닝 시 앱 업데이트 불필요.
개발 효율성
- OPEN API를 통해 외부 서비스와 손쉽게 연동 가능. (ex. 네이버 로그인, 카카오 지도 API)
데이터 통합 관리
- 이벤트 발생 시 API 호출로 데이터를 중앙화 가능. (ex. yes24 베스트셀러 API → 사용자 클릭 이벤트 집계)

[API의 종류]

구분 접근 범위 특징 활용 예

구분	접근 범위	특징	활용 예
Private API	내부 전용	하드코딩된 해시 키 기반 통신, 서버 간 비공개 통신	파트너 간 전용 API(헤더 키 전달)
Public API	외부 공개	사용자 제한 설정(일일 호출 수 등)	네이버, 카카오 OPEN API

[API 실습 예시 – Open API 기반 온도 예측]

- Open-Meteo API를 통해 인공지능 모델 없이 실시간 날씨 예측 데이터 요청. 특징: API 버전 명시 (예: v1), 좌표 기반 데이터 요청

const OPEN_API = "https://api.open-meteo.com/v1/forecast?latitude=37.57&longitude=126.98&hourly=temperature_2m¤t_weather=true&timezone=Asia%2FTokyo";

[API 구축]
- 목표: 내부 로직이 변경되어도 API 명세를 변경하지 않고 호환성 유지

- Node.js: Google V8 엔진 기반 JavaScript 런타임 환경. 비동기 이벤트 주도형 구조. 자바스크립트로 서버·알고리즘·게임 등 실행 가능

- Express.js: Node.js 기반 웹 프레임워크. 라우팅, 미들웨어, 정적 자원 제공 기능 간결화

[라우팅 (Routing)]

URI(경로)와 HTTP 메서드(GET, POST 등)에 따라 클라이언트 요청에 응답하는 규약

예: /api/users → GET(조회), POST(등록), PUT(수정), DELETE(삭제)

[URI 분석 예시]
http://127.0.0.1:3000

프로토콜 : HTTP
IP : 127.0.0.1 (루프백IP)
port : 3000
app.listen(port, () => {
console.log(`http://127.0.0.1:${port}`)
port는 사실 숨겨져 있음
https port : 443이 기본포트
http port : 80이 기본포트

[예시 – 실제 사이트 URI]
http://www.naver.com → HTTP 기본 포트 80
브라우저 접근 시 프로토콜, IP, 포트는 자동 추상화됨

[클라우드 컴퓨팅 개요]

[클라우드의 기반 기술 – 가상머신(Virtual Machine)]

전통적 배포방식: 물리 컴퓨터 1대에 OS 1개 설치 → 여러 프로그램이 같은 자원을 공유
→ 한 앱의 변경이 다른 앱에 영향 가능

가상화 배포방식: 하드웨어 위에 하이퍼바이저(Hypervisor)를 두고 여러 OS를 독립적으로 실행
→ 한 컴퓨터에서 여러 VM 동시 구동 가능

특징: 하드웨어를 소프트웨어적으로 구현. 설정만으로 CPU·RAM 할당 변경 가능. 서로 완전히 격리된 환경 제공(샌드박스 구조)

단점: 각 VM에 OS를 별도 설치해야 함

[하이퍼바이저(Hypervisor)]

의의: 단일 시스템에서 여러 VM을 구동할 수 있게 하는 중간 계층
역할: 하드웨어 자원 분리·할당 및 VM 관리
예시: VMware, KVM, Hyper-V

[클라우드 배포 방식]

구분	정의	특징	예시
오프프레미스 (Off-Premise)	외부 클라우드 서비스 제공업체가 인프라 호스팅	인프라 설치 없이 저비용 운영, 확장 용이	AWS, Azure, NCP
온프레미스 (On-Premise)	기업이 자체 데이터센터(IDC) 직접 구축·운영	보안·통제력 우수, 초기비용 높음	네이버 춘천 데이터센터 (프리쿨링 방식 냉각)

[클라우드 서비스 모델]

IaaS (Infrastructure as a Service)
의의: 인프라(서버·스토리지·네트워크)만 제공
특징: OS·Runtime·DB를 사용자가 직접 설치, 특정 플랫폼에 종속되지 않음, 유연성 높음, 운영비 효율 낮음
예시: AWS EC2, Naver Cloud Platform(NCP)

PaaS (Platform as a Service)
의의: 개발 플랫폼 및 런타임 환경 제공
특징: Node.js, MongoDB 등 미리 설치, CI/CD 및 모니터링 제공, 운영 효율 높으나 플랫폼 종속성 존재
예시: Heroku, Google App Engine

SaaS (Software as a Service)
의의: 완성된 소프트웨어를 서비스 형태로 제공
특징: 별도 설치 없이 즉시 사용, 실시간 협업, 버전 관리 용이
예시: Google Docs, Notion, Slack

[IaaS vs PaaS 비교]

항목	IaaS	PaaS
유연성	높음	낮음
종속성	낮음	높음
이식성	높음	낮음
운영비	비효율적	효율적

[컨테이너(Container)와 도커(Docker)]

컨테이너: 애플리케이션 실행 환경을 OS 레벨에서 격리해 빠르고 안정적으로 배포하는 단위
특징: OS를 공유 → VM보다 경량·고속, 모든 의존성(라이브러리, 설정 등)을 함께 패키징, 완전한 격리성 제공, OS 문제 발생 시 다른 컨테이너 영향 가능

도커(Docker): 컨테이너 생성·관리·배포를 위한 플랫폼

특징: 동일 이미지에서 다수의 컨테이너 생성 가능, 이미지 불변성으로 재현성 확보
핵심 구성:

Dockerfile: 패키지·환경 변수 설정 기록 파일
Docker Image: 컨테이너 실행을 위한 불변 상태 스냅샷
Docker Container: 실행 중인 이미지 인스턴스

작동 과정: Dockerfile → Build → Image 생성 → Run → Container 실행

도커 활용 예시: 클라우드 컨테이너 배포(AWS ECS, Kubernetes 등) (구글 서비스 대부분이 도커 기반)

[CI/CD (지속적 통합·배포)]: 코드 작성 → 테스트 → 빌드 → 배포까지 자동화하는 파이프라인 구조 규약
(Continuous Integration / Continuous Delivery / Continuous Deployment)

필요성: 다수 개발자 협업 시 배포 충돌, 버전 불일치 방지, 테스트 자동화로 품질 유지

단계별 구성:

단계	설명
Continuous Integration (CI)	코드 빌드·테스트·병합 자동화
Continuous Delivery (CD)	릴리스 버전 자동 생성
Continuous Deployment	실제 서비스 환경(프로덕션) 자동 배포

장점: 코드 품질 유지, 테스트 자동화 강제, 배포 주기 단축, 장애 발생 시 롤백 용이

대표 툴:

CI/CD 플랫폼: GitHub Actions, Jenkins, CircleCI
통합형 플랫폼: Heroku(Git 연동 자동 배포 지원)

파이프라인 구성 요소:

Build (빌드)
- 코드 번들링 및 자원 패키징
- 예: webpack (모듈 번들러)
Test (테스트)
- 단위 테스트(Unit), 통합 테스트(Integration), 엔드투엔드(E2E) 테스트
- 대표 도구: Mocha, Jest
Merge (머지)
- Git 기반 코드 병합, 충돌 해결
- 작은 단위(issue 단위) 병합 권장
Deploy (배포)
- 서비스, 관리자페이지, 데이터 파이프라인 등 환경별 배포 포함
- GitHub Actions + Heroku 조합으로 자동화 가능

[요약]

클라우드: 가상화 기반의 분산 컴퓨팅 인프라. 도커: 컨테이너 단위 애플리케이션 배포 기술. CI/CD: 지속적 통합·자동 배포 파이프라인 규약.

[클래스, 객체, 인스턴스]
클래스(Class): 객체를 생성하기 위한 청사진 또는 설계 규약. 속성(필드)과 동작(메서드)의 집합 정의.
객체(Object): 클래스에서 생성된 실체. 클래스의 구조를 실제 메모리에 할당한 형태.
인스턴스(Instance): 객체가 메모리에 로드되어 실행 중인 상태. 런타임 시점에 존재하는 실체. ※ AWS 등에서는 ‘가상 서버 단위’를 의미하기도 함.

[static 키워드]
- 의의: 클래스의 인스턴스가 아닌 클래스 자체에 속하는 멤버를 정의하는 규약. 모든 객체가 공유하는 변수·메서드로 사용.
- 특징: 인스턴스화 없이 클래스명.메서드() 형태로 접근 가능, 클래스 내부에서 공통 기능·전역 자원 관리 시 유용, 명시적이며 가시성 높은 공유 자원 관리 가능.
- 단점: Heap이 아닌 Method Area에 미리 할당되어 GC(가비지 컬렉션) 미적용, 프로그램 종료 전까지 메모리 점유로 불필요한 낭비 위험, 객체지향 원칙(캡슐화·다형성) 약화.

[오버로딩(Overloading) vs 오버라이딩(Overriding)]

구분	오버로딩	오버라이딩
정의	동일한 메서드명으로 매개변수 타입·개수·순서를 다르게 정의	상위 클래스 메서드를 하위 클래스가 재정의
사용 위치	동일 클래스 내	상속 관계 클래스 간
목적	코드 유연성·가독성 향상	다형성 실현 및 행위 재정의
제약	없음	static, final 메서드는 불가
실행 시점	컴파일 시 결정	런타임 시 결정

[추상화(Abstraction)]
- 의의: 복잡한 구조나 데이터를 단순화하여 핵심만 표현하는 설계 원칙. 불필요한 세부 구현을 감추고 인터페이스로 표현.
- 유형: (1) 데이터 추상화 - 공통 속성을 묶고 세부 차이는 제거 (예: 고양이·강아지 → “동물”) (2) 프로세스 추상화 - 내부 절차를 감추고 인터페이스로 제공 (예: DB 내부 저장 과정은 숨기고 INSERT, UPDATE만 노출).
시스템 내 예시: MySQL 아키텍처는 내부 I/O 구조를 감춘 채 쿼리 단위 접근 제공. API, 모듈화 구조도 추상화의 구현 사례.

[컴파일러(Compiler)와 인터프리터(Interpreter)]
공통점: 고수준 언어를 기계어(Machine Code, 0·1)로 변환하는 변환기 규약.
컴파일러 방식: 전체 코드를 한 번에 기계어로 변환, 실행 전 변환으로 속도 빠름, 수정 시 재컴파일 필요. 사용 언어: C, C++, Go, Rust. 과정: 전처리 → 컴파일러 → 어셈블러 → 링커 → 실행파일 생성.
인터프리터 방식: 코드를 한 줄씩 읽고 즉시 실행, 시작은 빠르나 전체 속도는 느림, 실행 중 변환으로 수정 후 즉시 실행 가능. 사용 언어: Python, JavaScript. 장점: 실시간 실행 및 디버깅 용이. 단점: 반복 변환으로 인한 성능 저하.

[JIT 컴파일러 (Just-In-Time Compiler)]
의의: 컴파일러와 인터프리터의 장점을 결합한 동적(실시간) 컴파일 방식으로, 실행 중 자주 호출되는 코드를 선택적으로 기계어로 변환.
작동 원리: (1) 코드 분석 - 실행 중 “핫스팟(hot spot)” 탐지 (2) 동적 컴파일 - 자주 실행되는 코드만 변환 (3) 최적화 - 메모리 접근·GC 오버헤드 최소화 (4) 캐싱 - 변환된 코드 메모리 저장 및 재사용.
대표 구현: JVM, .NET CLR, V8 Engine(Node.js, Chrome).
장점: 반복 실행 코드의 성능 극대화, 인터프리터 대비 빠른 실행 속도. 단점: 캐시 저장으로 메모리 사용량 증가, 초기 실행 시 분석 오버헤드 발생.

[요약]
클래스는 객체의 설계도, static은 공용 자원 선언 규약, 오버로딩·오버라이딩은 다형성 구현 수단, 추상화는 복잡성 완화의 핵심 개념, 컴파일러·인터프리터·JIT은 언어 실행의 세 가지 접근 구조임.

[백준 골드2] 1655번: 가운데를 말해요 (우선순위 큐) - Java

Hyun_! — Wed, 15 Oct 2025 16:21:50 +0900

1655번: 가운데를 말해요

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

문제
백준이는 동생에게 "가운데를 말해요" 게임을 가르쳐주고 있다. 백준이가 정수를 하나씩 외칠때마다 동생은 지금까지 백준이가 말한 수 중에서 중간값을 말해야 한다. 만약, 그동안 백준이가 외친 수의 개수가 짝수개라면 중간에 있는 두 수 중에서 작은 수를 말해야 한다.
예를 들어 백준이가 동생에게 1, 5, 2, 10, -99, 7, 5를 순서대로 외쳤다고 하면, 동생은 1, 1, 2, 2, 2, 2, 5를 차례대로 말해야 한다. 백준이가 외치는 수가 주어졌을 때, 동생이 말해야 하는 수를 구하는 프로그램을 작성하시오.

입력
첫째 줄에는 백준이가 외치는 정수의 개수 N이 주어진다. N은 1보다 크거나 같고, 100,000보다 작거나 같은 자연수이다. 그 다음 N줄에 걸쳐서 백준이가 외치는 정수가 차례대로 주어진다. 정수는 -10,000보다 크거나 같고, 10,000보다 작거나 같다.

출력
한 줄에 하나씩 N줄에 걸쳐 백준이의 동생이 말해야 하는 수를 순서대로 출력한다.

예제 입력 1
7
1
5
2
10
-99
7
5
예제 출력 1
1
1
2
2
2
2
5

알고리즘: 자료 구조, 우선순위 큐

N의 범위가 최대 10만이다.

매번 데이터를 정렬하면 비효율적일 것이므로, 정렬된 자료구조인 힙을 이용하는 우선순위 큐 두 개를 사용해야겠다고 생각했다.

내림차순 우선순위 큐 smalls: 중앙값 이하의 값들을 저장

오름차순 우선순위 큐 bigs: 중앙값 초과의 값들을 저장 (*숫자 값이 아닌, 위치에 따른 초과를 위미)

smalls의 크기 >= bigs의 크기를 유지하며

중간의 원소를 bigs로 옮겨주는 방식으로 구현했다.

pq.peek()이 기억이 안 나서 첫 풀이는 다소 복잡하다.

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

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());
        PriorityQueue<Integer> smalls = new PriorityQueue<>(Collections.reverseOrder());
        PriorityQueue<Integer> bigs = new PriorityQueue<>();
        for(int i=0; i<n; i++){
            int input = Integer.parseInt(br.readLine());
            if(smalls.isEmpty()){
                smalls.add(input);
            } else if (smalls.size()<=bigs.size()){
                int s=smalls.poll();
                if(s>=input) {
                    smalls.add(input);
                    smalls.add(s);
                } else {
                    int b=bigs.poll();
                    if(b>=input){
                        smalls.add(input);
                        smalls.add(s);
                        bigs.add(b);
                    } else {
                        smalls.add(s);
                        smalls.add(b);
                        bigs.add(input);
                    }
                }
            } else {
                int s=smalls.poll();
                if(s>=input) {
                    smalls.add(input);
                    bigs.add(s);
                } else {
                    smalls.add(s);
                    bigs.add(input);
                }
            }
            int sTop = smalls.poll();
            System.out.println(sTop);
            smalls.add(sTop);
        }
    }
}

삽입 후 균형 조정 방식으로 개선한 풀이는 다음과 같다.

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

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());
        PriorityQueue<Integer> smalls = new PriorityQueue<>(Collections.reverseOrder());
        PriorityQueue<Integer> bigs = new PriorityQueue<>();
        for(int i=0; i<n; i++){
            int input = Integer.parseInt(br.readLine());
            // 삽입
            if (smalls.isEmpty() || input <= smalls.peek()) {
                smalls.offer(input);
            } else {
                bigs.offer(input);
            }
            // 균형 조정 
            if (smalls.size() > bigs.size()+1) {
                bigs.offer(smalls.poll());
            } else if (bigs.size() > smalls.size()) {
                smalls.offer(bigs.poll());
            }
            System.out.println(smalls.peek());
        }
    }
}

[Do it! 알고리즘 코딩테스트 - 자바 편] 05. 정렬

Hyun_! — Mon, 6 Oct 2025 21:12:15 +0900

정렬 알고리즘들과 정의

정렬 알고리즘	정의
버블	데이터끼리 인접 요소끼리 비교하고, swap 연산을 수행하며 졍렬하는 방식
선택	대상에서 가장 크거나 작은 데이터를 찾아 선택하는 과정을 반복하면서 정렬하는 방식
삽입	대상을 선택해 정렬된 영역에서 선택 데이터의 적절한 위치를 찾아 삽입하면서 정렬하는 방식
퀵	pivot 값을 선정해 해당 값을 기준으로 정렬하는 방식
병합(합병)	이미 정렬된 부분 집합들을 효율적으로 병합해 전체를 정렬하는 방식
힙	최대 힙 트리나 최소 힙 트리를 구성해 정렬을 하는 방식 (내림차순 정렬-최소 힙 / 오름차순 정렬-최대 힙)
기수	데이터의 자릿수를 바탕으로 비교해 데이터를 정렬하는 방식

05-1. 버블 정렬

버블 정렬: 두 인접한 데이터의 크기를 비교해 정렬. 시간 복잡도 O(n^2)으로 다른 알고리즘보다 속도가 느림.

루프를 돌면서 인접한 데이터 간에 swap 연산을 해 정렬.

만약 특정한 루프의 전체 영역에서 swap이 한 번도 발생하지 않았다면 데이터가 모두 정렬되었다는 뜻, 프로세스를 종료해도 된다.

[2750번: 수 정렬하기] / 브2

c++로 풀었었어서 생략

#include<iostream>
#include<algorithm>
using namespace std;

int main()
{
    int N;
    cin >> N;
    int* arr = new int[N];
    for (int i = 0; i < N; i++) {
        cin >> arr[i];
    }
    sort(arr, arr + N);
    for (int i = 0; i < N; i++) {
        cout << arr[i] << endl;
    }
    delete[] arr; // 메모리 해제
    return 0;
}

직접 구현한다면

for(int i=0; i<N-1; i++) {

for(int j=0; j<n-1-i; j++){

if(A[j]>A[j+1){

int temp=A[j];

A[j]=A[j+1];

A[j+1]=temp;

}

[1377번: 버블 소트] / 골2

문제에서 c++ 코드를 제공해주었길래 그대로 출력하도록 했는데, 시간초과가 나서 책 을 보고 다시 풀었다...

버블 정렬에서는 한 번의 루프마다 각 원소가 최대 한 칸씩만 왼쪽으로 이동할 수 있다. 따라서 원소가 처음 위치에서 얼마나 멀리 왼쪽으로 이동했는지를 보면, 실제 버블 정렬이 완료되기까지 필요한 최소 루프 횟수를 구할 수 있다.
실제 정렬 자체는 평균 시간 복잡도 O(n log n)인 Arrays.sort()로 빠르게 수행하고,

버블 정렬이 완료되는 최소 루프 횟수는 각 원소의 (정렬 전 인덱스 − 정렬 후 인덱스) 값 중 최댓값에 1을 더해 계산한다.

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

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[][] A = new int[n][2];
        for(int i=0; i<n; i++) {
            A[i][0] = i; // 정렬 전 인덱스
            A[i][1] = Integer.parseInt(br.readLine()); // 값
        }
        Arrays.sort(A, (a, b) -> {
            if(a[1]!=b[1]) return Integer.compare(a[1], b[1]); // 값 기준 정렬
            return Integer.compare(a[0], b[0]);
        });
        int max=0;
        for(int i=0; i<n; i++) {
            if (max < A[i][0]-i) 
                max = A[i][0]-i;
        }
        System.out.println(max+1);
    }
}

    // 문제에서 제공한 코드, 그러나 이렇게 실행하면 시간초과
    // bool changed = false;
    // for (int i=1; i<=N+1; i++) {
    //     changed = false;
    //     for (int j=1; j<=N-i; j++) {
    //         if (A[j] > A[j+1]) {
    //             changed = true;
    //             swap(A[j], A[j+1]);
    //         }
    //     }
    //     if (changed == false) {
    //         cout << i << '\n';
    //         break;
    //     }
    // }

05-2. 선택 정렬

선택 정렬: 대상 데이터에서 최대나 최소 데이터를 데이터가 나열된 순으로 찾아가며 선택하는 방법.

- 구현 방법이 복잡하고 시간 복잡도도 O(n^2)으로 효율적이지 않아 코딩 테스트에서는 많이 사용하지 않음.

선택 정렬의 핵심 이론: 최솟값 또는 최댓값을 찾고, 남은 정렬 부분의 가장 앞에 있는 데이터와 swap.

[1427번: 소트인사이드] / 실5

예전에 계수 정렬(Counting Sort)로 푼 적 있는 문제였다.

(입력 문자열(str)의 각 숫자 빈도를 numbers[10] 배열에 저장하고, 9부터 0까지 역순으로 출력하므로 내림차순 정렬)

import java.util.Scanner;

public class Main {
    public static void solution() throws Exception {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        int[] numbers = new int[10];

        for (int i = 0; i < str.length(); i++) {
            int n = str.charAt(i) - '0'; // 0~9
            numbers[n]++;
        }
        for (int i = 9; i >= 0; i--) {
            for (int j = 0; j < numbers[i]; j++) {
                System.out.print(i);
            }
        }
    }

    public static void main(String[] args) throws Exception {
        solution();
    }
}

선택 정렬로 푼다면

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        int n = str.length();
        int[] A = new int[n];

        for (int i = 0; i < n; i++) {
            A[i] = str.charAt(i) - '0';
        }

        // 선택 정렬 (내림차순)
        for (int i = 0; i < n - 1; i++) {
            int maxIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (A[j] > A[maxIdx]) {
                    maxIdx = j;
                }
            }
            // swap
            int tmp = A[i];
            A[i] = A[maxIdx];
            A[maxIdx] = tmp;
        }

        for (int num : A) {
            System.out.print(num);
        }
    }
}

05-3. 삽입 정렬

삽입 정렬: 이미 정렬된 데이터 범위에 정렬되지 않은 데이터를 적절한 위치에 삽입시켜 정렬하는 방식.

- 평균 시간 복잡도는 O(n^2)으로 느린 편,구현하기 쉬움.

삽입 정렬의 핵심 이론: 선택 데이터를 현재 정렬된 데이터 범위 내에서 적절한 위치에 삽입.

적절한 삽입 위치 탐색하는 데 이진 탐색을 사용하면 시간복잡도를 줄일 수 있다.

[11399번: ATM] / 실4

c++로, 정렬 후 누적합을 구하는 방식으로 풀었었다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int solution(int n, int times[]) {
    // 정렬
    sort(times, times + n);
    int sum = 0;
    int curr = 0;
    for (int i = 0; i < n; i++) {
        curr += times[i];
        sum += curr;
    }
    return sum;
}


int main()
{
    int n;
    int times[1000];
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> times[i];
    }
    cout << solution(n, times);
}

sort(times, times + n); 이 부분을 삽입 정렬 코드로 교체한다면 아래와 같이 된다.

// 삽입 정렬 (오름차순)
for (int i = 1; i < n; i++) {
    int key = times[i];
    int j = i - 1;
    while (j >= 0 && times[j] > key) {
        times[j + 1] = times[j];
        j--;
    }
    times[j + 1] = key;
}

05-4. 퀵 정렬

퀵 정렬: 기준값(pivot)을 선정해 해당 값보다 작은 데이터와 큰 데이터로 분류하는 것을 반복해 정렬하는 알고리즘.

- 기준값을 어떻게 선정하는지가 시간복잡도에 많은 영향을 미침. 평균적인 시간 복잡도는 O(nlogn).

퀵 정렬의 핵심 이론: pivot을 중심으로 계속 데이터를 2개의 집합으로 나누면서 정렬한다.

[11004번: K번째 수] / 실5

지난번에는 정렬을 직접 구현하지 않고 sort()를 사용했다.

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));
        String[] nk = br.readLine().split(" ");
        int n = Integer.parseInt(nk[0]);
        int k = Integer.parseInt(nk[1]);
        int[] arr = new int[n];
        String[] numbers = br.readLine().split(" ");
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(numbers[i]);
        }
        Arrays.sort(arr);
        System.out.println(arr[k-1]);
    }
}

퀵 정렬을 직접 구현한다면 다음과 같이 풀 수 있다. (문제집 코드)

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));
        String[] nk = br.readLine().split(" ");
        int n = Integer.parseInt(nk[0]);
        int k = Integer.parseInt(nk[1]);
        int[] arr = new int[n];
        String[] numbers = br.readLine().split(" ");
        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(numbers[i]);
        }
        Arrays.sort(arr);
        System.out.println(arr[k-1]);
    }
    
    public static void quickSort(int[] A, int S, int E, int K){
        if (S<E) {
            int pivot=partition(A, S, E);
            
            if (pivot==K) {
                return;
            } else if (K<pivot) {
                quickSort(A, S, pivot-1, K);
            } else {
                quickSort(A, pivot+1, E, K);
            }
        }
    }
    
    public static int partition(int[] A, int S, int E){
        if(S+1==E){
            if(A[S]>A[E]) swap(A, S, E);
            return E;
        }
        int M = (S+E)/2;
        swap(A, S, M);
        int pivot=A[S];
        int i=S+1;
        int j=E;
        while (i<=j) {
            while (j>=S+1 && pivot<A[j]) {
                j--;
            }
            while (i<=E && pivot>A[i]) {
                i++;
            }
            if (i<=j) {
                swap(A, i++, j--);
            }
        }
        A[S]=A[j];
        A[j]=pivot;
        return j;
    }
    
    public static void swap(int[] A, int i, int j){
        int temp=A[i];
        A[i]=A[j];
        A[j]=temp;
    }
}

05-5. 병합 정렬

병합 정렬: 분할 정복(divide and conquer) 방식을 사용해 (1) 데이터를 분할하고 (2) 분할한 집합을 정렬하며 합치는 알고리즘.

- 시간복잡도 평균값 O(nlogn).

병합 정렬의 핵심 이론: (1) 가장 작은 데이터 집합으로 분할 (2) 2개씩 그룹을 합치면서 오름차순 정렬 반복

2개의 그룹을 병합하는 과정: 투 포인터 개념을 사용해 왼쪽, 오른쪽 그룹을 병합한다.

- 왼쪽 포인터와 오른쪽 포인터의 값을 비교하여, 작은 값을 결과 배열에 추가하고 포인터를 오른쪽으로 1칸 이동시킨다.

[2751번: 수 정렬하기 2] / 실5

예전에는 그냥 sort()로 했었는데 병합 정렬을 구현하면 다음과 같이 할 수 있다. (문제집 코드)

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Main {
  public static int[] A, tmp;
  public static long result;
  
  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 N = Integer.parseInt(br.readLine());
    A = new int[N + 1];
    tmp = new int[N + 1];
    for (int i = 1; i <= N; i++) {
      A[i] = Integer.parseInt(br.readLine());
    }
    mergeSort(1, N); // 병합정렬 수행하기
    for (int i = 1; i <= N; i++) {
      bw.write(A[i] + "\n");
    }
    bw.flush();
    bw.close();
  }

  private static void mergeSort(int s, int e) {
    if (e - s < 1)
      return;
    int m = s + (e - s) / 2;
    // 재귀함수 형태로 구현
    mergeSort(s, m);
    mergeSort(m + 1, e);
    for (int i = s; i <= e; i++) {
      tmp[i] = A[i];
    }
    int k = s;
    int index1 = s;
    int index2 = m + 1;
    while (index1 <= m && index2 <= e) { // 두 그룹을 Merge 해주는 로직
      if (tmp[index1] > tmp[index2]) {
        A[k] = tmp[index2];
        k++;
        index2++;
      } else {
        A[k] = tmp[index1];
        k++;
        index1++;
      }
    }
    // 한쪽 그룹이 모두 선택된 후 남아있는 값 정리하기
    while (index1 <= m) {
      A[k] = tmp[index1];
      k++;
      index1++;
    }
    while (index2 <= e) {
      A[k] = tmp[index2];
      k++;
      index2++;
    }
  }
}

[1517번: 버블 소트] / 플5

N개의 수로 이루어진 수열 A[1], A[2], …, A[N]이 있다. 이 수열에 대해서 버블 소트를 수행할 때, Swap이 총 몇 번 발생하는지 알아내는 프로그램을 작성하시오.
버블 소트는 서로 인접해 있는 두 수를 바꿔가며 정렬하는 방법이다. 예를 들어 수열이 3 2 1 이었다고 하자. 이 경우에는 인접해 있는 3, 2가 바뀌어야 하므로 2 3 1 이 된다. 다음으로는 3, 1이 바뀌어야 하므로 2 1 3 이 된다. 다음에는 2, 1이 바뀌어야 하므로 1 2 3 이 된다. 그러면 더 이상 바꿔야 할 경우가 없으므로 정렬이 완료된다.

아까 문제와 마찬가지로, 제목이 버블 정렬이지만 버블 정렬로 풀면 시간 초과가 나는 문제. (N 최대 범위 500,000 -> O(nlogn) 필요)

병합 정렬을 이용해야 한다. 두 그룹을 병합하는 과정에 버블 정렬의 swap이 쓰인다.

마지막 병합 전의 데이터 [ 24 32 42 60 ] [ 5 15 45 90 ] 를 생각하자.

최종 정렬된 데이터는 [ 5 15 24 32 42 45 60 90 ].

5는 앞 그룹의 4개 데이터를 제치므로 버블 정렬에서 swap을 4번 하는 것과 동일하다.

45는 앞 그룹의 1개 데이터를 제치므로 버블 정렬에서 swap을 1번 하는 것과 동일하다.

병합 정렬을 동일하게 진행하는데, 정렬 과정에서 index가 이동한 거리를 result에 저장하자.

각 그룹을 정렬하는 과정에서 원소가 앞으로 이동한 거리만큼 result에 더하기.

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

public class Main {
    static int[] A, tmp;
    static long result;
  
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        A = new int[n+1];
        tmp = new int[n+1];
        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i=1; i<=n; i++) {
            A[i] = Integer.parseInt(st.nextToken());
        }
        result = 0;
        mergeSort(1, n);
        System.out.println(result);
    }
    
    private static void mergeSort(int s, int e) { 
        if (e-s < 1)
            return;
        int m = s + (e-s)/2;
        //재귀함수 (왼쪽, 오른쪽)
        mergeSort(s, m); 
        mergeSort(m+1, e);
        
        for (int i=s; i<=e; i++) {
            tmp[i] = A[i];
        }
        int k = s; // 병합 결과를 A에 저장하기위한 위치 인덱스
        int index1 = s; // 왼쪽 그룹의 현재 원소 위치
        int index2 = m + 1; // 오른쪽 그룹의 현재 원소 위치
        // 병합 로직 (작은 값을 A[k]에 넣으며 병합)
        while (index1 <= m && index2 <= e) {
            if (tmp[index1] > tmp[index2]) { // 뒤쪽 데이터 값이 작다면 역전 발생
                A[k] = tmp[index2];
                result += (index2 - k); // 오른쪽 원소가 왼쪽 원소 몇 개를 앞질렀는지
                k++;
                index2++;
            } else {
                A[k] = tmp[index1];
                k++;
                index1++;
            }
        }
        // 두 부분 중 한 쪽이 먼저 소진되었을 때, 남은 원소 병합
        while (index1 <= m) {
            A[k] = tmp[index1];
            k++;
            index1++;
        }
        while (index2 <= e) {
            A[k] = tmp[index2];
            k++;
            index2++;
        }
    }
}

05-6. 기수 정렬

기수 정렬: 값을 비교하지 않는 정렬. 값을 놓고 비교할 자릿수를 정한 다음 해당 자릿수만 비교.

- 시간복잡도: O(kn). // k: 자릿수. 시간복잡도가 가장 짧은 정렬임.

기수 정렬의 핵심 이론: 10개의 큐를 이용. 각 큐는 값의 자릿수를 대표함.

기수 정렬 수행 방식

원본 배열: 16 80 18 77 03 24 88 23

(1) 일의 자릿수 기준으로 배열 원소를 큐에 집어넣는다. 그런 다음 0번째 큐부터 9번째 큐까지 pop을 진행한다.

-> 결과: 90 03 23 24 16 77 18 88

(2) 이어서 십의 자릿수를 기준으로 같은 과정을 진행한다.

(3) 마지막 자릿수를 기준으로 정렬할 때까지 앞의 과정을 반복.

일반적인 기수 정렬은 우선순위 큐를 사용해 비교적 간단하게 구하는 방법이 있지만, 시간 복잡도를 느리게 하는 요소가 있어 구간 합을 이용하는 것이 더욱 효율적이다.

[10989번: 수 정렬하기 3] / 브1

이전에는 계수 정렬로 풀었었다.

기수 정렬로는 다음과 같이 풀이할 수 있다.

import java.io.*;

public class Main {
    static int[] A;
    static long result;
    
    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 N = Integer.parseInt(br.readLine());
        A = new int[N];
        for (int i = 0; i < N; i++) {
            A[i] = Integer.parseInt(br.readLine());
        }
        br.close();
        radixSort(A, 5); //수의 범위가 <=10000
        for (int i = 0; i < N; i++) {
            bw.write(A[i] + "\n");
        }
        bw.flush();
        bw.close();
    }

    private static void radixSort(int[] A, int maxSize) {
        int[] output = new int[A.length];
        int digit = 1;
        int count = 0;
        while (count != maxSize) { // 최대 자리수 만큼 반복
            int[] bucket = new int[10];
            for (int i = 0; i < A.length; i++) {
                bucket[(A[i] / digit) % 10]++; // 일의 자리 부터 시작
            }
            for (int i = 1; i < 10; i++) { // 합배열을 이용하여 index 계산
                bucket[i] += bucket[i - 1];
            }
            for (int i = A.length - 1; i >= 0; i--) { // 현재 자리수 기준으로 정렬
                output[bucket[(A[i] / digit % 10)] - 1] = A[i];
                bucket[(A[i] / digit) % 10]--;
            }
            for (int i = 0; i < A.length; i++) {
                A[i] = output[i]; // 다음 자리 수 이동을 위해 현재 자리수 기준 정렬 데이터 저장
            }
            digit *= 10; // 자리수 증가
            count++;
        }
    }
}

bucket 배열로 현재 자리를 기준으로 정렬하는 방식 잘 확인하기.