로깡이

[BOJ C++] 백준 14502번: 연구소

audxkawjd17 — Fri, 27 Mar 2026 16:55:46 +0900

문제

[BOJ C++] 백준 14502번: 연구소
https://www.acmicpc.net/problem/14502

입력 및 출력

문제 풀이

조합(Backtracking)으로 벽을 세울 위치 3개를 선택하고, BFS(너비 우선 탐색)로 바이러스를 확산시키는 시뮬레이션을 결합하여 해결했다.

자세한 구현 방법은 다음과 같다.

초기 위치 저장: 입력을 받으면서 빈칸(0)의 위치는 blank 벡터에, 바이러스(2)의 위치는 virusPos 큐에 별도로 저장한다. 빈칸은 나중에 벽을 세울 조합을 뽑기 위함이고, 바이러스는 BFS를 시작할 시작점들이기 때문이다.
벽 세우기 (조합): blank 벡터에 저장된 좌표들 중 3개를 선택한다. 재귀 함수를 이용한 백트래킹 방식으로 구현하였으며, 벽을 세운 뒤(1) 재귀 호출이 끝나면 다시 없애는(0) 과정을 반복한다.
바이러스 확산 (BFS): 벽이 3개 세워질 때마다 virus 함수를 호출한다. 초기 바이러스 위치들이 담긴 큐를 복사하여 상하좌우로 퍼뜨리며 빈칸의 개수를 줄여나간다.
최댓값 갱신: 바이러스 확산이 끝난 후 남은 빈칸의 개수(blankCnt)를 계산하여 maxVal을 최댓값으로 갱신한다.

알고리즘 개선 및 최적화

두 가지 방법으로 성능을 높였다.

1. 가지치기 (Pruning)

시뮬레이션을 모두 구현한 후에 스스로 생각한 방법이다. 바이러스가 한 칸씩 퍼질 때마다 빈칸의 개수(blankCnt)를 1씩 줄여나가는데, 만약 남아 있는 빈칸의 수가 지금까지 구한 안전 구역의 최대 넓이(maxVal)보다 작거나 같아지면 나머지 빈칸이 모두 안전 구역이 되어도 최댓값이 될 수 없다. 즉, 더 이상 계산할 필요가 없으므로 즉시 함수를 종료(return)한다. 무의미한 값이므로 0을 리턴하였다.

2. 값에 의한 전달 vs 참조에 의한 전달

처음에는 combi 함수를 작성할 때 매개변수로 vector<vector<int>> board를 그대로 넘겨주는 값에 의한 전달(Call by Value) 방식을 사용했다. 이 부분을 개선할 방법이 있을 것 같아 AI에게 코드 리뷰를 맡겨본 결과, 이 방법은 재귀가 호출될 때마다 2차원 벡터가 통째로 복사되어 오버헤드 발생 위험이 있다는 것을 알 수 있었다. virus 함수에서만 바이러스가 퍼지는 시뮬레이션을 구현하면 되므로, combi 함수에서는 새로운 보드를 생성할 필요가 없다. 따라서 combi 함수에는 참조(&)를 전달하여 불필요한 복사를 방지하고, 실제 바이러스 전파 시뮬레이션이 일어나는 virus 함수 내부에서만 임시 보드를 복사하여 사용하는 방식으로 수정하였다.

⌨️ C++ 코드

/*
1. 입력 받으면서 빈칸, 바이러스 위치 별도로 저장.
	바이러스: 확산해야하므로 큐에 저장.
	빈칸: 조합으로 선택해야하므로 벡터에 저장.

2. 조합으로 3칸 선택, 벽 세우기
3. 바이러스 퍼지는 시뮬레이션 수행
4. 안전 영역 크기 계산

위 2~4단계 반복.
*/

#include<bits/stdc++.h>
using namespace std;

struct Cell {
	int r, c;
	Cell(int r, int c) : r(r), c(c) {}
};

void combi(vector<vector<int>>&, int, int);
int virus(vector<vector<int>>&);

vector<Cell> blank; // 빈칸 위치 저장.
queue<Cell> virusPos; // 바이러스 위치 저장.

int dr[] = { -1, 1, 0, 0 }, dc[] = { 0, 0, -1, 1 }, n, m, maxVal = 0;

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

	cin >> n >> m;
	vector<vector<int>> board(n, vector<int>(m));

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			cin >> board[i][j];
			if (board[i][j] == 0)
				blank.emplace_back(i, j);
			else if (board[i][j] == 2)
				virusPos.emplace(i, j);
		}
	}
	combi(board, 0, 0);
	cout << maxVal;
}

// 수정: combi 함수에서는 board를 사용하지 않음. (virus 함수로 전달하기 용.)
// -> 값으로 전달하는 대신 참조(&)를 전달하고, virus 함수 내에서 board를 복사하여 사용.
void combi(vector<vector<int>> &board, int start, int cnt) {
	if (cnt == 3) {
		maxVal = max(maxVal, virus(board));
		return;
	}

	for (int i = start; i < blank.size(); i++) {
		board[blank[i].r][blank[i].c] = 1;
		combi(board, i + 1, cnt + 1);
		board[blank[i].r][blank[i].c] = 0; // 되돌리기.
	}
}

