요약 정리

알고리즘 문제 해결 흐름 정리

[1] 구슬탈출2

카테고리: BFS, 시뮬레이션, 상태 관리 핵심:

• 빨간 구슬과 파란 구슬 동시 이동

• 4방향 탐색, 이동 거리 비교로 겹침 처리

• 방문 상태: visited[rr][rc][br][bc] 4차원

• 최대 10번 제한

시스템 흐름도:

text

main()
├── 입력: board[N][M], R/B 초기위치
├── bfs(시작위치)
│   ├── Queue<State> 초기화
│   ├── while (!q.isEmpty())
│   │   ├── if (depth >= 10) continue
│   │   ├── for (4방향)
│   │   │   ├── move()로 R, B 이동
│   │   │   ├── B가 구멍 → continue
│   │   │   ├── R,B 겹침 → 이동거리로 조정
│   │   │   ├── R만 구멍 → return depth+1
│   │   │   └── 방문체크 후 큐 추가
│   └── return -1
└── 결과 출력

[2] 2048(Easy)

카테고리: DFS, 시뮬레이션, 백트래킹 핵심:

• 5번 이동 가능한 모든 경우 탐색 (4^5)

• 보드 상태 복사 후 이동 시뮬레이션

• 이동 방향별 처리 순서 다름

• 합쳐진 블록은 visited로 중복 합침 방지

시스템 흐름도:

text

main()
├── 입력: board[N][N]
├── dfs(board, 0)
│   ├── if (turns == 5) → 최대값 갱신
│   ├── for (4방향)
│   │   ├── board 복사본 생성
│   │   ├── move(복사본, 방향)
│   │   │   ├── 방향별 처리순서 설정
│   │   │   ├── visited 초기화
│   │   │   ├── 셀 이동 및 합치기
│   │   └── dfs(새보드, turns+1)
└── 결과 출력

[3] 뱀

카테고리: 시뮬레이션, 덱, 자료구조 핵심:

• Deque<int[]>: 뱀 몸통 좌표 (머리 추가, 꼬리 제거)

• Map<Integer, Character>: 시간별 방향 전환

• 동작: 매초 이동 → 사과 확인 → 충돌 체크

시스템 흐름도:

text

main()
├── 입력: board[N][N], 사과위치, 방향전환정보
├── simulate()
│   ├── Deque<int[]> snake 초기화
│   ├── while (true)
│   │   ├── time++
│   │   ├── 다음 머리 위치 계산
│   │   ├── 벽/자기몸 충돌 체크 → break
│   │   ├── if (사과있음) → 사과제거
│   │   ├── else → 꼬리 제거
│   │   ├── 방향전환 시간체크 → 방향변경
│   └── return time
└── 결과 출력

[4] 시험감독

카테고리: 수학, 구현 핵심:

• 각 시험장에 총감독관 1명 필수

• 남은 인원에 대해 부감독관 수 계산

• long 타입 사용 (범위 초과 가능)

시스템 흐름도:

text

main()
├── 입력: N, A[], B, C
├── for (각 시험장)
│   ├── total++ (총감독관)
│   ├── remaining = A[i] - B
│   ├── if (remaining > 0)
│   │   └── total += (remaining + C - 1) / C
└── 결과 출력

[5] 주사위 굴리기

카테고리: 시뮬레이션, 구현 핵심:

• 주사위 6면 값 배열 dice[7]

• 방향별 회전시 주사위 면 매핑

• 지도와 주사위 바닥면 값 교환

시스템 흐름도:

text

main()
├── 입력: board[N][M], 명령어 K개
├── for (각 명령)
│   ├── if (이동불가) continue
│   ├── updateDice(방향) → 주사위 회전
│   ├── if (board[nr][nc] == 0) → 지도에 주사위값 복사
│   ├── else → 주사위에 지도값 복사, 지도 0
│   └── printTop() → 주사위 윗면 출력
└── 종료

