ImJay

[리눅스 마스터 2급] LVM(Logical Volume Manager) 완벽 가이드 — 기초부터 활용까지

ImJay — Sat, 9 Aug 2025 19:40:08 +0900

LVM(Logical Volume Manager) 완벽 가이드 — 기초부터 활용까지

1. 들어가며

서버나 스토리지를 운영하다 보면, “디스크 공간이 부족해졌을 때 어떻게 확장하지?”라는 고민을 하게 됩니다.
전통적인 파티션 방식은 구조가 고정되어 있어, 용량을 변경하려면 서비스 중단이 필요하고 데이터 손실 위험도 있습니다.
이때 **LVM(Logical Volume Manager)**을 사용하면, 디스크 공간을 훨씬 더 유연하고 안전하게 관리할 수 있습니다.

2. 기본 배경 지식

2-1. 파티션(Partition)이란?

하드디스크나 SSD를 '논리적으로 나눈 구역'
각 구역은 독립적으로 운영체제에서 관리
예: C 드라이브(운영체제), D 드라이브(데이터), E 드라이브(백업)
리눅스에서는 /dev/sda1, /dev/sda2 같은 형식
단점: 크기를 변경하기 어렵고, 다른 디스크 공간을 합치는 것이 사실상 불가능

2-2. 컨트롤러(Controller)란?

하드웨어 장치와 운영체제(OS) 사이에서 데이터를 주고받는 장치
스토리지 컨트롤러: 디스크 입출력, RAID 관리 등을 수행
RAID의 동작 레벨
- 하드웨어 RAID: 컨트롤러가 직접 관리, OS에는 하나의 디스크처럼 보임
- 소프트웨어 RAID: OS가 직접 RAID 기능을 수행 (리눅스 mdadm 등)

3. LVM이란?

**LVM(Logical Volume Manager)**는 운영체제(OS) 레벨에서 디스크를 추상화해 논리적 볼륨으로 관리하는 기술입니다.
즉, 여러 디스크나 파티션을 하나의 저장 풀(VG)로 묶고, 필요한 만큼 잘라서(LV) 사용할 수 있습니다.

4. LVM의 구성 요소

PV (Physical Volume) – 물리 볼륨
LVM이 관리할 수 있도록 초기화된 디스크 또는 파티션
bash

복사편집

pvcreate /dev/sda1
VG (Volume Group) – 볼륨 그룹
여러 PV를 묶어서 하나의 큰 저장 풀로 만든 것
bash

복사편집

vgcreate my_vg /dev/sda1 /dev/sdb1
LV (Logical Volume) – 논리 볼륨
VG에서 필요한 만큼 공간을 할당해 만든 가상의 디스크
nginx

복사편집

lvcreate -L 100G -n my_lv my_vg

5. LVM과 전통 파티션의 차이

항목전통 파티션LVM

크기 변경	어려움, 위험	유연하고 안전
여러 디스크 결합	불가능	가능
서비스 중 용량 변경	불가능(마운트 해제 필요)	가능(실시간 확장)
스냅샷	불가능	가능
복잡성	단순	구조 이해 필요

6. "마운트 해제 없이"란?

마운트(Mount): 디스크를 특정 경로(폴더)에 연결하는 것
마운트 해제(Unmount): 연결을 끊는 것
전통 파티션 방식: 용량 변경 시 반드시 마운트 해제 → 해당 서비스 중단
LVM: 온라인 상태에서 크기 변경 가능 → 서비스 중단 없이 운영 가능

7. LVM이 좋은 이유

용량 확장/축소 자유로움
새 디스크를 VG에 추가 → LV 용량 확장 → 파일시스템 확장
(예: /home을 500GB → 800GB로 확장, 서비스 중단 없음)
여러 디스크를 하나처럼 사용
서로 다른 크기·종류의 디스크도 하나의 VG로 묶어 활용
스냅샷 지원
작업 전 상태를 저장해두고, 실패 시 해당 시점으로 롤백 가능
마운트 해제 없이 관리 가능
서비스 가동 중에도 디스크 관리 가능

8. LVM을 굳이 쓰지 않는 경우

단순 환경: 개인 PC, NAS, 외장하드 등 용량 변동이 거의 없는 경우
성능 우선 환경: 극한의 I/O 성능이 필요한 경우(미세한 성능 저하 방지)
호환성 문제: 오래된 OS나 일부 복구 툴이 LVM을 지원하지 않는 경우
복잡성 회피: PV/VG/LV 구조 학습이 부담되는 경우

9. LVM과 RAID의 관계

RAID: 디스크를 묶어 성능·안정성 향상 (하드웨어 또는 소프트웨어에서 처리)
LVM: 디스크를 묶어 공간 관리 유연성 향상 (OS 레벨에서 처리)
둘은 계층이 다르며, 병행 사용 가능
- 예: RAID-5로 묶은 디스크를 LVM으로 관리

10. 정리

LVM은 운영 중 디스크 관리가 필요한 환경에서 강력한 도구입니다.
특히 서버 운영 중 용량 부족 문제를 서비스 중단 없이 해결할 수 있다는 점이 큰 장점입니다.
다만 단순 환경에서는 오히려 복잡성만 늘릴 수 있으므로, 용도에 맞게 선택하는 것이 중요합니다.

한 줄 요약

LVM = 디스크 공간을 가변적으로 나누고 합치는 ‘가변형 칸막이’
RAID = 여러 디스크를 묶어 성능과 안정성을 높이는 ‘집의 기초 공사’

[리눅스 마스터 2급] RAID 완벽 정리 — 원리부터 스페어 디스크, 복구 방식까지

ImJay — Sat, 9 Aug 2025 19:02:52 +0900

RAID 완벽 정리 — 원리부터 스페어 디스크, 복구 방식까지

1. RAID란?

RAID(Redundant Array of Independent/Inexpensive Disks)는 여러 개의 물리 디스크를 하나의 논리적 장치처럼 묶어서 성능 향상, 데이터 안정성, 또는 둘 다를 달성하는 기술입니다.

2. RAID-5란 무엇인가?

구성: 최소 3개의 디스크 필요
방식: 데이터를 스트라이핑(Stripe)하여 나누고, 각 스트라이프마다 패리티(Parity) 블록을 1개씩 저장
장점: 읽기 속도 우수, 디스크 1개 장애에도 데이터 복구 가능
단점: 쓰기 성능이 다소 저하(패리티 연산), 동시에 2개 이상 장애 시 복구 불가
용량 계산: (전체 디스크 수 - 1) × 각 디스크 용량

3. 스페어 디스크(Hot Spare)란?

정의: RAID에 포함되어 있지만 평상시에는 데이터 저장에 쓰이지 않고, 고장 시 자동으로 투입되는 예비 디스크
역할: 장애 발생 시 즉시 리빌드(Rebuild)를 시작하여 Degraded 모드의 위험 기간을 최소화
차이점:
- 패리티 저장 공간: 정상 동작 시 항상 데이터와 복구 정보를 저장하는 주전 선수
- 스페어 디스크: 평상시 놀다가 고장나면 들어오는 교체 선수

4. RAID-5와 스페어 디스크가 함께 있을 때 용량 계산

문제 예시

10GB 디스크 8개
스페어 디스크 1개, 나머지로 RAID-5 구성

전체: 8 × 10GB = 80GB
스페어 제외: 8 - 1 = 7개
RAID-5 패리티: 7 - 1 = 6개 데이터 디스크
실제 용량: 6 × 10GB = 60GB

✅ 정답: 60GB

5. RAID-5의 패리티 원리

패리티는 단순 복사본이 아닌, 같은 스트라이프 내의 데이터 블록들을 XOR 연산한 결과
XOR 특징: A ⊕ B ⊕ B = A → 한 블록이 없어도 나머지 블록과 패리티로 복원 가능
각 스트라이프의 패리티 블록은 내용이 다르며, 모든 디스크에 분산 저장되어 부하가 고르게 분배됨

6. 복구 과정 (예시)

예: 디스크 4개, Disk3 장애

StripeDisk1Disk2Disk3Disk4