int virus(vector<vector<int>> &originBoard) {
	vector<vector<int>> board = originBoard; // 넘겨 받은 원본 board를 복사하여 사용.
	queue<Cell> q = virusPos;
	int blankCnt = blank.size() - 3;

	while (!q.empty()) { // 바이러스 확산.
		Cell cur = q.front();
		q.pop();
		for (int i = 0; i < 4; i++) {
			int nr = cur.r + dr[i], nc = cur.c + dc[i];
			if (nr < 0 || nr >= n || nc < 0 || nc >= m) continue;
			if (board[nr][nc] != 0) continue;
			board[nr][nc] = 2;
			blankCnt--;

			// 빈칸의 수가 지금까지 구한 최대 안전 영역크기보다 작으면 가지치기.
			if (blankCnt <= maxVal) return 0;

			q.emplace(nr, nc);
		}
	}
	return blankCnt;
}

[BOJ Java] 백준 4179번: 불!

audxkawjd17 — Sat, 7 Mar 2026 21:00:30 +0900

문제

[BOJ Java] 백준 4179번: 불!
https://www.acmicpc.net/problem/4179

입력 및 출력

문제 풀이

Node에 좌표, 시간, 상태(불인지 지훈이인지 관리)를 함께 담아 관리한다.
큐에 불(F)의 위치를 먼저 넣고, 마지막에 지훈이의 위치(J)를 넣는다. (불길이 먼저 번지고 지훈이가 불을 피해 이동해야하기 때문.)
불이 번진 곳이나 지훈이가 지나간 곳은 visited 배열에 방문 표시한다.
지훈이의 다음 좌표가 미로의 범위를 벗어난다면 탈출한 것 !
큐에 더 이상 지훈이가 이동할 위치가 없다면 탈출 불가. IMPOSSIBLE 출력.
처음에는 불의 위치를 저장하는 큐와 지훈이의 위치를 저장하는 큐를 따로 관리하려고 생각했는데, 시간별로 처리하기 어려워 하나의 큐에 넣어 관리하는 방식으로 변경하였다.

⌨️ Java 코드

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

class Node {
	int x, y, time;
	char state;

	Node(int x, int y, int time, char state) {
		this.x = x;
		this.y = y;
		this.time = time;
		this.state = state;
	}
}

public class Main {
	static BufferedReader br;
	static StringTokenizer st;
	static int dr[] = { -1, 1, 0, 0 }, dc[] = { 0, 0, -1, 1 };

	public static void main(String[] args) throws Exception {
		br = new BufferedReader(new InputStreamReader(System.in));
		st = new StringTokenizer(br.readLine());
		int r = Integer.parseInt(st.nextToken()), c = Integer.parseInt(st.nextToken()), startR = 0, startC = 0;
		char map[][] = new char[r][];
		boolean visited[][] = new boolean[r][c];
		Queue<Node> q = new ArrayDeque<>(); // 불 먼저, 이동 다음. 한 번에 저장.
		for (int i = 0; i < r; i++) { // input
			map[i] = br.readLine().toCharArray();
			for (int j = 0; j < c; j++) {
				if (map[i][j] == 'J') {
					map[i][j] = '.';
					startR = i;
					startC = j;
				}
				if (map[i][j] == 'F') {
					q.add(new Node(i, j, 0, map[i][j]));
					visited[i][j] = true;
				}
			}
		} // end of input
		q.add(new Node(startR, startC, 0, 'J'));

		int move = 1; // 이동할 수 있는 경우의 수 관리. 0이되면 더 이상 이동할 수 없으므로 종료.
		while (!q.isEmpty()) {
			int curR = q.peek().x, curC = q.peek().y, t = q.peek().time;
			char state = q.poll().state;
			if (state == 'J')
				move--;
			for (int i = 0; i < 4; i++) {
				int nr = curR + dr[i], nc = curC + dc[i];
				if (nr < 0 || nr >= r || nc < 0 || nc >= c) {
					if (state == 'J') { // 탈출 성공 !
						System.out.println(t + 1);
						return;
					}
					continue;
				}
				if (map[nr][nc] == '.' && !visited[nr][nc]) {
					visited[nr][nc] = true; // 방문 여부 체크.
					q.add(new Node(nr, nc, t + 1, state)); // 다음 이동 저장.
					map[nr][nc] = state; // 이전 위치와 같은 상태로 전파.
					if (state == 'J')
						move++;
				}
			}
			if (move == 0) // 더 이상 이동할 곳이 없음.
				break;
		}
		System.out.println("IMPOSSIBLE");
	}
}

[이론_Java 기초] Map? Set?

audxkawjd17 — Sat, 7 Feb 2026 18:59:59 +0900

Map? Set?

Map은 Key(키)-Value(값)을 하나의 쌍으로 묶어 저장하는 자료구조를 말한다. 데이터를 찾을 때 Key를 이용하며, Key는 중복될 수 없다. 구현 클래스는 HashMap, TreeMap, LinkedHashMap이 있다.

Set은 수학의 집합 개념이며, 데이터의 중복을 허용하지 않는다는 것이 가장 큰 특징이다.

구현 클래스는 HashSet, TreeSet, LinkedHashSet이 있다.

HashMap? HashSet?