[6] 테트로미노

카테고리: DFS, 브루트포스 핵심:

• 4칸 DFS로 ㅡ, ㅁ, ㄱ, ㄴ 모양 처리

• ㅗ, ㅓ, ㅏ, ㅜ 모양 별도 함수 처리

• 가지치기 + 상/하 대칭 탐색 제한

시스템 흐름도:

text

main()
├── 입력: board[N][M]
├── for (모든 칸)
│   ├── visited[r][c] = true
│   ├── dfs(r,c,1,board[r][c]) → 4칸 연결
│   ├── visited[r][c] = false
│   └── aeiou(r,c) → ㅗ모양 처리
└── 최대값 출력

[7] 퇴사

카테고리: DP, 다이나믹 프로그래밍 핵심:

• 뒤에서부터 계산하는 DP

• 점화식: dp[i] = max(dp[i+1], money[i] + dp[endDay+1])

• 선택/미선택 경우의 수

시스템 흐름도:

text

main()
├── 입력: N, day[], money[]
├── dp[N+2] 초기화
├── for (i = N; i >= 1; i--)
│   ├── endDay = i + day[i] - 1
│   ├── dp[i] = dp[i+1] (선택안함)
│   ├── if (endDay <= N)
│   │   └── dp[i] = max(dp[i], money[i] + dp[endDay+1])
└── dp[1] 출력

[8] 연구소

카테고리: DFS, 조합, BFS 핵심:

• 벽 3개 조합으로 세우기 (완전탐색)

• BFS로 바이러스 전파

• 안전 영역 계산

시스템 흐름도:

text

main()
├── 입력: board[N][M]
├── buildWall(0) → 벽 3개 조합
│   ├── if (count == 3) → spreadVirus()
│   ├── for (모든 빈칸)
│   │   ├── 벽 세우기
│   │   ├── buildWall(count+1)
│   │   └── 벽 복구
└── 최대 안전영역 출력

[9] 로봇 청소기

카테고리: 시뮬레이션, 구현 핵심:

• 현재 칸 청소 후 4방향 탐색 (반시계 90도 회전)

• 후진 가능성 확인

• 청소 여부 체크 순서 중요

시스템 흐름도:

text

main()
├── 입력: board[N][M], 로봇 초기위치, 방향
├── while (true)
│   ├── 현재칸 청소
│   ├── for (4방향)
│   │   ├── 반시계 90도 회전
│   │   ├── 앞칸 청소 가능 → 이동
│   │   └── break
│   ├── if (4방향 모두 불가)
│   │   ├── 후진 시도
│   │   ├── 후진 불가 → break
└── 청소한 칸 수 출력

[10] 연산자 끼워넣기

카테고리: DFS, 순열 핵심:

• 연산자 개수 제한 있으므로 순열 생성

• 음수 나눗셈 처리 주의

• 연산자 배열 인덱스 리스트로 조합 생성

시스템 흐름도:

text

main()
├── 입력: N, numbers[], operators[]
├── start(1, list) → 연산자 순열 생성
│   ├── if (idx == N) → 계산 후 min/max 갱신
│   ├── for (4개 연산자)
│   │   ├── if (개수 0) continue
│   │   ├── 연산자 사용
│   │   ├── start(idx+1, list)
│   │   └── 연산자 복구
└── max, min 출력

[11] 스타트와 링크

카테고리: 조합, DFS, 백트래킹 핵심:

• N/2명씩 팀 나누기

• 팀 능력치 계산시 중복 제거 (i<j 조건)

• 대칭성 활용

시스템 흐름도:

text

main()
├── 입력: N, stats[][]
├── makeTeam(2, isStart, 1) → 팀 조합
│   ├── if (cnt == N/2) → 점수차 계산, min 갱신
│   ├── for (i = start; i <= N; i++)
│   │   ├── isStart[i] = true
│   │   ├── makeTeam(i+1, isStart, cnt+1)
│   │   └── isStart[i] = false
└── 최소 차이 출력