1	D1	D2	D3(복구 대상)	P1(D1⊕D2⊕D3)
2	D4	D5	P2(복구 대상)	D6

복구 방법

Stripe 1: D3 = D1 ⊕ D2 ⊕ P1
Stripe 2: P2 = D4 ⊕ D5 ⊕ D6 (패리티 재생성)
이 과정을 각 스트라이프별로 반복하여 고장 디스크의 모든 블록을 재구성

7. Degraded 모드란?

디스크 1개 고장 시, RAID-5는 남은 데이터 + 패리티로 즉시 서비스를 유지
하지만 고장난 블록이 있을 때마다 실시간으로 패리티 연산을 수행해야 하므로 성능 저하 발생
이 상태에서 추가 장애가 나면 데이터 전체 손실 → Hot Spare로 즉시 복구를 시작하는 이유

8. RAID-5가 같은 데이터를 여러 번 저장하나?

아니요
RAID-5는 RAID-1처럼 같은 데이터를 통째로 복사하지 않습니다.
→ N개의 디스크 중 1개 분량만 패리티로 사용, 나머지는 모두 실제 데이터 저장
용량 효율: (N-1)/N

9. RAID 구성별 비교표

RAID 종류최소 디스크 수저장 방식장애 허용용량 효율장점단점

RAID 0	2	스트라이핑	0개	100%	속도 매우 빠름	고장 시 전체 손실
RAID 1	2	미러링	N/2개	50%	안정성 높음	용량 효율 낮음
RAID 5	3	스트라이핑+단일 패리티	1개	(N-1)/N	성능·안정성 균형	쓰기 느림
RAID 6	4	스트라이핑+이중 패리티	2개	(N-2)/N	안정성↑	쓰기 더 느림
RAID 10	4	미러+스트라이프	각 미러에서 1개	50%	빠름+안정성↑	비용↑

10. 마무리

RAID-5는 용량 효율, 성능, 안정성의 균형이 좋아서 많이 쓰입니다.
하지만 복구 중에는 취약하므로 Hot Spare 구성으로 위험 기간을 최소화하는 것이 안전합니다.
또한 RAID는 백업이 아니므로, 중요한 데이터는 반드시 별도 백업 체계를 운영해야 합니다.

[기출문제] 리눅스마스터 2급 기출문제

ImJay — Tue, 6 May 2025 14:20:55 +0900

1. 다음 중 소스 코드를 수정해서 만든 2차적 저작물을 반드시 공개해야 하는 라이선스로 알맞은 것은?
MPL

2. 다음 중 10분 후에 시스템을 종료하는 명령으로 알맞은 것은?

shutdown -h +10

3. 다음 중 MPL 라이선스에 대한 설명으로 틀린 것은?

MPL 소스 코드와 다른 코드를 결합한 경우에 다른 소스 코드를 공개해야 한다.

4. 다음 중 리눅스의 섀도 패스워드(Shadow Password)에 대한 설명으로 알맞은 것은?

UNIX 네트워크에서 일반적으로 사용되는 네트워크 인증 기능

5. 다음 중 콘솔 모드나 터미널창에서 로그아웃하는 방법으로 틀린 것은?

[Ctrl]+[c]

6. 다음에서 설명하는 라이선스로 알맞은 것은?

해당 소프트웨어를 누구나 개작할 수 있고, 수정본의 재배포 시에 소스 코드의 비공개가 가능하다. 이 라이선스가 적용된 소프트웨어에는 X Window System, JQuery, Node.js 등이 있다.

BSD

7. 다음은 ls -l 명령을 실행시킨 결과이다. 이에 대한 설명으로 틀린 것은?

-rwxr-xr-x ihd project 1024 Aug 13 10:10 client.c

소유자는 client.c를 수정할 수 없다.

8. 다음 설명에 해당하는 파일로 알맞은 것은?

콘솔로 로그인을 시도하는 사용자에게 메시지를 전달하려고 할 때 관리자가 이용하는 파일이다.

/etc/motd

9. 다음 중 특정 도메인이 사용하는 IP 주소를 조회하는 명령으로 틀린 것은?

hostname

10. 다음 중 ls 명령에서 알파벳 역순으로 출력할 때 사용하는 옵션으로 알맞은 것은?

-r

11. 다음 명령의 결과에 대한 설명으로 알맞은 것은?

rm -r 디렉터리명

디렉터리 내의 파일뿐만 아니라 하위 디렉터리와 그 안의 파일까지 모두 삭제한다.

12. 다음 중 "/" 디렉터리 바로 하단에 위치하는 디렉터리로 가장 거리가 먼 것은?

/include

13. 다음 명령에 대한 설명으로 맞는 것은?

useradd -f 5 ihduser

ihduser 계정은 패스워드 사용기한 만료 후 5일 동안만 사용할 수 있도록 한다.

14. 다음 설명에 적합한 라이선스로 알맞은 것은?

소스 코드를 수정해서 프로그램을 개발한 후에 소스 코드를 공개하지 않고 독점적 소프트웨어로 사용하려고 한다.

BSD

15. 다음 ( 괄호 ) 안에 들어갈 명령어로 알맞은 것은?

( ) -l kaituser
Last password change : Jul 05, 2021

chage

16. 다음 중 시스템에 로그인한 전체 사용자에게 메시지를 전달할 때 사용하는 명령으로 알맞은 것은?

wall

17. 다음 중 ping 명령어를 사용하여 확인할 수 있는 정보로 틀린 것은?

외부에서 사용 중인 시스템에 PING을 이용한 DOS attack 실행 유무

18. 다음 ( 괄호 ) 안에 들어갈 명령어로 알맞은 것은?

( ) ihduser
22:34:05 up 160 days, 9:19, 6 users, load average: 0:00

19. 다음 ( 괄호 ) 안에 들어갈 명령으로 알맞은 것은?

( 괄호 ) com1.txt com2.txt
com1.txt com2.txt differ: byte 8, line 1

cmp

20. 다음 설명에 해당하는 명령으로 알맞은 것은?

등록된 DNS 서버를 이용하여 도메인이나 IP를 조회하는 명령이다. 셀 상에서 직접 조회할 수도 있고, 이 명령 실행 후에 대화형으로도 조회할 수 있다.

nslookup

21. 다음 명령의 실행 결과에 대한 설명으로 가장 알맞은 것은?

traceroute ihd.or.kr
traceroute to ihd.or.kr ..

ihd.or.kr까지 도달하기 위해 거쳐 가는 연결된 노드들을 확인하고 있다.

22. 다음 중 파티션 설정에 관한 설명으로 틀린 것은?

시스템의 여러 관리정보가 있는 /var는 별도의 파티션으로 분할하는 것이 좋다.

23. 텍스트 파일인 a, b의 내용이 아래와 같을 때 ㉠ 명령의 실행에 따른 ㉡의 결과로 알맞은 것은?

cat a
korea team
cat b
fighting
㉠
cat b
㉡

㉠ cat a > b ㉡ korea team

24. /etc/passwd 파일의 7개 필드 관련 정보를 얻기 위한 명령으로 알맞은 것은?

man 5 passwd

25. 다음 중 CD-ROM이 IDE 장치의 Secondary Slave로 연결되어 있을 때, 일반적으로 사용하는 장치 파일명으로 알맞은 것은?

/dev/hdd1

26. 다음 중 리눅스 배포판에 대한 설명으로 알맞은 것은?

리눅스 전체 시스템을 구성하는 소프트웨어를 패키지 형태로 만들어 놓은 것

27. 다음 중 리눅스에서 최상위 디렉터리로 알맞은 것은?

28. 다음 명령의 실행 결과에 대한 설명으로 가장 알맞은 것은?

groupdel ihd1
groupdel: group 'ihd1' does not exist

ihd1 그룹을 제거하고자 하였으나, 해당 그룹이 존재하지 않아서 제거하지 못하였다.

29. 다음 주 traceroute 명령과 가장 관련이 깊은 프로토콜로 알맞은 것은?

ICMP

30. 다음 중 리눅스 커널이 들어있는 디렉터리로 알맞은 것은?

/boot

31. 다음 중 시스템의 메모리 사용량 정보를 확인하는 명령으로 알맞은 것은?