Map과 Set을 구현할 때는 보통 HashMap과 HashSet을 사용한다. 이 둘은 해싱을 기반으로 하여 빠른 속도를 자랑한다.

HashMap은 데이터를 키-값 쌍으로 저장한다. 순서를 보장하지 않지만, 데이터를 넣거나 찾을 때 시간 복잡도 O(1)로 압도적으로 빠르다.

HashSet은 내부적으로 HashMap을 사용하기 때문에 유사한 특징을 가지고 있다. 키-값 쌍에서 값 부분을 비워둔 형태이다. HashMap가 마찬가지로 중복된 데이터를 빠르게 확인하고 제거할 때 효율적이다.

이 두 클래스가 데이터를 관리하는 방식은 해시 기법을 사용한다. 데이터를 넣으면 객체의 hashCode() 메서드를 호출해 해시코드를 얻고, 이를 이용해 데이터를 담을 공간을 결정한다. 이때, 만약 해당 위치에 이미 데이터가 있어 해시 충돌이 발생한다면, equals() 메서드로 같은 객체인지 확인하는 과정을 거친다. 이처럼 해시를 활용하여 데이터를 관리하기 때문에 하나하나 순회하며 데이터 저장 위치를 찾을 필요가 없어 속도가 훨씬 빨라지는 것이다.

TreeMap? TreeSet?

TreeMap과 TreeSet은 앞선 HashMap과 HashSet과 달리 데이터의 순서를 관리할 수 있다. 내부적으로 레드-블랙 트리를 기반으로 작동하기 때문에 데이터를 저장할 때 요소들을 자동 정렬된 상태로 관리해 준다. (Map은 키를 기준으로) 또, 데이터를 삽입, 삭제할 때 $O(log n)$의 시간 복잡도를 가지며, 키에 null값을 허용하지 않는다. (null 값은 크기를 비교할 수 없기 때문)

두 클래스의 정렬 방식은 자연적인 순서(Natural Ordering. 숫자는 오름차순, 문자는 사전순)를 따르며, 별도의 Comparator로 정렬 로직을 바꾸는 것도 가능하다 Integer, String 등은 기본적으로 Comparable이 구현되어 있기 때문에 바로 사용할 수 있지만, 커스텀 객체의 경우 반드시 Comparable 인터페이스를 구현하거나 Comparator를 넘겨줘야 한다.

예를 들어 Student 객체를 학번(id) 기준으로 정렬한다면 Comparable 인터페이스를 다음과 같이 구현할 수 있다.

class Student implements Comparable<Student> {
    int id;
    String name;

    public Student(int id, String name) { // 생성자.
        this.id = id;
        this.name = name;
    }

    @Override
    public int compareTo(Student other) {
        // 현재 객체(this)가 인자로 들어온 객체(other)보다 작으면 음수, 같으면 0, 크면 양수 반환.
        // 양수인 경우 자리 바꿈.
        return Integer.compare(this.id, other.id); 
    }
}

// 사용법
TreeSet<Student> set = new TreeSet<>();
set.add(new Student(2021001, "김철수"));
set.add(new Student(2020005, "이영희")); // 학번순으로 자동 정렬되어 저장.

혹은 다음과 같이 Comparator를 구현할 수도 있다.

TreeMap<Student, String> map = new TreeMap<>( (s1, s2) -> {
	if(s1.score == s2.score) // 점수가 같으면 이름순으로 정렬.
    		return s1.name.compareTo(s2.name);
	return Integer.compare(s2.score, s1.score); // 점수를 내림차순으로 정렬.
});

TreeMap, TreeSet은 데이터를 자동 정렬해주기 때문에 특정 값을 찾는 탐색 기능에서 유용하게 사용할 수 있다. 그러나 단순히 데이터를 저장할 때는 HashMap, HashSet을 사용하는 것이 $O(1)$로 훨씬 빠르다.

요약

구분	HashMap / HashSet	TreeMap / TreeSet	LinkedHashMap / LinkedHashSet
핵심 기법	해싱	레드-블랙 트리	해싱 + 연결 리스트
시간 복잡도	$O(n)$	$O(log n)$	$O(1)$
정렬 여부	x (무작위)	o (정렬 기준에 따름)	o (삽입 순서 보장)
null	Key 하나만 허용	허용 x	Key 하나만 허용

✍ 관련 문제

❓ 문제

백준 1181번: 단어 정렬 https://www.acmicpc.net/problem/1181

백준 20291번: 파일 정리 https://www.acmicpc.net/problem/20291

백준 7662번: 이중 우선순위 큐 https://www.acmicpc.net/problem/7662

백준 21939번: 문제 추천 시스템 Version 1 https://www.acmicpc.net/problem/21939

문제풀이

(제작중.....)

[이론] 스위핑 알고리즘

audxkawjd17 — Wed, 4 Feb 2026 14:14:07 +0900

스위핑 알고리즘이란?

: '빗자루로 쓸기' 기법. 특정 방향으로 가상의 선을 옮겨가며 마주치는 사건을 순서대로 처리하는 방식.

스위핑 알고리즘을 사용하는 가장 큰 이유는 효율성이다. 2차원 평면의 문제를 1차원적인 순서 문제로 변환하기 때문에 전체 데이터를 다 확인해보지 않아도 정답을 찾아낼 수 있기 때문이다.