[12] 경사로

카테고리: 구현, 시뮬레이션 핵심:

• 높이 차 1 초과 불가

• 경사로 길이 L 만큼 연속 필요

• 경사로 겹침 불가

• 행별/열별 독립 검사

시스템 흐름도:

text

main()
├── 입력: N, L, map[][]
├── countingRow() → 행 검사
│   ├── for (각 행)
│   │   ├── bridge[]로 경사로 체크
│   │   ├── for (각 열)
│   │   │   ├── 높이차 계산
│   │   │   ├── 높이차 >1 → 불가
│   │   │   ├── 높이차 =1 → 경사로 설치 가능성 검사
│   │   │   └── 경사로 설치 및 중복 체크
│   └── 가능한 행 수 카운트
├── countingCol() → 열 검사 (동일)
└── 행+열 합 출력

[13] 톱니바퀴

카테고리: 시뮬레이션, 구현 핵심:

• 회전 전 맞닿은 극 확인

• rot[4] 배열로 각 톱니 회전 방향 저장

• 연쇄 전파 방향 결정 후 한번에 회전 적용

시스템 흐름도:

text

main()
├── 입력: gear[4][8], K개 명령
├── for (K번)
│   ├── rot[4] 초기화
│   ├── 왼쪽/오른쪽 연쇄 회전 방향 결정
│   ├── for (4개 톱니)
│   │   ├── if (rot[i] == 1) → 시계회전
│   │   ├── else if (rot[i] == -1) → 반시계회전
└── 점수 계산 출력

[14] 감시

카테고리: DFS, 조합, 시뮬레이션 핵심:

• CCTV 종류별 방향 경우의 수 미리 정의

• 각 CCTV 방향 선택 조합 탐색

• 감시 영역 전파

• cctvDir[종류][방향][4방향] 3차원 배열

시스템 흐름도:

text

main()
├── 입력: board[N][M], CCTV 정보
├── dfs(0, board) → CCTV 방향 조합
│   ├── if (depth == K) → 사각지대 계산, min 갱신
│   ├── CCTV 종류별 가능 방향 탐색
│   │   ├── board 복사본 생성
│   │   ├── watching()으로 감시영역 표시
│   │   └── dfs(depth+1, 새보드)
└── 최소 사각지대 출력

[15] 사다리 조작

카테고리: DFS, 백트래킹, 브루트포스 핵심:

• 추가 가로선 0~3개

• 조합 탐색시 start 인덱스 사용 (중복 제거)

• 가지치기: 이미 찾은 답보다 크면 중단

시스템 흐름도:

text

main()
├── 입력: N, M, H, 초기사다리
├── for (추가개수 = 0~3)
│   ├── addBridge(개수, 0, bridge)
│   │   ├── if (curr == total) → 사다리타기 검증
│   │   ├── for (모든 가능 위치)
│   │   │   ├── 가로선 추가 조건 체크
│   │   │   ├── 가로선 추가
│   │   │   ├── addBridge(개수, curr+1)
│   │   │   └── 가로선 제거
│   └── if (성공) break
└── 결과 출력

[16] 드래곤 커브

카테고리: 시뮬레이션, 세트 핵심:

• K세대 = (K-1세대) + (K-1세대 90도 회전 뒤집기)

• 방향 리스트 회전/확장

• Set<Pair>로 좌표 관리

시스템 흐름도:

text

main()
├── 입력: N개 드래곤 커브 정보
├── for (각 커브)
│   ├── dirs 리스트에 초기 방향 추가
│   ├── for (세대만큼)
│   │   ├── 이전 세대 방향들 90도 회전
│   │   └── 회전된 방향들 dirs에 추가
│   └── 좌표 Set에 추가
└── 정사각형 개수 계산 출력

[17] 치킨 배달