free

32. 물리적 시스템의 메모리(RAM)의 크기가 1GB일 때 권장할 만한 스왑 공간 용량으로 가장 알맞은 것은?

1GB

33. 다음 중 bash(Bourne Again Sheel)에서 fileB 파일의 뒷 부분에 fileA 파일의 내용을 추가하여 저장하는 명령은?

cat fileA >> fileB

34. 다음 중 확장 파티션에 부여될 수 있는 최대 파티션 번호 값으로 알맞은 것은?

35. 다음 중 리눅스의 특징으로 틀린 것은?

동적 라이브러리를 제공하지 않는다.

36. /etc/passwd 파일의 내용이 다음과 같은 경우 관련 설명으로 틀린 것은?

ihd:x:1000:1000::/home/ihd:/bin/false

ihd 계정의 패스워드는 암호화되어 /etc/shadows 파일에 저장되어 있다.

37. 리눅스의 기본 명령어에 대한 설명으로 틀린 것은?

내부명령어는 실행 시 새로운 서브 프로세스를 exec하여 실행한다.

38. 다음 중 nslokkup 실행 중인 상태에서 메일 서버 정보를 조회하기 위해 입력하는 명령으로 알맞은 것은?

set type=mx

39. 다음 중 유닉스(Unix) 운영체제를 개발한 인물들의 조합으로 알맞은 것은?

켄 톰슨, 데니스 리치

40. 다음 중 파티션과 장치명에 대한 설명으로 알맞은 것은?

hda는 첫 번째 IDE HDD를 나타낸다.

41. 섀도 패스워드(Shadow Password)를 사용할 때, /etc/passwd 파일에 포함된 내용으로 틀린 것은?

패스워드

42. 다음 중 논리 파티션에 부여될 수 있는 최소 파티션 번호 값으로 알맞은 것은?

43. test라는 바이너리 파일을 cat 명령으로 출력하였더니 모니터에 이상한 문자들이 출력되었다. 이렇게 출력된 문자들을 깔금히 모니터에서 제거하고자 할 때 사용하는 명령으로 알맞은 것은?

clear

44. 다음 중 디렉터리 내의 파일들의 정보를 화면 단위로 출력할 때 사용하는 명령으로 알맞은 것은?

ls -al | more

45. 다음 명령의 결과에 대한 설명으로 알맞은 것은?

mkdir .fileA

ls 명령에서 -a 옵션을 이용하면 .fileA 디렉터리를 찾을 수 있다.

46. 다음 중 사용 중인 호스트에서 ihd.or.kr까지 연결되는 과정을 알고 싶을 때 사용하는 명령으로 알맞은 것은?

traceroute ihd.or.kr

47. 다음 중 구글이 리눅스 커널 기반으로 만든 모바일 운영체제로 알맞은 것은?

Android

48. 다음 중 현재 사용 중인 가상 콘솔창 정보를 확인하는 명령으로 알맞은 것은?

tty

49. 다음 중 Bash 셸에서 설정된 PATH 환경변수에 /usr/local/bin이라는 새로운 경로를 추가하기 위한 명령으로 알맞은 것은?

export PATH=/usr/local/bin

50. 다음 명령어의 실행 결과에 대한 설명으로 알맞은 것은?

cal

오늘 날짜를 기준으로 속한 달이 출력된다.

오답이 8문제 있습니다. 양해 부탁드립니다.

[BOJ/Java] 12422. 창문 깨기 (Large)

ImJay — Fri, 14 Mar 2025 15:42:18 +0900

[BOJ/Java] 12422. 창문 깨기 (Large)

문제 링크

문제 해석

본 문제는 K개의 창문으로 둘러싸인 방에서 진행되는 상황을 모델링한다. 창문은 기본적으로 돌 한 개에 깨지나, H개의 창문은 강화되어 있어 첫 번째 돌은 견디고 두 번째 돌에 깨진다. 모임 전에 M명의 일꾼이 각각 무작위로 한 창문을 선택하여 추가 강화 작업을 수행하며, 한 번 강화할 때마다 해당 창문은 돌을 한 번 더 버틸 수 있다. 모임 당일에는 N명의 악당이 각자 한 개의 창문을 선택하여 돌을 던지며, 이미 깨진 창문에 돌이 던져지면 돌은 그대로 통과한다.

문제의 목표는 모임 후에 최소 한 개 이상의 창문이 깨질 확률을 구하는 것이다.

️ 풀이 과정

본 문제는 각 창문의 내구성을 강화와 돌 던지기의 결과로 모델링하여, 전체 방이 안전한 상태(즉, 한 개의 창문도 깨지지 않은 상태)가 될 확률을 계산한 후, 1에서 해당 확률을 빼어 창문이 깨질 확률을 구하는 문제이다. 문제 해결 과정은 다음과 같이 진행된다.

창문 그룹 분리:
K개의 창문 중 H개는 처음부터 강화된 창문(그룹 A)으로 기본 내구성이 2이며, 나머지 K − H개는 기본 창문(그룹 B)으로 기본 내구성이 1이다.
동적 계획법(DP)을 통한 경우의 수 계산:
각 창문에 대해 추가 강화 횟수(dr)와 돌에 맞은 횟수(ds)의 조합으로 기여도를 계산한다. 각 창문은 다음의 안전 조건을 만족해야 한다.
- 그룹 A(강화 창문): ds ≤ dr + 1
- 그룹 B(기본 창문): ds ≤ dr
각 창문에 대해 1/(dr! × ds!)의 가중치를 부여하는 생성함수를 고려하며, 전체 창문에 대한 경우의 수는 두 그룹의 DP 결과를 합성(convolution)하여 구한다.
최종 확률 계산:
모임에서 총 M회의 강화와 N회의 돌 던지기가 이루어질 때, 안전한 상태의 확률 P_safe는 아래와 같이 계산된다.

P_safe = (M! × N! / K^(M+N)) × S_total

여기서 S_total은 전체 generating function에서 x^M·y^N 항의 계수이다. 최종적으로 창문이 깨질 확률은 1 − P_safe로 구한다.

코드 구현 (Java)

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

public class Main {
    // M과 N의 최대값이 100임을 고려하여 MAX를 110으로 설정한다.
    static final int MAX = 110;
    