보통 정렬에 $O(N log N)$이 걸리고, 각 사건을 처리할 때 트리 구조 등을 사용하면 $O(N log N)$이 걸리므로 전체 시간 복잡도를 확 낮출 수 있다.

️ 동작 원리

1. 정렬 (Sorting): 모든 요소를 처리할 방향에 맞춰 정렬한다. ex) x 좌표 순, y 좌표 순 ...

2. 처리 (Processing): 정렬된 순서대로 요소를 확인하며 현재 위치에서의 상태를 업데이트하고 정답을 구한다.

스위핑 알고리즘은 주로 기하 문제에서 사용되는 편이다.

선분 교차: 평면 위 선분 중 교차하는 쌍 찾기.
사각형의 합집합 넓이: 여러 개의 직사각형이 겹쳐 있을 때 전체 면적 구하기.
가장 가까운 두 점 찾기: 평면 위 수많은 점 중 거리가 가장 짧은 두 점 찾기.
일정 관리: 회의실 배정이나 겹치는 시간대 최대 인원 구하기.

예시: 선분 교차

여러 선분의 교차점을 찾는 문제를 예로 들어보자. 모든 선분 쌍을 하나하나 비교하면 $O(N^2)$만큼의 시간 복잡도가 필요하다. 대신 스위핑을 사용하면 시간 복잡도를 $O(N log N)$까지 줄일 수 있다.

가상의 수직선을 왼쪽에서 오른쪽으로 이동시킨다.
선분의 왼쪽 끝점을 만나면 현재 선분 목록에 추가한다.
선분의 오른쪽 끝점을 만나면 목록에서 삭제한다.

스위핑 방식을 사용하면, 선분을 목록에 삽입하거나 삭제할 때 인접한 선분과의 교차 여부만 확인하면 된다.

✍ 관련 문제

❓ 문제

백준 2170번: 선 긋기 https://www.acmicpc.net/problem/2170

백준 1911번: 흙길 보수하기 https://www.acmicpc.net/problem/1911

백준 11000번: 강의실 배정 https://www.acmicpc.net/problem/11000

문제풀이

[BOJ Java] 백준 2170번: 선 긋기

audxkawjd17 — Wed, 4 Feb 2026 14:12:04 +0900

문제

[BOJ Java] 백준 2170번: 선 긋기
https://www.acmicpc.net/problem/2170

입력 및 출력

문제 풀이

선분의 양 끝 점을 입력받고, 시작점($x$)을 기준으로 오름차순 정렬한다. 만약 시작점($x$)이 같다면 끝점($y$)을 기준으로 정렬한다.

list.sort((list1, list2) -> { // x 순으로 정렬.
	if (list1[0] == list2[0])
		return list1[1] - list2[1];
	return list1[0] - list2[0];
});

정렬은 위 코드와 같이 람다식으로 구현했다. 시작점이 같으면 끝점을 기준으로 정렬하는 것이다.

첫 번째 선분의 양 끝을 변수로 저장해 두고, 입력된 선분들을 순회하며 범위를 확장한다. 다음 선분이 이전 선분 중간에서 시작하면 범위가 겹치므로 끝점이 뒤로 더 밀려난다. 즉, 새로운 선분의 시작점($i[0]$)이 이전 선분의 양 끝(left, right) 사이에 있으면 right를 새로운 끝점($i[1]$)과 기존 점(right) 중 더 큰 값으로 갱신한다.
만약 새로운 선분의 시작점이 기존 범위 내부에 없다면 선분이 끊기는 것이므로 현재까지의 선분 길이를 저장해 두고 양 끝 범위를 수정한다.

⌨️ Java 코드

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));
		StringTokenizer st;
		int n = Integer.parseInt(br.readLine());
		List<int[]> list = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			st = new StringTokenizer(br.readLine());
			int x = Integer.parseInt(st.nextToken()), y = Integer.parseInt(st.nextToken());
			list.add(new int[] { x, y });
		}
		list.sort((list1, list2) -> { // x 순으로 정렬.
			if (list1[0] == list2[0])
				return list1[1] - list2[1];
			return list1[0] - list2[0];
		});
		int left = list.get(0)[0], right = list.get(0)[1], rst = 0;
		for (int[] i : list) {
			if (left <= i[0] && i[0] <= right) // 오른쪽으로 확장.
				right = Math.max(right, i[1]);
			else if (right <= i[0]) { // 끊기면 길이 저장하고 범위 이동.
				rst += right - left;
				left = i[0];
				right = i[1];
			}
		}
		rst += right - left;
		System.out.println(rst);
	}
}

[이론_Java 기초] Queue 구현체 비교

audxkawjd17 — Mon, 2 Feb 2026 16:00:40 +0900

큐?

큐는 FIFO (First-In-First-Out, 선입선출) 구조의 자료구조이다. 말 그대로 먼저 들어온 데이터가 먼저 나가는 구조이다.

삽입 연산은 큐의 뒤에서만, 삭제 연산은 큐의 앞에서만 이루어 진다.

java.util.Queue

자바에서 큐 인터페이스의 주요 메서드를 살펴보자. 동일한 역할을 하는 메서드가 두 가지씩 있는데, 예외를 던지는 방식과 null이나 false를 반환하는 방식으로 나누어진다.