카테고리: 조합, 완전탐색 핵심:

• M개 치킨집 선택

• 조합 탐색시 start 인덱스 필수 (시간 초과 방지)

• 집-치킨집 거리 미리 계산 가능

시스템 흐름도:

text

main()
├── 입력: N, M, board[][], 집/치킨집 좌표
├── simulation(M, 0, selected) → 치킨집 조합
│   ├── if (cnt == M) → 치킨거리 계산, min 갱신
│   ├── for (i = start; i < chicken.size(); i++)
│   │   ├── selected[i] = true
│   │   ├── simulation(M, cnt+1, i+1, selected)
│   │   └── selected[i] = false
└── 최소 치킨거리 출력

[18] 큐빙

카테고리: 시뮬레이션, 구현 핵심:

• 54칸 1차원 배열로 큐브 표현

• side[face][12]로 인접면 매핑

• 회전시 temp 배열로 동시 치환

시스템 흐름도:

text

main()
├── 입력: T개 테스트케이스
├── for (각 테스트)
│   ├── cube[54] 초기화
│   ├── for (N개 명령)
│   │   ├── face = 명령별 면 인덱스
│   │   ├── times = (+면 1, -면 3)
│   │   ├── rotate(face, times)
│   │   │   ├── rotateSide12() → 인접 12칸 회전
│   │   │   └── rotateFace9() → 현재면 8칸 회전
└── U면 출력

[19] 인구 이동

카테고리: BFS, 시뮬레이션, 그래프 핵심:

• Union 클래스로 연합 정보 관리

• BFS로 인구 차이 L~R 범위 내 연합 형성

• 연합별 인구 재분배

시스템 흐름도:

text

main()
├── 입력: N, L, R, A[][]
├── while (true)
│   ├── unions = new ArrayList<>()
│   ├── visited[][] 초기화
│   ├── for (모든 칸)
│   │   ├── if (!visited) → BFS로 연합 형성
│   │   └── if (연합크기 >1) → unions 추가
│   ├── if (unions 비움) break
│   ├── for (각 연합) → 인구 재분배
│   └── day++
└── day 출력

[20] 나무 재테크

카테고리: 시뮬레이션, 자료구조 핵심:

• List<Tree>[][] treeMap으로 나무 위치 관리

• 나이순 정렬 (어린 나무부터 양분 흡수)

• 계절별 처리 (봄/여름/가을/겨울)

시스템 흐름도:

text

main()
├── 입력: N, M, K, A[][], 나무 정보
├── for (K년)
│   ├── springSummer() → 나이증가/죽은나무 처리
│   ├── autumn() → 번식 (나이 5배수)
│   └── winter() → 양분 추가
└── 살아있는 나무 수 출력

[21] 아기 상어

카테고리: BFS, 시뮬레이션 핵심:

• 상어 크기별 먹을 수 있는 물고기 제한

• BFS로 가장 가까운 물고기 탐색 (거리, 행, 열 순)

• 크기 증가시 eaten 리셋

시스템 흐름도:

text

main()
├── 입력: N, board[][], 상어 초기위치
├── while (true)
│   ├── fish = bfsFindBestFish() → 가장 가까운 물고기
│   ├── if (fish == null) break
│   ├── 이동 및 섭취
│   ├── eaten++
│   └── if (eaten == size) → size++, eaten=0
└── 총 시간 출력

[22] 미세먼지 안녕

카테고리: 시뮬레이션, 구현 핵심:

• 미세먼지 확산 (동시에 발생하므로 복사본 필요)

• 공기청정기 순환 (반시계/시계 방향)

• 배열 회전으로 공기 순환 구현

시스템 흐름도:

text

main()
├── 입력: R, C, T, room[][], 공기청정기 위치
├── for (T초)
│   ├── spreadMicroDust() → 미세먼지 확산
│   ├── cleaningRoom() → 공기청정기 작동
│   │   ├── cleaningUpSpace() → 위쪽 반시계
│   │   └── cleaningDownSpace() → 아래쪽 시계
│   ├── popGreen() → 가득찬 행 처리
│   └── checkLightZone() → 연한칸 처리
└── 미세먼지 총합 출력