    public static void main(String[] args) throws Exception {
        // 빠른 입출력을 위하여 BufferedReader와 PrintWriter를 사용한다.
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        
        int T = Integer.parseInt(br.readLine().trim());
        
        // 0부터 MAX-1까지의 팩토리얼과 로그 팩토리얼을 미리 계산한다.
        double[] fact = new double[MAX];
        double[] logFact = new double[MAX];
        fact[0] = 1.0;
        logFact[0] = 0.0;
        for (int i = 1; i < MAX; i++) {
            fact[i] = fact[i - 1] * i;
            logFact[i] = logFact[i - 1] + Math.log(i);
        }
        // 0부터 MAX-1까지의 1/n! 값을 미리 계산한다.
        double[] invFact = new double[MAX];
        for (int i = 0; i < MAX; i++) {
            invFact[i] = 1.0 / fact[i];
        }
        
        // 각 테스트 케이스를 처리한다.
        for (int t = 1; t <= T; t++) {
            String line = br.readLine();
            String[] parts = line.trim().split("\\s+");
            int K = Integer.parseInt(parts[0]); // 창문의 총 개수이다.
            int N = Integer.parseInt(parts[1]); // 돌을 던지는 악당의 수이다.
            int M = Integer.parseInt(parts[2]); // 강화하는 일꾼의 수이다.
            int H = Integer.parseInt(parts[3]); // 처음부터 강화된 창문의 개수이다.
            
            // 그룹 A는 강화된 창문, 그룹 B는 기본 창문이다.
            int countA = H;
            int countB = K - H;
            
            // 그룹 A에 대한 DP 테이블을 구성한다.
            // dpA[r][s]는 그룹 A의 창문에 대해 총 r회의 추가 강화와 s회의 돌 던지기가 이루어졌을 때의 기여도 합이다.
            // 그룹 A의 안전 조건은 ds ≤ r + 1이다.
            double[][] dpA = new double[M + 1][N + 1];
            dpA[0][0] = 1.0;
            for (int i = 0; i < countA; i++) {
                double[][] newdp = new double[M + 1][N + 1];
                // 현재까지의 강화 횟수(r0)와 돌 던진 횟수(s0)에 대하여 순회한다.
                for (int r0 = 0; r0 <= M; r0++) {
                    for (int s0 = 0; s0 <= N; s0++) {
                        double cur = dpA[r0][s0];
                        if (cur == 0.0) continue;
                        int remR = M - r0; // 남은 강화 횟수이다.
                        int remS = N - s0; // 남은 돌 던지기 횟수이다.
                        // 새 창문에 대해 가능한 (dr, ds) 조합을 시도한다.
                        // 단, 안전 조건은 ds ≤ dr + 1이다.
                        for (int dr = 0; dr <= remR; dr++) {
                            int maxDs = Math.min(remS, dr + 1);
                            for (int ds = 0; ds <= maxDs; ds++) {
                                // 한 창문에서의 기여도는 1/(dr! × ds!)이다.
                                double add = invFact[dr] * invFact[ds];
                                newdp[r0 + dr][s0 + ds] += cur * add;
                            }
                        }
                    }
                }
                dpA = newdp;
            }
            
            // 그룹 B에 대한 DP 테이블을 구성한다.
            // dpB[r][s]는 그룹 B의 창문에 대해 총 r회의 추가 강화와 s회의 돌 던지기가 이루어졌을 때의 기여도 합이다.
            // 그룹 B의 안전 조건은 ds ≤ r이다.
            double[][] dpB = new double[M + 1][N + 1];
            dpB[0][0] = 1.0;
            for (int i = 0; i < countB; i++) {
                double[][] newdp = new double[M + 1][N + 1];
                for (int r0 = 0; r0 <= M; r0++) {
                    for (int s0 = 0; s0 <= N; s0++) {
                        double cur = dpB[r0][s0];
                        if (cur == 0.0) continue;
                        int remR = M - r0;
                        int remS = N - s0;
                        // 그룹 B의 경우, 가능한 (dr, ds) 조합은 ds ≤ dr를 만족한다.
                        for (int dr = 0; dr <= remR; dr++) {
                            int maxDs = Math.min(remS, dr);
                            for (int ds = 0; ds <= maxDs; ds++) {
                                double add = invFact[dr] * invFact[ds];
                                newdp[r0 + dr][s0 + ds] += cur * add;
                            }
                        }
                    }
                }
                dpB = newdp;
            }
            
            // 두 그룹의 DP 결과를 합성하여 전체 generating function에서 x^M · y^N 항의 계수 S_total을 구한다.
            double S_total = 0.0;
            for (int rA = 0; rA <= M; rA++) {
                for (int sA = 0; sA <= N; sA++) {
                    int rB = M - rA;
                    int sB = N - sA;
                    if (rB < 0 || sB < 0) continue;
                    S_total += dpA[rA][sA] * dpB[rB][sB];
                }
            }
            
            // 전체 방이 안전한 상태(즉, 한 개의 창문도 깨지지 않은 상태)가 될 확률 P_safe는 아래와 같이 계산된다.
            // P_safe = (M! × N! / K^(M+N)) × S_total
            // 큰 수의 계산을 위하여 로그를 사용하여 계산한다.
            double logP_safe;
            if (S_total == 0.0) {
                logP_safe = Double.NEGATIVE_INFINITY;
            } else {
                logP_safe = logFact[M] + logFact[N] + Math.log(S_total) - (M + N) * Math.log(K);
            }
            double P_safe = (logP_safe == Double.NEGATIVE_INFINITY ? 0.0 : Math.exp(logP_safe));
            double ans = 1.0 - P_safe;
            if (ans < 0) ans = 0.0;
            if (ans > 1) ans = 1.0;
            
            out.printf("Case #%d: %.8f%n", t, ans);
        }
        out.flush();
        out.close();
    }
}

⏱️ 시간 복잡도 분석

본 알고리즘은 각 창문마다 가능한 강화와 돌 던지기 조합을 2차원 동적 계획법(DP)을 사용하여 계산한다. DP 배열의 크기는 (M+1)×(N+1)이며, 내부 반복문에서는 강화 횟수와 돌 던지기 횟수를 모두 고려한다.

그룹 A와 그룹 B의 창문 수의 합은 K(최대 200)개이므로, 전체 시간 복잡도는 제한 내에서 충분히 계산 가능하다.

느낀점

본 문제는 단순해 보이는 상황을 수학적 모델링과 동적 계획법을 통하여 효과적으로 해결한 모범적인 사례이다. 각 창문의 내구성을 강화와 돌 던지기의 조합으로 세분화하여 안전 조건을 엄밀하게 정의한 점이 인상적이다. 또한, 큰 수의 연산에서 로그를 사용하여 오버플로우를 방지한 접근법은 계산의 안정성을 보장한다. 이러한 방법론은 복잡한 조합론 문제를 효율적으로 해결하는 데 큰 도움이 된다.

[BOJ/Java] 3628. Knockdown

ImJay — Fri, 14 Mar 2025 15:12:04 +0900

[BOJ/Java] 3628. Knockdown

문제 링크

3628번 - Knockdown

문제 해석

이 문제는 전 세계를 파괴하기 위해 특정 지점에 폭탄을 배치하는 시나리오를 다룬다.
각 폭탄은 동일한 파괴 반경을 가지며, 전 세계를 파괴할 수 있는 최소한의 반경을 찾아야 한다. ➡️

지구는 반지름이 1인 단위 구(Sphere) 로 모델링되며, 폭탄의 위치는 위도(latitude, φ)와 경도(longitude, λ) 로 주어진다.
거리는 구면 거리(Spherical Distance) 로 측정된다.

풀이 과정

1️⃣ 구 좌표 변환 (위도/경도 → 3D 좌표) ️➡️

지구는 구형이므로, 주어진 위도와 경도를 3D 좌표계로 변환해야 한다.

위도(φ)와 경도(λ)를 사용하여 다음 공식을 이용한다.

x = cos(φ) * cos(λ)  
y = cos(φ) * sin(λ)  
z = sin(φ)

이제 각 폭탄은 3D 공간의 점(Point) 으로 변환된다. ️

2️⃣ 최소 반경을 찾기 위한 접근 방식

목표는 어느 지점에서든 가장 가까운 폭탄까지의 거리가 최소 반경 r 이하가 되도록 하는 것이다.

즉, 지구상의 모든 점이 어떤 폭탄과도 최대 r 거리 이내에 있도록 보장해야 한다.
이를 해결하기 위해, 이분 탐색(이진 탐색) + 기하학적 계산을 활용한다. ⚙️

고려해야 할 후보 점들

각 폭탄의 반대편 점 (Antipodal Point)
- 폭탄이 위치한 점의 정반대 지점이 유력한 후보가 된다.
- 이는 (−x,−y,−z)(-x, -y, -z) 로 쉽게 구할 수 있다.
두 폭탄 사이의 중간점 (Pairwise Midpoint)
- 두 개의 폭탄이 있다면, 이들의 중간 벡터 방향이 적절한 후보가 될 수 있다.
세 폭탄으로 이루어진 정점 (Triple-wise Normal Vector)
- 세 개의 폭탄이 형성하는 평면의 법선 벡터가 유력한 후보가 된다.

최적화 목표: min max(dot product)

각 후보 지점에서 모든 폭탄과의 최대 내적(dot product) 값을 최소화하는 p를 찾아야 한다.
이 값이 작을수록 최적의 반경이 줄어든다.

최소 반경은 acos(최적의 내적 값) 으로 계산된다.

r = arccos(min max(p · bomb_i))

코드 구현 (Java)

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

public class Main {
    static final double EPS = 1e-9;  // 오차 허용 범위