기능	예외 발생 (Throws Exception)	값 반환 (Returns value)
추가	add(e)	offer(e)
삭제	remove()	poll()
큐의 맨 앞에 있는 원소 확인	element()	peek()

값을 반환하는 메서드를 사용하면 큐가 비어있을 때 연산을 수행하더라도 프로그램이 종료되지 않는다.

LinkedList vs ArrayDeque

Queue 인터페이의 구현체로 LinkedList와 ArrayDeque를 주로 사용한다. 그렇다면 둘의 차이점은 무엇이고, 어떤 장단점이 있을까?

결론부터 언급하자면, ArrayDeque를 사용하는 것을 추천한다. 두 구현체는 대체 뭐가 다른 걸까? 아래에서 자세히 설명하겠다.

1️⃣ 내부 구조의 차이

가장 큰 차이는 내부 구조의 형태이다. LinkedList는 각 데이터가 'Node'라는 객체에 담겨 데이터, 다음 노드의 주소값을 가진다. 반면 ArrayDeque는 가변 배열을 사용한다. 단순히 데이터를 배열의 인덱스에 순차적으로 넣는 것이다. 이 내부 구조 때문에 두 구현체 간의 차이가 발생한다.

2️⃣ 메모리 효율성 (Memory Efficiency)

LinkedList는 데이터의 삽입, 삭제 연산을 수행할 때마다 참조값을 위한 추가 메모리(오버헤드)가 필요하다.

반면 ArrayDeque는 배열 기반이라 연속적으로 저장되기 때문에 이가 필요하지 않다.

3️⃣ 캐시 지역성 (Cache Locality)

LinkedList는 노드들이 여기저기에 흩어져 있기 때문에 다음 데이터를 찾을 때마다 메모리를 새로 탐색해야 하는 Cache Miss가 자주 발생한다.

반면 ArrayDeque는 배열이므로 데이터가 연속적으로 저장되어 있기 때문에 데이터를 읽을 때 한번에 캐시에 올리고, 접근 속도가 매우 빠르다.

4️⃣ 가비지 컬렉션 (GC)의 부담

LinkedList는 요소를 추가, 삭제할 때마다 매번 노드 객체를 생성, 해제해야한다. 이는 가비지 컬렉터에게 부담을 주어 프로그램 전반의 성능에 영향을 줄 수 있다.

반면 ArrayDeque는 배열을 재사용하기 때문에 더 효율적이다.

5️⃣ null 허용 여부

LinkedList는 null 값을 허용하는 반면, ArrayDeque는 null 값을 허용하지 않는다. 그 이유는 poll() 메서드에 있다.

poll() 메서드는 큐가 비어 있을 때 null을 반환하여 맨 앞에 원소가 아무것도 없다는 것을 알린다.

LinkedList는 다음 노드의 여부에 따라 큐가 비어있는지 확인하지만, ArrayDeque는 데이터를 배열에 바로 넣기 때문에 실제 데이터를 저장해야하는 곳에 null 값을 넣어버리면 진짜 데이터가 null인지, 큐가 비어있어서 null을 반환하는 것인지 구분할 수 없다.

따라서 이런 모호성을 방지하고 내부 연산 속도를 높이기 위해 ArrayDeque는 null 삽입을 금지한다. (NullPointerException 발생)

✅ 주요 성능 비교

특징	LinkedList	ArrayDeque
내부 구조	양방향 연결 리스트	가변 순환 배열
시간 복잡도	O(1)	Amortized O(1) (배열이 꽉 차서 늘릴 때 일시적으로 발생)
메모리 오버헤드	높음 (노드 참조값 필요)	낮음
null 허용 여부	허용	허용 안 함
추천 용도	중간 삽입, 삭제가 빈번할 때	대부분의 Queue 작업

Java 공식 문서에서도 LinkedList보다 ArrayDeque를 우선적으로 사용하라고 권장하는만큼, 앞으로는 ArrayDeque로 큐를 구현해보자..!

[BOJ Java] 백준 24465번: 데뷔의 꿈

audxkawjd17 — Sun, 18 Jan 2026 20:14:35 +0900

문제

[BOJ Java] 백준 24465번: 데뷔의 꿈
https://www.acmicpc.net/problem/24465

입력 및 출력

문제 풀이

먼저 기존 멤버 7명의 생일을 입력받고, 어느 별자리인지 체크한다. check 함수를 따로 만들어 활용하였고, star 배열에 유무를 저장하였다.
오디션 지원자 수 N을 입력받고, N개의 줄에서 지원자들의 생일을 입력받을 때마다 어느 별자리인지 체크하고, 기존 멤버와 겹치지 않는 별자리인 경우에만 생월, 생일을 int 배열로 List에 저장한다.
Collections.sort()로 생월을 기준으로 정렬하고, 생월이 같은 경우에는 람다식을 활용하여 생일을 기준으로 리스트를 정렬한다. 아래에서 람다식에 대한 설명을 좀 더 자세히 하겠다.
리스트가 비어있는 경우는 합격자가 한 명도 없다는 뜻이므로 "ALL FAILED"를 출력하고, 아닌 경우에는 정렬된 값을 순서대로 출력한다.