[23] 낚시왕

카테고리: 시뮬레이션, 구현 핵심:

• 상어 클래스로 속성 관리

• 속력 최적화: speed %= (R-1)*2 또는 (C-1)*2

• 같은 칸 상어 충돌시 큰 상어만 생존

시스템 흐름도:

text

main()
├── 입력: R, C, M, 상어 정보
├── for (c = 1~C) → 낚시왕 이동
│   ├── fishingShark(c) → 해당 열 가장 위 상어 잡기
│   ├── swimmingShark() → 상어 이동
│   │   ├── copy[][]에 새 위치 계산
│   │   ├── 충돌시 큰 상어만 생존
│   │   └── map 업데이트
└── 잡은 상어 크기 합 출력

[24] 이차원 배열과 연산

카테고리: 시뮬레이션, 정렬 핵심:

• R연산: 행 ≥ 열일 때 행 정렬

• C연산: 행 < 열일 때 열 정렬

• Node 클래스로 (수, 등장횟수) 관리

• 100개 초과시 자르기

시스템 흐름도:

text

main()
├── 입력: r,c,k, A[3][3]
├── for (t = 1~100)
│   ├── if (행≥열) → RSorting()
│   │   ├── HashMap으로 숫자 카운트
│   │   ├── List<Node> 정렬 (cnt asc, num asc)
│   │   └── 새로운 배열 생성
│   ├── else → CSorting() (열 기준 동일)
│   └── if (A[r][c]==k) break
└── 시간 또는 -1 출력

[25] 연구소 3

카테고리: BFS, 조합, 시뮬레이션 핵심:

• M개 바이러스 활성화 조합

• BFS로 동시 전파

• 비활성 → 활성 바이러스 전환 가능

시스템 흐름도:

text

main()
├── 입력: N, M, lab[][], 바이러스 위치
├── combine(0,0,activated) → M개 바이러스 조합
│   ├── if (depth==M) → spreadVirus() 전파
│   ├── for (i=start; i<virus.size(); i++)
│   │   ├── activated 추가
│   │   ├── combine(depth+1, i+1)
│   │   └── activated 제거
└── 최소 시간 출력

[26] 게리맨더링 2

카테고리: 브루트포스, 구현 핵심:

• (x,y,d1,d2) 모든 조합 탐색

• 경계선 긋고 1~5번 선거구 할당

• 선거구별 인구 합 계산

시스템 흐름도:

text

main()
├── 입력: N, population[][]
├── for (모든 x,y,d1,d2 조합)
│   ├── ward[][] 초기화
│   ├── divideWard() → 5번 경계선
│   ├── 1~4번 선거구 할당
│   ├── 나머지 → 5번 선거구
│   └── 인구차 계산, min 갱신
└── 최소 인구차 출력

[27] 새로운 게임 2

카테고리: 시뮬레이션, 구현 핵심:

• List<Integer>[][] pieces로 말 위치 관리

• Map<Integer, Piece>로 말 정보 관리

• 말 이동시 위에 있는 말들 함께 이동

시스템 흐름도:

text

main()
├── 입력: N, K, board[][], 말 정보
├── while (turns <= 1000)
│   ├── movePieces() → 모든 말 이동
│   │   ├── stay/move 리스트로 말 분리
│   │   ├── 이동 및 충돌 처리
│   │   └── 4개 이상 쌓이면 종료
│   └── if (종료조건) break
└── 턴 수 출력

[28] 원판돌리기

카테고리: 시뮬레이션, BFS 핵심:

• 원판 배열 회전 (CW, CCW)

• 인접한 같은 숫자 제거 (BFS)

• 제거없을시 평균 계산 후 조정