    // 3차원 좌표를 저장하는 클래스
    static class Point {
        double x, y, z;
        Point(double x, double y, double z) {
            this.x = x; this.y = y; this.z = z;
        }
        Point add(Point p) { return new Point(x + p.x, y + p.y, z + p.z); }
        Point subtract(Point p) { return new Point(x - p.x, y - p.y, z - p.z); }
        Point multiply(double s) { return new Point(x * s, y * s, z * s); }
        double dot(Point p) { return x * p.x + y * p.y + z * p.z; }  // 내적
        Point cross(Point p) {  // 외적
            return new Point(y * p.z - z * p.y,
                             z * p.x - x * p.z,
                             x * p.y - y * p.x);
        }
        double norm() { return Math.sqrt(x * x + y * y + z * z); }  // 벡터 크기
        Point normalize() {  // 단위 벡터 변환
            double n = norm();
            if(n < EPS) return new Point(0, 0, 0);
            return new Point(x / n, y / n, z / n);
        }
    }

    static double candidateValue(Point p, Point[] bombs) {
        double val = -1e9;
        for (Point b : bombs) {
            val = Math.max(val, p.dot(b));
        }
        return val;
    }

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

        int n = Integer.parseInt(br.readLine().trim());
        Point[] bombs = new Point[n];

        for (int i = 0; i < n; i++) {
            String[] parts = br.readLine().trim().split("\\s+");
            double lat = Math.toRadians(Double.parseDouble(parts[0]));
            double lon = Math.toRadians(Double.parseDouble(parts[1]));
            double cosLat = Math.cos(lat);
            bombs[i] = new Point(cosLat * Math.cos(lon), cosLat * Math.sin(lon), Math.sin(lat));
        }

        double best = 1e9;

        for (int i = 0; i < n; i++) {
            Point cand = new Point(-bombs[i].x, -bombs[i].y, -bombs[i].z);
            best = Math.min(best, candidateValue(cand, bombs));
        }

        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n; j++) {
                Point sum = bombs[i].add(bombs[j]);
                if (sum.norm() > EPS) {
                    best = Math.min(best, candidateValue(sum.multiply(-1).normalize(), bombs));
                }
            }
        }

        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n; j++) {
                for (int k = j+1; k < n; k++) {
                    Point cross = bombs[i].subtract(bombs[j]).cross(bombs[i].subtract(bombs[k]));
                    if (cross.norm() > EPS) {
                        best = Math.min(best, candidateValue(cross.normalize(), bombs));
                        best = Math.min(best, candidateValue(cross.multiply(-1).normalize(), bombs));
                    }
                }
            }
        }

        best = Math.max(-1, Math.min(1, best));
        double ans = Math.acos(best);
        out.printf("%.6f\n", ans);
        out.flush();
    }
}

⏳ 시간 복잡도 분석

각 폭탄마다 후보 탐색 → O(n)
두 개의 폭탄을 이용한 후보 탐색 → O(n^2)
세 개의 폭탄을 이용한 후보 탐색 → O(n^3)
최대 폭탄 개수 n=20n = 20 이므로 최악의 경우 O(8000), 충분히 실행 가능 ✅

느낀 점

✅ 구면 기하학과 이분 탐색을 조합한 흥미로운 문제였다! ✨
✅ 폭탄이 최소한으로 커버해야 할 범위를 찾는 과정이 기하학적으로 재미있었다.
✅ 벡터 연산(내적, 외적, 단위 벡터 변환) 의 중요성을 다시 한번 체감했다!

[BOJ/Java] 6902. Orko

ImJay — Thu, 13 Mar 2025 17:35:41 +0900

[BOJ/Java] 6902. Orko

문제 링크: 문제 보기

문제 해석

Dumitru가 이상한 꿈을 꾸게 된다. 꿈 속에서 문이 잠긴 방에 갇힌 Dumitru는 n개의 박스를 발견하며, 각 박스에는 m개의 접시가 있다. 각 접시에는 1 이상의 정수가 적혀 있다. 그러던 중, 두 개의 정수 k와 l이 적힌 쪽지를 발견하고, 쪽지에는 아래와 같은 작업을 하라는 지시가 적혀 있다.

1단계: 첫 번째 박스부터 n번째 박스까지 순서대로 각 박스에서 한 개의 접시를 선택한다. 선택한 접시의 숫자를 노트에 기록한 후, 해당 접시의 숫자를 1로 변경한다.

2단계: n-1번째 박스부터 두 번째 박스까지 역순으로 각 박스에서 한 개의 접시를 선택한다.

목표는 노트에 기록된 숫자들의 곱이 k로 나누어 떨어지도록 하는 선택 방법의 총 가짓수 T를 구하고, T를 l로 나눈 나머지를 출력하는 것이다.

️ 풀이 과정

먼저, n, m, k, l과 각 박스의 접시 값들을 입력받는다. 문제의 핵심은 k의 약수를 상태로 활용하는 것이다. k의 모든 약수를 구한 뒤, 각 약수에 인덱스를 매핑하여 상태 전이 테이블을 구성한다.

각 박스마다 접시 선택의 경우의 수를 계산한다. 첫 번째 박스와 마지막 박스는 접시를 한 번만 선택하므로, 각 접시가 기여하는 값 그대로 반영된다.

중간 박스는 접시를 두 번 선택하는 경우가 있으므로, 첫 번째 선택(접시의 원래 숫자 기록)과 두 번째 선택(접시 숫자가 1로 변경됨)을 모두 고려하여 경우의 수를 누적한다.

동적 계획법(DP)을 이용해 각 박스에서 계산된 경우의 수를 누적하며, 현재까지 선택한 접시들의 곱의 gcd(k, ·) 값을 상태로 표현하여 전이를 수행한다.

모든 박스를 처리한 후, 최종 상태가 k(즉, k로 나누어 떨어지는 상태)가 되는 경우의 수를 l로 나눈 나머지를 출력한다.

코드 구현 (Java)

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