람다식이란?

함수를 간단한 하나의 식으로 표현한 것이다. 클래스, 객체를 만들지 않고 이름 없는 함수를 만들어 바로 전달할 수 있다.

1. 람다식의 기본 구조

(매개변수) → { 실행문 }

매개변수: 함수에 전달되는 값.

화살표: 매개변수를 이용해 다음의 실행문을 수행한다는 의미.
실행문: 실제로 수행할 코드. 결과값을 return 할 수 있음.

2. 람다식 설명

list.sort((a, b) -> {
	if (a[0] == b[0])
		return a[1] - b[1];
	return a[0] - b[0];
});

- (a, b)는 리스트에서 꺼낸 두 값을 의미한다. sort()는 두 값을 꺼내 비교하고, 크기에 따라 위치를 바꾸는 함수로, 비교 대상이 되는 두 값이 a, b이다.

- 정렬 메소드는 음수가 return 되면 a가 앞이라고 판단하고(순서 유지), 양수면 b가 앞이라고 판단한다(순서 변경). 예를 들어, a[1]=10, b[1]=20이면, 10-20=-10이므로 a가 앞으로 간다. (오름차순으로 정렬하는 경우)

- 내림차순으로 정렬하고 싶으면 return 부분에서 a와 b의 자리를 바꾸면 된다. (return b[1]-a[1]; 와 같이)

+) C++로만 알고리즘 문제 풀이를 하다가 최근 Java로도 병행하며 풀어보고 있다. 남들은 C에서 Java로 넘어가는건 어렵지 않다던데 왜 난 이렇게 어려운지 .... 자바를 안 쓴 지 너무 오래되어서 그런 것 같기도 하다....ㅠ

하나 더 추가하자면 처음에 System.out.println(i[0] + ' ' + i[1]);로 출력했다가 웬 이상한 숫자만 하나 출력되어서 잠시 헤맬뻔했다. " "로 바꾸니 해결되어서 그냥 제출하긴 했지만 .. 정확한 원인을 찾아보았다.
' '는 char 타입이라 아스키 코드로 바뀌어 int랑 더하기 연산이 그냥 이루어진다고 한다. 반면, " "는 String 타입이므로 문자열 연결 연산이 이루어져 내가 원하던 출력 형태로 나타낼 수 있는 것이다.

⌨️ Java 코드

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

class Main {
	static int check(int mon, int day) {
		if (mon == 1) {
			if (day <= 19)
				return 11;
			else
				return 0;
		} else if (mon == 2) {
			if (day <= 18)
				return 0;
			else
				return 1;
		} else if (mon == 3) {
			if (day <= 20)
				return 1;
			else
				return 2;
		} else if (mon == 4) {
			if (day <= 19)
				return 2;
			else
				return 3;
		} else if (mon == 5) {
			if (day <= 20)
				return 3;
			else
				return 4;
		} else if (mon == 6) {
			if (day <= 21)
				return 4;
			else
				return 5;
		} else if (mon == 7) {
			if (day <= 22)
				return 5;
			else
				return 6;
		} else if (mon == 8) {
			if (day <= 22)
				return 6;
			else
				return 7;
		} else if (mon == 9) {
			if (day <= 22)
				return 7;
			else
				return 8;
		} else if (mon == 10) {
			if (day <= 22)
				return 8;
			else
				return 9;
		} else if (mon == 11) {
			if (day <= 22)
				return 9;
			else
				return 10;
		} else {
			if (day <= 21)
				return 10;
			else
				return 11;
		}
	}

	public static void main(String args[]) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		int[] star = new int[12];
		for (int i = 0; i < 7; i++) {
			st = new StringTokenizer(br.readLine());
			int mon = Integer.parseInt(st.nextToken()), day = Integer.parseInt(st.nextToken());
			int mem = check(mon, day);
			star[mem] = 1;
		}
		int n = Integer.parseInt(br.readLine());
		List<int[]> list = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			st = new StringTokenizer(br.readLine());
			int mon = Integer.parseInt(st.nextToken()), day = Integer.parseInt(st.nextToken());
			int pass = check(mon, day);
			if (star[pass] == 0)
				list.add(new int[] { mon, day });
		}
		list.sort((a, b) -> {
			if (a[0] == b[0])
				return a[1] - b[1];
			return a[0] - b[0];
		});

		if (list.isEmpty())
			System.out.println("ALL FAILED");
		else {
			for (int[] i : list) {
				System.out.println(i[0] + " " + i[1]);
			}
		}
	}
}

[BOJ C++] 백준 10914번: Veni, vidi, vici

audxkawjd17 — Mon, 22 Dec 2025 18:09:41 +0900

문제

[BOJ C++] 백준 10914번: Veni, vidi, vici
https://www.acmicpc.net/problem/10914

입력 및 출력

문제 풀이

문제 본문에 있는 그대로 해결하면 되는 문제이다. 근데 브론즈 1인데 무려 4번이나 틀려버린 문제... 그래서 내가 틀렸던 원인들을 찾아 적어보려고 한다.