시스템 흐름도:

text

main()
├── 입력: N, M, T, board[][], 회전명령
├── for (T번)
│   ├── simulate() → 원판 회전
│   ├── updateBoard() → 숫자 제거/조정
│   │   ├── BFS로 같은 숫자 그룹 찾기
│   │   ├── 그룹 제거
│   │   └── 없으면 평균 계산 후 조정
└── 원판 숫자 합 출력

[29] 주사위 윷놀이

카테고리: DFS, 백트래킹, 그래프 핵심:

• Node 클래스로 보드 경로 연결

• 이동 경로 하드코딩

• DFS로 말 4개 이동 조합 탐색

시스템 흐름도:

text

main()
├── 입력: 주사위 10개 눈
├── buildBoard() → 보드 그래프 생성
├── dfs(0,0) → 말 이동 조합
│   ├── if (turn==10) → 점수 갱신
│   ├── for (4개 말)
│   │   ├── if (도착) continue
│   │   ├── 이동 후 충돌 체크
│   │   ├── dfs(turn+1, score+점수)
│   │   └── 위치 복구
└── 최대 점수 출력

[30] 모노미노도미노 2

카테고리: 시뮬레이션, 구현 핵심:

• 초록보드(6x4), 파랑보드(6x4) 분리 관리

• 블록 타입별 이동 로직

• 줄 가득찼을시 삭제 및 이동

시스템 흐름도:

text

main()
├── 입력: N, 블록 정보
├── for (N개 블록)
│   ├── moveGreen() → 초록보드에 떨어뜨림
│   ├── moveBlue() → 파랑보드에 떨어뜨림
│   ├── popGreen() → 가득찬 행 처리
│   ├── popBlue() → 가득찬 열 처리
│   ├── checkLightGreenZone() → 연한칸 처리
│   └── checkLightBlueZone() → 연한칸 처리
└── 점수, 타일 개수 출력

[31] 청소년 상어

카테고리: DFS, 백트래킹, 시뮬레이션 핵심:

• Fish 클래스로 물고기 상태 관리

• 물고기 이동 (8방향, 회전)

• 상어 이동 가능한 모든 경로 탐색

시스템 흐름도:

text

main()
├── 입력: board[4][4], 물고기 정보
├── dfs(상어위치, 방향, 점수, board)
│   ├── moveFish() → 물고기 이동
│   ├── for (상어 이동 가능 위치)
│   │   ├── board 복사본 생성
│   │   ├── 물고기 먹기
│   │   └── dfs(새위치, 새방향, 새점수)
│   └── max 점수 갱신
└── 최대 점수 출력

[32] 어른 상어

카테고리: 시뮬레이션, 구현 핵심:

• 상어 클래스로 상태 관리

• 냄새 시간 관리

• 상어 이동 우선순위 테이블

시스템 흐름도:

text

main()
├── 입력: N, M, k, board[][], 상어정보, 우선순위
├── for (시간)
│   ├── movingShark() → 상어 이동
│   │   ├── 빈칸 → 자신의 냄새 순 탐색
│   │   ├── 충돌시 작은 번호 상어 생존
│   ├── scentTime 감소
│   ├── 새 냄새 추가
│   └── if (1번만 남음) break
└── 시간 출력

[33] 스타트 택시

카테고리: BFS, 시뮬레이션 핵심:

• BFS로 최단거리 승객 찾기

• 연료 관리 및 충전

• 벽에 둘러쌓인 경우 처리

시스템 흐름도:

text

main()
├── 입력: N, M, fuel, board[][], 승객정보
├── for (M명)
│   ├── selectMinDistPerson() → 가장 가까운 승객
│   ├── 택시→승객 이동 (연료 체크)
│   ├── 승객→목적지 이동 (연료 체크)
│   └── 연료 충전 (소모량×2)
└── 남은 연료 또는 -1 출력

[34] 컨베이어 벨트 위의 로봇