public class Main {

// 유클리드 호제법을 이용하여 최대공약수(GCD)를 구하는 메소드
static long gcd(long a, long b) {
    // b가 0이 될 때까지 반복
    while (b != 0) {
        long temp = a % b;  // a를 b로 나눈 나머지를 임시 저장
        a = b;              // a에 b 값을 대입
        b = temp;           // b에 나머지 값을 대입
    }
    return a;             // 최대공약수 반환
}

public static void main(String[] args) throws Exception {
    // 입력을 위한 BufferedReader 초기화
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
    // 첫 번째 줄 입력: 박스 개수 n과 각 박스당 접시 개수 m
    StringTokenizer st = new StringTokenizer(br.readLine());
    int n = Integer.parseInt(st.nextToken());
    int m = Integer.parseInt(st.nextToken());
    
    // 두 번째 줄 입력: 목표 정수 k와 모듈러 연산에 사용할 값 mod
    st = new StringTokenizer(br.readLine());
    int k = Integer.parseInt(st.nextToken());
    int mod = Integer.parseInt(st.nextToken());
    
    // k의 모든 약수를 구함 (각 상태로 활용)
    ArrayList<Integer> dList = new ArrayList<>();
    for (int i = 1; i * i <= k; i++) {
        if (k % i == 0) {
            dList.add(i);
            if (i * i != k) {
                dList.add(k / i);
            }
        }
    }
    
    // 약수를 오름차순으로 정렬
    Collections.sort(dList);
    int dCount = dList.size();
    
    // 약수를 배열에 저장
    int[] dArr = new int[dCount];
    for (int i = 0; i < dCount; i++) {
        dArr[i] = dList.get(i);
    }
    
    // 각 약수에 대해 인덱스를 매핑 (상태 전이 테이블 구성에 활용)
    HashMap<Integer, Integer> dIndex = new HashMap<>();
    for (int i = 0; i < dCount; i++) {
        dIndex.put(dArr[i], i);
    }
    
    // 상태 전이 테이블 구성: 두 상태의 곱의 결과에 대해 gcd(k, 곱) 값을 미리 계산
    int[][] mult = new int[dCount][dCount];
    for (int i = 0; i < dCount; i++) {
        for (int j = 0; j < dCount; j++) {
            long product = (long) dArr[i] * dArr[j];
            int g = (int) gcd(product, k);
            mult[i][j] = dIndex.get(g);
        }
    }
    
    // DP 배열 초기화: dp[i]는 현재 상태가 dArr[i]일 때의 경우의 수
    int[] dp = new int[dCount];
    // 초기 상태는 접시 선택 전 곱이 1인 상태
    dp[dIndex.get(1)] = 1;
    
    // 각 박스를 순서대로 처리
    for (int box = 1; box <= n; box++) {
        
        // 현재 박스의 접시들을 읽어, 각 접시의 숫자에 따른 상태(약수 상태)의 빈도수를 계산
        int[] freq = new int[dCount];
        st = new StringTokenizer(br.readLine());
        for (int j = 0; j < m; j++) {
            int plateValue = Integer.parseInt(st.nextToken());
            int g = (int) gcd(plateValue, k);
            int idx = dIndex.get(g);
            freq[idx]++;  // 해당 상태의 빈도수 증가
        }
        
        // 현재 박스에서 선택 가능한 경우의 수 분포를 저장할 배열
        int[] boxDist = new int[dCount];
        
        // 첫 번째 박스와 마지막 박스는 접시를 한 번만 선택하므로 단순히 freq 값을 사용
        if (box == 1 || box == n) {
            for (int i = 0; i < dCount; i++) {
                boxDist[i] = freq[i] % mod;
            }
        } else {
            // 중간 박스는 접시를 두 번 선택해야 함
            // 첫 번째 선택: 접시의 원래 숫자를 기록
            // 두 번째 선택: 해당 접시의 숫자가 1로 변함
            int[] doubleDist = new int[dCount];
            
            // 첫 번째 선택의 경우의 수를 추가
            for (int i = 0; i < dCount; i++) {
                doubleDist[i] = (doubleDist[i] + freq[i]) % mod;
            }
            
            // 두 번째 선택에 대해, 같은 접시를 두 번 선택하는 경우와 다른 접시를 선택하는 경우를 모두 고려
            for (int i = 0; i < dCount; i++) {
                for (int j = 0; j < dCount; j++) {
                    long ways;
                    if (i == j) {
                        // 같은 접시를 두 번 선택하는 경우
                        ways = (long) freq[i] * (freq[i] - 1);
                    } else {
                        // 서로 다른 접시를 선택하는 경우
                        ways = (long) freq[i] * freq[j];
                    }
                    if (ways == 0)
                        continue;
                    
                    // 두 선택의 결과 상태를 상태 전이 테이블을 이용해 계산
                    int newIndex = mult[i][j];
                    doubleDist[newIndex] = (int) ((doubleDist[newIndex] + ways) % mod);
                }
            }
            boxDist = doubleDist;
        }
        
        // 현재까지의 dp 배열과 현재 박스의 경우의 수(boxDist)를 이용하여 상태 전이를 수행
        int[] nextDP = new int[dCount];
        for (int i = 0; i < dCount; i++) {
            if (dp[i] == 0)
                continue;
            for (int j = 0; j < dCount; j++) {
                if (boxDist[j] == 0)
                    continue;
                int nextState = mult[i][j];  // 상태 전이
                nextDP[nextState] = (int) ((nextDP[nextState] + (long) dp[i] * boxDist[j]) % mod);
            }
        }
        
        // dp 배열을 업데이트
        dp = nextDP;
    }
    
    // 최종적으로 목표 상태 k(즉, k로 나누어 떨어지는 상태)의 경우의 수를 mod로 나눈 나머지를 출력
    System.out.println(dp[dIndex.get(k)] % mod);
}

⏱️ 시간 복잡도 분석

문제는 각 박스마다 m개의 접시를 처리하고, k의 약수 개수를 d라 할 때 전체 시간 복잡도는 O(n*m + n*d²)이다.
n은 최대 200, m은 최대 10,000이며, d는 k의 약수 개수로 보통 √k에 가까워 제한 내에서 충분히 계산 가능하다.

느낀점

문제 해결 과정에서 각 박스에서 접시 선택에 따른 상태 전이를 명확하게 처리하는 것이 핵심이었다.
정수론과 gcd를 활용하여 k의 약수를 상태로 처리한 점, 그리고 중간 박스에서 두 번 선택하는 경우를 세밀하게 고려한 점이 인상적이었다.

[BOJ/Java] 5266. Strange Dream

ImJay — Thu, 13 Mar 2025 17:12:40 +0900

[BOJ/Java] 5266. Strange Dream

문제 링크: 문제 보기

문제 해석

Dumitru가 이상한 꿈을 꿨다. 꿈속에서 문이 잠긴 방에 갇힌 Dumitru는 n개의 박스를 발견했다. 각 박스에는 m개의 접시가 있었고, 각 접시에는 1 이상의 정수가 적혀 있었다. 그러던 중 두 개의 정수 k와 l이 적힌 쪽지를 발견했다. 쪽지에는 다음과 같은 작업을 하라고 되어 있었다.

1단계: 첫 번째 박스부터 n번째 박스까지 순서대로 각 박스에서 한 개의 접시를 선택한다. 선택한 접시의 숫자를 노트에 기록한 후, 해당 접시의 숫자를 1로 바꾼다.

2단계: n-1번째 박스부터 두 번째 박스까지 역순으로 각 박스에서 한 개의 접시를 선택한다.

목표는 노트에 기록된 숫자들의 곱이 k로 나누어 떨어지도록 하는 선택 방법의 총 가짓수 T를 구하고, T를 l로 나눈 나머지를 출력하는 것이다.

✅ 핵심 개념

정수론과 gcd를 활용해 k의 약수를 처리한다.
각 박스별 접시 선택의 경우의 수를 구분해 계산한다.
동적 계획법(DP)을 통해 상태 전이를 누적한다.

️ 풀이 과정

먼저 입력으로 n, m, k, l과 각 박스의 접시에 적힌 수를 받았다. k의 모든 약수를 구해 각 약수를 상태로 사용하고, 약수에 대한 인덱스를 매핑했다.

각 박스마다 접시 선택의 경우의 수를 계산했다. 첫 번째 박스와 마지막 박스는 접시를 한 번만 선택하므로 각 접시가 기여하는 값이 그대로 반영되었다.

중간 박스는 두 번 선택하는 경우가 있어, 같은 접시를 두 번 선택하는 경우(두 번째 선택 시 1이 기록됨)와 서로 다른 접시를 선택하는 경우를 모두 고려했다.

DP 배열을 이용해 각 박스에서 계산된 경우의 수를 누적하며 상태 전이를 진행했다. 현재 상태는 지금까지 선택한 접시들의 숫자 곱의 gcd(k, ·) 값으로 표현된다.

모든 박스를 처리한 후, 최종 상태가 k로 나누어 떨어지는 경우의 수를 l로 나눈 나머지를 출력했다.

코드 구현 (Java)

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

public class Main {
    public static void main(String[] args) throws Exception {
        // 입력을 위한 BufferedReader 초기화
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        // 첫 번째 줄: n (박스 개수), m (각 박스 당 접시 개수) 입력
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        
        // 두 번째 줄: k (목표 배수), mod (나머지 연산 모듈) 입력
        st = new StringTokenizer(br.readLine());
        int k = Integer.parseInt(st.nextToken());
        int mod = Integer.parseInt(st.nextToken());
        
        // k의 모든 약수를 구함 (각 상태를 약수로 사용)
        ArrayList<Integer> dlist = new ArrayList<>();
        for (int i = 1; i * i <= k; i++) {
            if (k % i == 0) {
                dlist.add(i);
                if (i * i != k)
                    dlist.add(k / i);
            }
        }
        // 약수를 오름차순으로 정렬
        Collections.sort(dlist);
        int dCount = dlist.size();
        int[] dArr = new int[dCount];
        for (int i = 0; i < dCount; i++) {
            dArr[i] = dlist.get(i);
        }
        
        // 각 약수에 인덱스를 매핑 (상태 전이 테이블 구성에 사용)
        HashMap<Integer, Integer> dIndex = new HashMap<>();
        for (int i = 0; i < dCount; i++) {
            dIndex.put(dArr[i], i);
        }
        
        // 두 상태의 곱셈 결과의 gcd(k, 곱)으로 전이되는 상태를 미리 계산 (상태 전이 테이블)
        int[][] mult = new int[dCount][dCount];
        for (int i = 0; i < dCount; i++) {
            for (int j = 0; j < dCount; j++) {
                long prod = (long) dArr[i] * dArr[j];
                int g = (int) gcd(prod, k);
                mult[i][j] = dIndex.get(g);
            }
        }
        
        // dp 배열 초기화 (현재 상태별 경우의 수 저장)
        int[] dp = new int[dCount];
        // 초기 상태는 1 (곱의 결과가 1)인 상태에서 시작
        dp[dIndex.get(1)] = 1;
        
        // 각 박스별로 처리 (총 n개의 박스)
        for (int box = 1; box <= n; box++) {
            // 각 박스 내에서 약수 상태에 해당하는 접시 개수 카운트
            int[] freq = new int[dCount];
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < m; j++) {
                int val = Integer.parseInt(st.nextToken());
                int g = (int) gcd(val, k);
                int idx = dIndex.get(g);
                freq[idx]++; // 해당 약수 상태에 해당하는 접시 개수 증가
            }
            
            // 현재 박스에서 선택할 경우의 수를 계산할 배열
            int[] boxDist = new int[dCount];
            if (box == 1 || box == n) {
                // 첫 번째 박스와 마지막 박스는 한 번만 선택하므로 그대로 사용
                for (int i = 0; i < dCount; i++) {
                    boxDist[i] = freq[i] % mod;
                }
            } else {
                // 중간 박스는 두 번 선택함 (한 번은 기록 후 1로 변경, 두 번 선택 시 곱에 영향 없음)
                int[] doubleDist = new int[dCount];
                // 먼저 한 번 선택하는 경우 (기본적으로 freq 값을 더함)
                for (int i = 0; i < dCount; i++) {
                    doubleDist[i] = (doubleDist[i] + freq[i]) % mod;
                }
                // 두 번째 선택의 경우: 같은 접시 또는 다른 접시 선택 경우 고려
                for (int i = 0; i < dCount; i++) {
                    for (int j = 0; j < dCount; j++) {
                        // i와 j가 같은 경우: 같은 접시를 두 번 선택하는 경우
                        // i와 j가 다른 경우: 서로 다른 접시를 선택하는 경우
                        long ways = (i == j) ? (long) freq[i] * (freq[i] - 1) : (long) freq[i] * freq[j];
                        if (ways == 0)
                            continue;
                        int idx = mult[i][j];
                        doubleDist[idx] = (int) ((doubleDist[idx] + ways) % mod);
                    }
                }
                boxDist = doubleDist;
            }
            
            // 현재까지의 dp와 이번 박스의 boxDist를 이용해 다음 상태(ndp)를 계산
            int[] ndp = new int[dCount];
            for (int i = 0; i < dCount; i++) {
                if (dp[i] == 0)
                    continue;
                for (int j = 0; j < dCount; j++) {
                    if (boxDist[j] == 0)
                        continue;
                    int ns = mult[i][j]; // 현재 상태 i에서 박스의 선택 j를 적용한 새로운 상태
                    ndp[ns] = (int) ((ndp[ns] + (long) dp[i] * boxDist[j]) % mod);
                }
            }
            // dp 배열 갱신
            dp = ndp;
        }
        // 최종적으로 dp 배열에서 목표 상태 k (즉, 약수 상태가 k가 되는 경우)의 값을 출력
        System.out.println(dp[dIndex.get(k)] % mod);
    }
    