처음에는 getline으로 한 줄을 전부 받고 다시 읽는 방식으로 해결하려 했는데, 공백을 처리하기가 애매해져서 while문의 조건문에 cin>>str을 넣는 것으로 변경하였다. while문이 끝날 때 공백을 하나씩 출력해주기만 하면 된다.
str의 길이가 홀수이면, 맨 뒤에 있는 문자는 더미 글자이므로 pop_back() 함수를 사용하여 미리 제거한다.
"x"를 "yz"로 암호화 했으므로 문자를 2개씩 읽어야 한다. 그리고 $(y+z-n) mod 26$을 계산한다.

사진 출처: https://www.thecollector.com/i-came-i-saw-i-conquered-julius-caesar-veni-vidi-vici/

첫번째 문제는 입력된 문자열의 길이가 1일 때 pop_back() 함수를 시행하고 나면 str이 빈 문자열이 되어 오류가 발생한 것이었다. 이를 해결하기 위해 for문에 !str.empty() 조건을 추가하였다.
두번째 문제는 $y+z-n$의 값이 음수일 수 있다는 것이다. 예를 들어 n=10, str="aa"이면 $(0+0-10) mod 26 = -10$이 된다. 이를 해결하기 위해 모듈러 연산을 수행하기 전에 26을 더해 항상 양수가 나오도록 식을 $(y+z-n+26) mod 26$로 변경하였다.

⌨️ C++ 코드

#include <bits/stdc++.h>
using namespace std;

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

    int n;
    cin >> n;
    string str;
    while (cin >> str) {
        if (str.size() % 2) str.pop_back();
        for (int i = 0; !str.empty() && i < str.size() - 1; i+=2)
            cout << (char)((str[i] - 'a' + str[i + 1] - 'a' - n + 26) % 26 + 'a');
        cout << ' ';
    }
}

왔노라, 보았노라, 이겼노라 !!

[BOJ C++] 백준 1916번: 최소비용 구하기

audxkawjd17 — Sat, 20 Dec 2025 16:02:46 +0900

문제

[BOJ C++] 백준 1916번: 최소비용 구하기
https://www.acmicpc.net/problem/1916

입력 및 출력

문제 풀이

구현 과정

이 문제는 앞서 공부했던 이론인 다익스트라 알고리즘을 활용하여 해결할 수 있다.

[이론] 다익스트라 알고리즘

다익스트라 알고리즘이란? 하나의 정점에서 출발하여 그래프 상의 다른 모든 정점까지의 최단 경로를 찾는 알고리즘이다.
주의해야 할 점은 노드에서 노드로 가는 간선이 유일하지 않다는 점이다. 즉, A 도시에서 B 도시로 가는 버스가 여러 개 존재할 수 있다.

자세한 구현 방법은 다음과 같다.

먼저 버스의 정보를 모두 받아 2차원 벡터(v)에 저장한다. 두 도시를 연결하는 버스 정보가 없는 길은 무한으로 나타내야 하므로 초기값을 모두 INF으로 저장한다. INF 값은 도시의 개수(1,000) * 버스 비용 (100,000)인 100,000,000 이상으로 설정해야 한다. 그 이유는 아래 그림과 같다.

v[s][e]는 s 도시에서 e 도시로 가는 버스 비용을 의미한다. 이때, s 도시에서 e 도시로 가는 버스가 여러 대 있을 수 있으므로 이미 저장되어 있는 값과 새로 입력받은 값 중 더 작은 값을 골라 저장한다.
버스 정보를 모두 저장했다면 출발 도시부터 도착 도시까지의 최소 비용을 구해야 한다. 다음으로 선택한 도시를 cur라고 하고, 출발 도시부터 다른 도시까지의 거리는 dis 배열에 저장한다. 또, 이미 비용이 최소인 도시는 그보다 더 적은 비용으로 갈 수 없으므로 방문 여부를 visited 배열에 저장한다. (음수 가중치가 없으므로 비용을 다시 감소할 수는 없음.) 출발 도시부터 출발 도시까지의 거리는 0이므로 dis[start]=0으로 설정한다.

이후부터는 아래 과정을 반복한다. (방문 처리 - 거리 갱신 - 노드 선택)

현재 도시를 선택한 것이므로 visited[cur]=true로 설정하고, cur 도시와 연결된 도시들 중 아직 방문하지 않은 도시의 dis 값을 갱신한다. 기존에 저장된 값과 cur을 거쳐 방문했을 때의 값 중 더 작은 값을 골라 저장한다.
다음으로 방문할 도시를 선택하기 위해 거리가 최소인 도시를 찾아 cur로 설정한다.

예시 풀이

예제 1을 풀어보도록 하자. 도시는 5개, 버스는 8개가 존재한다. 1번 도시에서 5번 도시까지 가는 최소 비용을 찾아야 하고, 버스 정보를 그림으로 나타내면 다음과 같다.

dis 배열의 초기값은 INF(100,000)로 설정한다.

1번 도시에서 출발하므로 처음 방문하는 도시는 1번 도시이다. visied[1]=true로 변경하고, 1번 도시에 연결된 도시들의 거리를 갱신한다. 1번 도시에서 1번 도시로 가는 비용은 0이다.