카테고리: 시뮬레이션, 구현 핵심:

• 벨트 회전 (로봇 포함)

• 로봇 이동 (앞칸 비었고 내구도 1 이상)

• 로봇 올리기 (내구도 1 이상)

시스템 흐름도:

text

main()
├── 입력: N, K, A[]
├── while (true)
│   ├── step++
│   ├── rotateBelt() → 벨트+로봇 회전
│   ├── moveRobot() → 로봇 이동
│   ├── addRobot() → 로봇 올리기
│   └── if (countZero() >= K) break
└── step 출력

[35] 마법사 상어와 파이어볼

카테고리: 시뮬레이션, 구현 핵심:

• FireBall 클래스로 속성 관리

• 이동 계산 최적화: (r + dr[dir]*speed) % N

• 2개 이상 합쳐지면 4개로 분할

시스템 흐름도:

text

main()
├── 입력: N, M, K, 파이어볼 정보
├── for (K번)
│   ├── moveFireball() → 파이어볼 이동
│   ├── update() → 합치기 및 분할
│   │   ├── Map<String, List>로 칸별 파이어볼 관리
│   │   ├── 2개 이상시 질량/속력/방향 계산
│   │   └── 질량 0이면 소멸
└── 남은 질량 합 출력

[36] 마법사 상어와 토네이도

카테고리: 시뮬레이션, 구현 핵심:

• 나선형 이동 패턴

• 모래 비율별 분산 계산

• 경계 밖으로 나간 모래 합산

시스템 흐름도:

text

main()
├── 입력: N, board[][]
├── while (중심→(1,1) 이동)
│   ├── tornado() → 모래 분산
│   │   ├── 이동방향별 비율 계산
│   │   ├── 각 위치에 모래 추가
│   │   └── 남은 모래 a칸으로 이동
│   ├── 다음 위치로 이동
│   └── 이동방향 변경 패턴
└── 밖으로 나간 모래 출력

[37] 마법사 상어와 파이어스톰

카테고리: 시뮬레이션, BFS 핵심:

• 부분 격자 90도 회전

• 얼음 녹이기 (인접 3칸 미만)

• BFS로 가장 큰 얼음 덩어리 찾기

시스템 흐름도:

text

main()
├── 입력: N, Q, board[][], L[]
├── for (Q번)
│   ├── fireStorm(L) → 회전 및 녹이기
│   │   ├── rotate90() → 부분 격자 회전
│   │   └── melt() → 얼음 녹이기
└── 전체 얼음 합, 최대 덩어리 출력

[38] 마법사 상어와 비바라기

카테고리: 시뮬레이션, 구현 핵심:

• 구름 boolean 배열로 관리

• 구름 이동 및 비 내리기

• 물복사버그 (대각선 4방향)

시스템 흐름도:

text

main()
├── 입력: N, M, A[][], 이동명령
├── cloud[][] 초기 구름 설정
├── for (M번)
│   ├── moveCloud() → 구름 이동
│   ├── rain() → 비 내리기
│   ├── waterCopyBug() → 물복사
│   └── makeNewCloud() → 새 구름 생성
└── 물의 총합 출력

[39] 마법사 상어와 블리자드

카테고리: 시뮬레이션, 구현 핵심:

• 나선형 배열 ↔ 리스트 변환

• 구슬 폭발 (4개 이상 연속)

• 구슬 변화 (개수, 번호)

시스템 흐름도:

text

main()
├── 입력: N, M, board[][], 마법정보
├── for (M번)
│   ├── blizzard() → 블리자드 마법
│   ├── arrToList() → 나선형 → 리스트
│   ├── moveBlank() → 빈칸 이동
│   ├── while (bomb()) → 구슬 폭발
│   ├── changeBead() → 구슬 변화
│   └── listToArr() → 리스트 → 나선형
└── 점수 계산 출력

[40] 마법사 상어와 복제