    // 유클리드 호제법을 이용한 최대공약수(GCD) 계산 메소드
    static long gcd(long a, long b) {
        while (b != 0) {
            long t = a % b;
            a = b;
            b = t;
        }
        return a;
    }
}

⏱️ 시간 복잡도 분석

문제는 각 박스마다 m개의 접시를 처리하고, k의 약수 개수를 d라 할 때 O(n*m + n*d²)의 시간 복잡도를 가진다.
n은 최대 200, m은 최대 10,000이며, d는 k의 약수 개수로 보통 √k에 가까워 제한 내에서 충분히 계산된다.

느낀점

문제 접근 방식은 각 박스에서의 접시 선택에 따른 상태 전이를 명확하게 처리하는 데 초점을 두었다.
정수론과 gcd를 활용해 k의 약수를 처리하며 상태 전이 테이블을 구성한 점이 인상적이다.
동일한 박스에서 접시를 두 번 선택하는 경우를 세밀하게 고려한 점이 문제 해결의 핵심 포인트였다.

[BOJ/Java] 11404. 플로이드

ImJay — Mon, 10 Mar 2025 10:33:18 +0900

[BOJ/Java] 11404. 플로이드

문제 링크

문제 해석

N개의 도시가 있고, M개의 버스 노선이 존재한다.
각 버스는 특정한 비용이 있으며, 도시 간 최단 비용을 구하는 문제이다.

주어진 정보

N: 도시의 개수 (2 ≤ N ≤ 100)
M: 버스 노선의 개수 (1 ≤ M ≤ 100,000)
A B C: A번 도시에서 B번 도시로 가는 비용이 C (중복 가능)

✅ 목표:
1️⃣ 모든 도시 쌍(i → j)에 대한 최소 비용 경로를 구하기
2️⃣ 경로가 없는 경우 0을 출력

풀이 과정

1️⃣ 플로이드-워셜 알고리즘 사용

모든 노드에서 모든 노드까지의 최단 거리를 구하는 문제이므로 플로이드-워셜 알고리즘을 사용
시간 복잡도: O(N³), N=100이므로 충분히 가능

2️⃣ 초기화

무한대(INF) 값 설정 (dist[i][j] = INF)
자기 자신으로 가는 경로 dist[i][i] = 0
입력값을 바탕으로 직접 이동 가능한 거리 설정

3️⃣ 플로이드-워셜 수행

k번 노드를 거쳐가는 경로(i → k → j)를 고려하여 i → j로 가는 최소 비용 갱신

코드 (Java)

import java.util.*;

public class Main {
    static final int INF = 1000000000;
    static int N, M;
    static int[][] dist;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        M = sc.nextInt();
        dist = new int[N + 1][N + 1];

        // 거리 배열 초기화
        for (int i = 1; i <= N; i++) {
            Arrays.fill(dist[i], INF);
            dist[i][i] = 0; // 자기 자신은 0
        }

        // 입력 받기
        for (int i = 0; i < M; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            dist[a][b] = Math.min(dist[a][b], c); // 같은 노선이 여러 개일 수 있음
        }

        // 플로이드-워셜 알고리즘 수행
        for (int k = 1; k <= N; k++) {
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    if (dist[i][k] != INF && dist[k][j] != INF) {
                        dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
                    }
                }
            }
        }

        // 결과 출력
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                System.out.print((dist[i][j] == INF ? "0" : dist[i][j]) + " ");
            }
            System.out.println();
        }
    }
}

⏱ 시간 복잡도 분석

플로이드-워셜 알고리즘: O(N³), N ≤ 100이므로 100³ = 1,000,000 연산은 충분히 가능

느낀 점

✅ 플로이드-워셜 알고리즘의 기본적인 형태를 익힐 수 있었다.
✅ 중복 간선이 존재할 수 있으므로 Math.min()으로 최소 비용 갱신해야 한다.
✅ 경로가 없을 경우 0을 출력하는 처리를 조심해야 한다.

그래프 최단 경로 문제의 기본 중 기본! 확실하게 익혀야 할 문제다.

[BOJ/Java] 2931. 가스관

ImJay — Mon, 10 Mar 2025 10:31:04 +0900

[BOJ/Java] 2931. 가스관

문제 링크

문제 해석

도시에는 여러 개의 가스관이 설치되어 있으며, 가스관은 일정한 패턴의 블록으로 이루어져 있다.
어느 날 하나의 블록이 사라지는 사고가 발생하여, 이를 찾아 원래의 블록을 복구해야 한다.

주어진 정보

N × M 크기의 도시 지도 (.: 빈칸, + - | 1 2 3 4 M Z: 가스관)
M: 가스가 시작되는 위치
Z: 가스가 도착하는 위치

✅ 목표:
1️⃣ 사라진 블록의 위치를 찾아 출력
2️⃣ 해당 위치에 들어갈 올바른 블록 종류를 출력