아직 방문하지 않은 도시들 중 가장 비용이 작은 도시를 선택하여 visited 값을 true로 변경한다. 4번 도시의 비용이 1로 가장 작으므로 visited[4]=true로 변경하였다. 그 후, 4번 도시를 거쳐간 경우의 비용이 더 적은 경우가 있다면 dis 값을 갱신한다. dis[5]의 기존 값은 10인데, 1번-4번-5번으로 이동하는 경우에는 1+3=4의 비용이 든다. 1번 도시에서 5번 도시로 바로 이동하는 것보다 4번 도시를 거쳐 이동하는 것의 비용이 더 적으므로 값을 갱신한다.

다음으로 가장 적은 비용이 드는 도시인 2번 도시를 선택하고, 이웃한 도시인 4번 도시를 확인한다.

그러나 4번 도시는 이미 방문한 도시이므로 거리를 갱신할 필요가 없다. (이미 최솟값이기 때문.)

다음 도시는 3번 도시이다. 이웃 도시는 4번, 5번 도시인데, 4번 도시는 이미 방문했으므로 확인하지 않는다.

5번 도시의 기존값과 3번 도시를 거쳤을 때의 값이 동일하므로 갱신하지 않는다.

다음 도시는 5번 도시이다. 5번 도시는 이웃한 도시가 없으므로 확인할 필요가 없다.

다익스트라 알고리즘이 완료되었다. 시작 도시(1번)부터의 각 도시까지의 거리를 모두 계산했으므로, 도착 도시까지의 거리를 출력하기만 하면 된다.

반례 찾기 Tip

https://testcase.ac/problems/1916
질문 게시판에 여러 반례가 올라와있지만, 이 사이트를 통해 확인해 보는 것을 추천한다. 여러 반례를 한 번에 확인해 줘서 틀린 부분을 쉽게 찾아낼 수 있다! 필자도 틀렸습니다를 한 번 받았었는데 testcase.ac에 돌려본 결과 무한대 값이 너무 작아서 문제가 발생한 것을 발견할 수 있었다. (~~사실 질문 게시판을 꼼꼼히 읽지 않아서 몰랐던 것 ...~~)

⌨️ C++ 코드

#include <bits/stdc++.h>
using namespace std;

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

    int n, m, start, end, INF = 100000000;
    cin >> n >> m;
    vector<vector<int>> v(n + 1, vector<int>(n + 1, INF));
    vector<bool> visited(n + 1);
    vector<int> dis(n + 1, INF);
    for (int i = 0; i < m; i++) {
        int s, e, cost;
        cin >> s >> e >> cost;
        v[s][e] = min(v[s][e], cost);
    }
    cin >> start >> end;
    dis[start] = 0;
    int cur = start;
    for (int i = 1; i <= n; i++) {
        visited[cur] = true;
        for (int j = 1; j <= n; j++)
            if (visited[j] == false) dis[j] = min(dis[j], dis[cur] + v[cur][j]);

        int min_val = INF;
        for (int j = 1; j <= n; j++) {
            if (visited[j] == false && dis[j] < min_val) {
                min_val = dis[j];
                cur = j;
            }
        }
    }
    cout << dis[end];
}

인천 유명 두바이 쫀득쿠키 내돈내산 비교 후기 : 팔레트디저트, 르호베, 아롬베이크, 디저트릭, 한정선 녹 서울역점

audxkawjd17 — Sun, 14 Dec 2025 04:01:00 +0900

자세한 후기는 이곳에! 직접 맛보고 비교하며 상세하게 작성한 글입니다 ㅎㅎ.

https://m.blog.naver.com/chammnaa/224100623423

인천 유명 두바이 쫀득쿠키 내돈내산 비교 후기 : 팔레트디저트, 모니모니 본점, 아롬베이크, 디

안녕하세요! 요즘 두바이 열풍이 식을 줄 모르죠?? 아무리 블로그 리뷰들을 봐도 어떤 차이인지 모르겠더라...

blog.naver.com

결론

두바이 쫀득쿠키는

르호베 > 디저트릭 > 아롬베이크 > 팔레트디저트

두바이 수건 케이크는

팔레트디저트 > 디저트릭 > 아롬베이크

로 결론 내렸습니다 ㅎ 맛과 가격, 웨이팅까지 고려해서 같이 먹은 친구들이랑 열띤 토론한 결과예요. 아롬베이크랑 팔레트디저트 두바이 쫀득쿠키는 기대가 넘 커서 그랬나 생각보단 조금 아쉬웠어요. 대신 다른 메뉴는 굿 두바이 쫀득 쿠키랑 두바이 수건 케이크만을 기준으로 비교했습니다. 물론 개인적인 견해니까 참고만 해주시길 바랍니다 ㅎㅎ 여유가 되신다면 주변 지인들이랑 같이 여러 가지로 먹어보시는 걸 추천드려요. 각각의 매력이 다 다른거든요. 그치만 혼자 먹기엔 넘 달기도 하고, 금전 이슈가....

그리고!! 한정선 두바이st 찹쌀떡도 정말 맛있으니 꼭 방문해보시길 바랍니다 ㅎㅎ. 다른 과일 찹쌀떡도 넘 맛있어서 입에서 살살 녹음!! 최근에 두바이 딸기 신상 나왔다던데 얼른 먹어보고 싶네요..ㅜㅜ 월급아 어서 들어와~~~

+) 아롬베이크 오픈런 하실 분들은 여기를 참고해주세요!