카테고리: 시뮬레이션, DFS, BFS 핵심:

• Fish 클래스로 물고기 상태

• 물고기 이동 (45도 반시계 회전)

• 상어 이동 DFS (사전순 우선)

시스템 흐름도:

text

main()
├── 입력: M, S, 물고기정보, 상어위치
├── while (S-- > 0)
│   ├── copy[][] → 물고기 복제
│   ├── moveAllFishes() → 물고기 이동
│   ├── dfs() → 상어 최적 이동 경로 찾기
│   ├── 상어 이동 및 물고기 제거
│   ├── smell 감소
│   └── 복제 마법 완료
└── 물고기 총수 출력

[41] 상어 초등학교

카테고리: 시뮬레이션, 구현 핵심:

• Student 클래스로 좋아하는 학생 관리

• 자리 선정 기준 (좋아하는 학생 수 → 빈칸 수 → 행 → 열)

• 만족도 계산

시스템 흐름도:

text

main()
├── 입력: N, 학생순서, 좋아하는학생4명
├── for (각 학생)
│   ├── setPosition() → 자리 선정
│   │   ├── 모든 빈칸 평가
│   │   ├── 정렬 (좋아하는학생↑, 빈칸↑, 행↓, 열↓)
│   │   └── 첫 번째 자리 선택
└── 만족도 합 출력

[42] 상어 중학교

카테고리: BFS, 시뮬레이션 핵심:

• Group 클래스로 블록 그룹 관리

• BFS로 블록 그룹 형성 (일반블록≥1, 무지개제한없음)

• 중력 적용 및 회전

시스템 흐름도:

text

main()
├── 입력: N, M, board[][]
├── while (true)
│   ├── makeGroup() → 블록 그룹 찾기
│   ├── largestGroup = getLargestGroup()
│   ├── removeBlock() → 블록 제거 및 점수
│   ├── gravity() → 중력 적용
│   ├── rotate90cw() → 90도 회전
│   └── gravity() → 중력 적용
└── 총 점수 출력

[43] 주사위 굴리기 2

카테고리: BFS, 시뮬레이션 핵심:

• 주사위 6면 값 배열

• BFS로 동일 숫자 칸 수 계산

• 이동 방향 변경 (A vs B 비교)

시스템 흐름도:

text

main()
├── 입력: N, M, K, map[][]
├── for (K번)
│   ├── moveDice() → 주사위 이동
│   ├── getScore() → BFS로 점수 획득
│   └── changeDirection() → 방향 변경
└── 총 점수 출력

[44] 온풍기 안녕!

카테고리: 시뮬레이션, BFS, 구현 핵심:

• 히터 바람 BFS 전파

• 온도 조절 (인접칸 차이/4)

• 벽 존재시 이동 제한

시스템 흐름도:

text

main()
├── 입력: R, C, K, board[][], 히터, 조사칸, 벽정보
├── while (초콜릿 ≤ 100)
│   ├── blowAllHeaters() → 히터 바람
│   ├── adjust() → 온도 조절
│   ├── decreaseBorder() → 바깥칸 -1
│   ├── 초콜릿++
│   └── if (모든 조사칸 ≥ K) break
└── 초콜릿 수 출력

[45] 어항정리

카테고리: 시뮬레이션, 구현 핵심:

• 2D 배열 회전 및 접기

• 물고기 수 조절 (차이/5)

• 최대/최소 차이 K 이하까지 반복

시스템 흐름도:

text

main()
├── 입력: N, K, fishTank[]
├── while (maxDiff > K)
│   ├── addFish() → 가장 적은 곳 +1
│   ├── rotate90() → 90도 회전
│   ├── rebalancing() → 물고기 수 조절
│   ├── makeOneLine() → 일렬로 놓기
│   ├── foldFishTank() → 2번 접기
│   ├── rebalancing()
│   └── makeOneLine()
└── 정리 횟수 출력