풀이 과정

1️⃣ 사라진 블록(.) 찾기

가스관을 따라가다가 연결이 끊긴 지점을 찾는다.

2️⃣ 사라진 블록이 가질 수 있는 형태 탐색

+ - | 1 2 3 4 중 올바른 블록을 결정
연결된 블록들의 방향을 고려하여 가능한 블록을 찾는다.

3️⃣ BFS를 활용한 가스관 탐색

M에서 시작하여 가스관을 따라 이동하며 연결된 블록 탐색
.을 만나는 순간 끊어졌으므로 사라진 블록의 위치 기록

코드 (Java)

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    static int R, C;
    static char[][] map;

    static final int[] dx = {-1, 1, 0, 0};  // 상, 하, 좌, 우
    static final int[] dy = {0, 0, -1, 1};

    static final int TOP = 0, BOTTOM = 1, LEFT = 2, RIGHT = 3;

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

        String[] input = in.readLine().split(" ");
        R = Integer.parseInt(input[0]);
        C = Integer.parseInt(input[1]);
        map = new char[R][C];

        for (int i = 0; i < R; i++) {
            map[i] = in.readLine().toCharArray();
        }

        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                if (map[i][j] == '.' && check(i, j)) {
                    return;
                }
            }
        }
    }

    private static boolean check(int x, int y) {
        boolean[] connected = new boolean[4];

        if (isValid(x + dx[TOP], y + dy[TOP]) && canComeBottom(map[x + dx[TOP]][y + dy[TOP]])) {
            connected[TOP] = true;
        }
        if (isValid(x + dx[BOTTOM], y + dy[BOTTOM]) && canComeTop(map[x + dx[BOTTOM]][y + dy[BOTTOM]])) {
            connected[BOTTOM] = true;
        }
        if (isValid(x + dx[LEFT], y + dy[LEFT]) && canComeRight(map[x + dx[LEFT]][y + dy[LEFT]])) {
            connected[LEFT] = true;
        }
        if (isValid(x + dx[RIGHT], y + dy[RIGHT]) && canComeLeft(map[x + dx[RIGHT]][y + dy[RIGHT]])) {
            connected[RIGHT] = true;
        }

        char correctPipe = findCorrectPipe(connected);
        if (correctPipe != '?') {
            System.out.println((x + 1) + " " + (y + 1) + " " + correctPipe);
            return true;
        }

        return false;
    }

    private static char findCorrectPipe(boolean[] connected) {
        if (connected[TOP] && connected[BOTTOM] && connected[LEFT] && connected[RIGHT]) return '+';
        if (connected[TOP] && connected[BOTTOM]) return '|';
        if (connected[LEFT] && connected[RIGHT]) return '-';
        if (connected[BOTTOM] && connected[RIGHT]) return '1';
        if (connected[TOP] && connected[RIGHT]) return '2';
        if (connected[TOP] && connected[LEFT]) return '3';
        if (connected[BOTTOM] && connected[LEFT]) return '4';
        return '?';
    }

    private static boolean canComeTop(char c) {
        return c == '|' || c == '+' || c == '2' || c == '3';
    }

    private static boolean canComeBottom(char c) {
        return c == '|' || c == '+' || c == '1' || c == '4';
    }

    private static boolean canComeLeft(char c) {
        return c == '-' || c == '+' || c == '3' || c == '4';
    }

    private static boolean canComeRight(char c) {
        return c == '-' || c == '+' || c == '1' || c == '2';
    }

    private static boolean isValid(int x, int y) {
        return x >= 0 && x < R && y >= 0 && y < C;
    }
}

⏱ 시간 복잡도 분석

BFS 탐색 → O(N × M)
가능한 블록 탐색 → O(7 × 4) = O(28) (상수 시간)
총 시간 복잡도 → O(N × M), 충분히 해결 가능

느낀 점

✅ 양방향 연결을 고려하는 것이 중요했다.
✅ 올바른 블록을 찾을 때 모든 방향에서 연결 가능 여부를 체크해야 했다.
✅ 출력 좌표는 1부터 시작하므로 주의해야 했다.

디테일한 조건을 정확히 처리하는 것이 핵심인 문제였다!

[BOJ/Java] 11657. 타임머신

ImJay — Mon, 10 Mar 2025 10:10:10 +0900

[BOJ/Java] 11657. 타임머신

문제 링크

문제 해석

한 도시에서 다른 도시로 이동하는 버스 노선이 주어진다.
일부 노선에는 음의 가중치(시간)가 존재하며, 음수 사이클이 발생할 수도 있다.

주어진 정보

N: 도시의 개수 (노드)
M: 버스 노선의 개수 (간선)
A B C: A번 도시에서 B번 도시로 가는 시간이 C(양수 또는 음수)

✅ 목표:
1️⃣ 1번 도시에서 모든 도시로 가는 최단 시간을 구한다.
2️⃣ 음수 사이클이 존재하는지 판별한다.

1 → 2 → 3 → 1로 돌아오면 음수 사이클 발생!

풀이 과정

1️⃣ 벨만-포드 (Bellman-Ford) 알고리즘 사용

✔ 음수 가중치가 존재할 수 있기 때문에 다익스트라가 아닌 벨만-포드 알고리즘을 사용
✔ N-1번 모든 간선을 확인하며 최단 경로 갱신
✔ N번째 갱신에서 값이 줄어들면 음수 사이클 존재!

2️⃣ 알고리즘 진행 방식

✅ 모든 최단 경로를 **무한대(INF)**로 초기화
✅ N-1번 동안 모든 간선을 순회하면서 거리 갱신
✅ N번째 반복에서 갱신이 발생하면 음수 사이클 존재!

코드 (Java)

import java.util.*;

public class Main {
    static final long INF = Long.MAX_VALUE;
    static int N, M;
    static List<Edge> edges;
    static long[] dist;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        M = sc.nextInt();

        edges = new ArrayList<>();
        dist = new long[N + 1];
        Arrays.fill(dist, INF);
        dist[1] = 0; // 시작점 설정

        for (int i = 0; i < M; i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            int w = sc.nextInt();
            edges.add(new Edge(u, v, w));
        }

        if (bellmanFord()) {
            System.out.println("-1"); // 음수 사이클 존재
        } else {
            for (int i = 2; i <= N; i++) {
                System.out.println(dist[i] == INF ? "-1" : dist[i]);
            }
        }
    }

    static boolean bellmanFord() {
        boolean updated = false;
        
        for (int i = 1; i < N; i++) { // N-1번 반복
            updated = false;
            for (Edge edge : edges) {
                if (dist[edge.u] != INF && dist[edge.v] > dist[edge.u] + edge.w) {
                    dist[edge.v] = dist[edge.u] + edge.w;
                    updated = true;
                }
            }
            if (!updated) break;
        }

        // N번째 반복에서 갱신 발생하면 음수 사이클 존재
        for (Edge edge : edges) {
            if (dist[edge.u] != INF && dist[edge.v] > dist[edge.u] + edge.w) {
                return true;
            }
        }
        return false;
    }

    static class Edge {
        int u, v, w;
        public Edge(int u, int v, int w) {
            this.u = u;
            this.v = v;
            this.w = w;
        }
    }
}

⏱ 시간 복잡도 분석

벨만-포드 알고리즘: O(N × M)
N ≤ 500, M ≤ 6000이므로 최악의 경우 500 × 6000 = 3,000,000 연산 (가능)

느낀 점

벨만-포드를 활용한 대표적인 문제였다.
➡️ 음수 가중치가 포함된 경우는 다익스트라 대신 벨만-포드 사용!
➡️ N번째 갱신 여부를 체크하면 음수 사이클 판별이 가능하다.

디테일한 부분에서 실수하기 쉬웠다.
✅ dist 배열을 Long 타입으로 선언해야 오버플로우 방지 가능!
✅ 시작점(1번 도시)을 0으로 초기화하는 것 잊지 않기
✅ 음수 사이클이 존재하면 -1을 바로 출력하고 종료해야 한다.

음수 가중치 그래프 문제를 연습하는 데 아주 좋은 문제였다!