개발날씨맑음

3월을 맞이하며, 2022년 회고 (SSAFY 7기 수료)

다교이 — Mon, 6 Mar 2023 22:44:09 +0900

2022년 회고를 지금 하는 게 조금 웃기긴 하지만...(?) 나름 알차게 살았던 2022년을 기록하고 싶었다.
나의 2022년은 SSAFY로 시작해서 SSAFY로 끝났다... 물론 중간중간 놀 거 다 놀긴 했다 ㅎㅎ
2022년 내가 어떤 SSAFY 생활을 했고, 어떻게 놀러 다녔는지(?) 포스팅해보려고 한다!!

1. SSAFY 7기 입학 및 스타트 캠프

SSAFY 7기로 입학하면서 웰컴 키트를 배송받았다! 다른 사람들은 못생긴 파란 후드티를 받았다고 했는데 나는 검정 후드티라서 잠깐 외출할 때도 잘 걸치고 다녔고, 2학기에 캠퍼스로 나갈 때 가지고 다니며 잘 입었다 ㅎㅎ
그리고 SSAFY를 처음 입학하게 되면 스타트 캠프 기간이 있다. 사람들과 해커톤도 하고 간단한(?) 팀플을 하면서 얘기하는 시간을 가지면서 친해질 수 있다. 물론 임시반이라 친해져도 같은 반이 될 수도 있고 다른 반으로 갈릴 수도 있다...!
팀으로 말고 혼자 하는 게임 코딩 시간도 있었는데 간단한 툴을 이용하여 게임을 제작하는 것이었다. 여기서 좋아요 숫자로 상을 줬었는데, 코로나를 주제로 코로나 물리치기 게임을 만들었었는데 게임을 만드는 난이도도 어렵지 않았었기에 수상은 기대하지 않았다. 주제가 시기와 맞아서인지 많은 사람들의 좋아요를 받을 수 있었고 7기에서 1등을 차지해 신세계 상품권 10만 원을 받을 수 있었다!! ㅎㅎ

2. 데스크 꾸미기

SSAFY 이전까지는 사실 장비 욕심 없고 관심도 없던 나였다... 컴공이었지만, 개발자로 취업을 목표하지도 않았고 게임을 즐겨하지도 않았고 그냥 노는 게 제일 좋았었다... 하지만, 개발을 집중적으로 시작하면서 눈을 뜨고 나서부터 눈을 감기 직전까지 컴퓨터 앞에 앉아있었기 때문에 좋은 마우스, 큰 모니터, 키보드는 필수라고 생각했다...
그냥 애플 좋아 인간이었던 나는 (지금도 물론 애플 좋아 인간임.. 맥스까지 산 나 새끼...) 처음엔 트랙패드가 제스처가 편리해서 좋을 것이라고 생각했었다. 그래서 친구들이 졸업선물로 좋은 마우스 사준다고 했을 때 트랙패드를 사달라고 했다... 그때의 나 반성해...
1학기 SSAFY 수업 기간 때, 트랙패드로 하루종일 작업하다가 진짜 손목이 나가는 줄 알았다. PPT 작업부터, 피그마 작업도 다 트랙패드로 했다 ^^ 지금도 트랙패드를 사용하고 있긴 하지만, 옛날처럼 마우스를 많이 쓰는 작업이 없기 때문에 크게 불편함 없이 사용 중이다. 하지만, 마우스로 작업을 많이 하는 사람이라면 트랙패드는 무조건 피해야 한다... 그래도 예쁜 데스크를 원한다면... 맥의 제스처가 편하고 마우스 쓰는 일이 별로 없다면 사는 걸 말리진 않는다 ^^

Magic Trackpad - 화이트 Multi-Touch 표면

배터리가 탑재된 새로운 디자인의 충전식 Magic Trackpad는 데스크탑에서 Force Touch 기능을 사용할 수 있게 해줍니다.

www.apple.com

모니터와 키보드는 지인의 추천을 받아 샀는데 아직까지 매우 만족하며 사용 중이다! 모니터는 벤큐 GW2780 아이케어 27인치를 샀다. 진짜 장비에 관심이 하나도 없어 추천해 준 걸 그냥 알아보지도 않고 샀는데 너무너무 만족 중이다!!! 내가 샀던 링크는 아니지만, 같은 모델 링크를 첨부한다.

[11번가] BenQ GW2780 아이케어 27인치 무결점 IPS페널 모니터

모니터>일반 모니터>67~78cm(27~31인치), 가격 : 194,000원

www.11st.co.kr

키보드는 게임코딩 1등으로 받은 신세계 상품권 10만 원에 내 돈을 보태서 샀다! 맨날 주변 사람들한테 키보드를 자랑할 만큼 키보드는 완전 만족 중이다. 색감도 너무 예쁘고 무엇보다 키감이 미쳤다! 나는 신세계 상품권을 쓰려고 ssg.com에서 샀었는데 지금 검색해 보니 다른 곳에서 조금 더 저렴한 가격에 살 수 있는 것 같다!

웨이코스 토체티 BW D＆T 베이지 체리 (저소음적축)

여기를 눌러 링크를 확인하세요.

www.ssg.com

SSAFY 대면 수업을 위해 대전 연수원 근처에서 자취를 할 땐 정말 좁은 집에서 살아서 책상도 정말 작아서 위 사진처럼 간신히 모든 것들을 욱여넣었다... 지금은 이전 집보다 몇 배는 넓은 방에서 자취를 하고 있기 때문에 데스크도 더 큰 걸로 구매하고, 모니터 암도 사서 좀 더 편안해졌다... (진짜 대전에서 자취하면서 공부할 땐, 너무 좁아서 정신 나가는 줄 알았음...)

내 지금 데스크 자랑하고 싶어서 구구절절 위에서 쓴거다 ㅎㅎ

3. 좋은 사람들과 재미있는 1학기

나는 SSAFY 1학기 과정이 너무 재미있었고, 너무 행복했다. 7기 대전 5반 사람들은 모두가 진짜 가족 같고, 친구 같은 좋은 사람들이었다. 2학기가 되고 캠퍼스에 가면서 다른 반 사람들은 우리 반을 보고 굉장히 부러워했다! 매일 수업이 끝나고 디스코드(내가 채널 주인인 것도 자랑 ㅎㅎ)에 모여 같이 스터디도 하고, 함께 얘기도 하면서 많이 친해졌고, 6월에 여름 MT, 12월에 겨울 MT를 가면서 더 많은 이야기를 나누고 더 가까워졌다! 1학기에 우리 반에서 제일 많은 취업자가 나왔지만, MT를 갈 때면 모두가 모여서 20명씩 MT를 가곤 했다... 대전 5반 최고야 ❤️
나는 독감 걸려서 겨울 MT는 함께하지 못해 함께 찍은 사진은 없지만, 여름 MT 사진은 넘쳐난다 ㅎㅎ 코로나 걸리면 안 된다고 MT 가기 전 자가진단 키트까지 해서 제출하는 열정까지... ㅋㅋㅋ 덕분에 코로나 이슈 없이 조심히 잘 놀다 올 수 있었다!

다른 사진은 없고, 겨울 MT 사진은 이거 두 개가 있다..! 레터링 케이크에 미친 나는... 가지도 못하는 MT였지만, 레터링 케이크를 꼭 하고 싶었다..! 항상 우리를 위해 고생했던 CA 오빠를 위해 깜짝 파티도 해주고 싶었기 때문에 우리 반 모든 사람들의 이름을 적은 레터링 케이크를 주문 제작하여 MT 가는 사람들 편에 보냈다 ㅋㅋㅋ CA 오빠 울리기 대작전이었는데, 울어서 만족 ㅎㅎ
이렇게 CA 오빠를 위한 우리의 깜짝 파티가 있었는데, CA 오빠도 우리를 위한 선물을 준비해 왔다! 한 사람 한 사람 이름을 프린팅 한 소주잔이었다. 소주잔은 너무 귀여웠다...

아무튼, 대전 5반이 SSAFY 중에서 제일 끈끈하고 가족 같은 행복한 반인게 확실하다! 이렇게 좋은 사람들과 함께할 수 있어 너무 행복했고, 앞으로도 좋은 인연 계속 이어가고 싶다!!!

4. 너무 힘들었지만, 알차고 가장 많이 성장한 2학기

SSAFY 2학기 과정은 3번의 프로젝트로 진행된다. 공통, 특화, 자율 프로젝트로 진행되는데 너무너무 빡세고 너무너무 힘들다. 진짜 마감이 다가오면 잠도 제대로 못 자고 프로젝트를 완성해 나간다...
공통 프로젝트를 진행할 때에는 정말 걱정이 많았었다. 갑자기 전공자 비전공자 비율 이슈로 인해 내가 다른 팀으로 갑자기 들어가게 되었는데 그 팀에서 팀장까지 맡게 되었다. 나를 제외한 모두가 극 I들이었기 때문에 처음에 내 말에 대답도 잘 안 해주고 정말 힘들었었다. 하지만, 친해지고 나니 다들 내숭 부린 거였다(?) ㅋㅋㅋ 다들 말도 잘하고 정말 많이 친해져 편해졌다. 내가 막내였는데, 막무가내 팀장이었기도 해서 항상 언니, 오빠들에게 이거 해줘! 저거 해줘! 부탁도 많이 하고, 대답도 많이 해달라고 화(?)도 냈지만, 언니오빠들이 다 착해서 잘 따라줬고, 우리 팀은 싸우지도 않고 재미있게 프로젝트를 잘 마무리했다. (나만 그렇게 생각하는 거 아니지?ㅋㅋㅋㅋ) 그래도 공통 팀원들이 처음 아무것도 모르고 가장 힘들게 프로젝트를 진행해서 하고 서로 의지하며 프로젝트를 해서인지 가장 기억에 남는 것 같다.

GitHub - Kkal-mat-chum/colors: WebRTC를 활용하여 다양한 사람들과 함께 소통하며 개인의 얼굴, 분위기와

WebRTC를 활용하여 다양한 사람들과 함께 소통하며 개인의 얼굴, 분위기와 어울리는 색상을 찾을 수 있는 서비스 개발 - GitHub - Kkal-mat-chum/colors: WebRTC를 활용하여 다양한 사람들과 함께 소통하며

github.com

특화 프로젝트는 새로운 기술 도메인을 학습하고 프로젝트를 완성하는 것까지 총 7주라는 시간이 주어진다. 새로운 걸 공부하고 프로젝트 완성까지 7주밖에 시간이 없어 정말 힘든 프로젝트였다. 나는 IoT 분야에 원래 관심이 많았었기 때문에 원래는 스마트 홈이나 자율주행 도메인을 선택하고 싶었다. 하지만, 여러 내부 사정으로 인해 나는 블록체인 도메인을 선택하게 되었다. 블록체인도 처음, 배포도 처음이라 진짜 모든 게 다 어렵고 힘들었지만 함께 백엔드를 맡아준 오빠도 같이 열심히 프로젝트를 진행하고, 프론트엔드를 맡았던 4명의 언니들도 모두 열심히 참여하여 우리는 반 1등이라는 성적을 거둘 수 있었다!

GitHub - Purgae/Purgae: NFT를 통한 투명한 해양 기부 서비스, 푸르게

NFT를 통한 투명한 해양 기부 서비스, 푸르게. Contribute to Purgae/Purgae development by creating an account on GitHub.

github.com

마지막 자율 프로젝트는 이제까지 배웠던 것들을 종합하여 만들고 싶은 서비스를 만드는 것이었다. 나는 학부 때부터 IoT에 미친 사람이었기 때문에... 그리고 특화 때 IoT를 못한 서러움이 있었기 때문에 자율 프로젝트만큼은 IoT 프로젝트를 하고 싶었다. (다시 돌아간다면 뜯어말리고 싶다) SSAFY에서 지원해 주는 지원금으로 터틀봇과 여러 장비들을 사서 1:1 건강검진 파트너 로봇을 만들었다. 로봇으로만 진행하려다 컨설턴트님의 조언으로 가제보(시뮬레이션)를 추가하여 진행하였는데, 가제보를 사용해 본 사람이 나밖에 없어서 내가 가제보를 맡아서 진행했다. (~~진짜 죽는 줄 알았다... 아니 죽고 싶었다...)~~ SSAFY에서 지원해 주는 노트북 일명 싸트북에 우분투도 깔고 그 안에서 작업을 했는데, 싸트북이 자꾸 죽어서 맵 하나 모델링하는 데도 진짜 거의 울면서 했다... 모델 하나 올리면 자꾸 멈춰서 진짜 싸트북을 내리치고 싶었지만, 싸트북 == 2 SSAFY(2달 SSAFY월급)이었기 때문에 참았다...

GitHub - IoT-gganbu/gganbu: 복잡한 건강검진 절차를 자율주행 기반의 로봇이 수검자가 건강검진을 완

복잡한 건강검진 절차를 자율주행 기반의 로봇이 수검자가 건강검진을 완료할 수 있도록 1:1 안내를 진행하는 IoT 프로젝트입니다. - GitHub - IoT-gganbu/gganbu: 복잡한 건강검진 절차를 자율주행 기반

github.com

특화 프로젝트 상장이랑 자율 프로젝트 때 내 사진들이다... 두 번째는 가제보에 미쳐가던 내게 조립을 시켜줘서 행복하게 조립하던 내 모습이다...ㅋㅋㅋ 마지막 사진은 중간발표 때 사진인데, 우리 조가 마지막 발표였는데 이전까진 질문도 없다가 우리 조 발표 때 10개가 넘는 질문이 쏟아져서 진짜 달달 떨면서 대답해 준 내 모습이다... 진짜 너무 힘들었지만, 알찼던 발표였다...!

사진은 다 없지만, 프로젝트 3번 동안 모두 베스트 팀을 받았고, 마지막 프로젝트에서 베스트 멤버도 되었다! SSAFY 2학기 과정에서 정말 힘든 일도 많았지만, 그만큼 많이 성장한 것 같고 알찼던 것 같다.

5. SSAFY 수료 & 수료식

1학기 800시간, 2학기 800시간 무사히 SSAFY를 수료했다... 당장 취업을 원했던 것도 아니었고, 내가 개발자로 취업하기 위해 성장하고 싶어 지원했던 SSAFY였기 때문에 SSAFY 교육 중에는 취업 지원도 많이 안 하고 정말 SSAFY 교육 과정에 최선을 다했던 것 같다. 이제 취업 준비도 열심히 하고 취업하는 일만 남았다...!

이수증과 마지막 퇴실 인증샷이다!

수료식이 있던 날, 1년 간의 SSAFY 생활을 행복하게 해 주었던 사람들과 사진도 찍었다! 공통 프로젝트 때, 나는 B208 팀이었지만, B209팀과 친해져 아직까지 재밌게 잘 놀고 있다... 그래서 B208.9 팀과 기념사진도 찍었고, 5반 사람들과 함께 사진을 찍었다! 센터 본능 발동한 나는 이날 모든 사진에서 센터에 서있었다(?) 인스타에 올리고 친구가 왜 자꾸 센터에 있냐 해서 알았다...ㅋㅋㅋ
아무튼 이 사람들 덕에 행복하게 SSAFY 생활을 마무리할 수 있었고, 이 사람들이 없었더라면 나는 진짜 중간에 탈주했을지도 모른다... 다들 고마워 ❤️

6. 2022년도 꼴찌지만, 나는 이글스라 행복합니다

2022년은 정말 바빴는데, 직관을 정말 많이 갔다. 홈 개막전부터, 인천, 수원, 마산, 고척, 잠실 원정을 다녔고, 홈 마지막 경기까지 다녀왔다! 맨날 사람들이 꼴찌인데 왜 이렇게 좋아하냐고 물었지만, 이유는 없었다. 그냥 맨날 져도 한 번 이길 때마다 짜릿했고, 내가 직관 갔을 때, 승요를 할 수 있다면 더더욱 행복했다! 올해도 야구장 더 많이 가야지(?) ㅋㅋㅋㅋㅋ 제발 올해는 잘해줘 ㅜㅡㅜ 아니 큰 기대는 안 할게 부상만 당하지 말고 행복하게 야구하자!!! 나는 이글스라 행복(?)해.....

홈 첫경기, 구장이 너무 좋아서 행복했던 인천 원정, 마산까지 가서 보고 온 2022년 찐 막경기

7. 2022년도 여러 사람들과 행복한 한 해였다❤️

2022.02.05.~02.06.
정책과 강릉으로 첫 여행을 다녀왔다! 2019년 총학생회 정책국으로 처음 만나 지금까지 좋은 인연을 이어오고 있다! 항상 서로를 응원해 주고, 서로의 생일이라면 누구보다 열심히(?) 축하해 주면서 꾸준히 만나고 있다. 꾸준히 만나긴 했지만, 여행은 한 번도 못 갔었는데 드디어 정책 첫 여행을 다녀왔다! 맛있는 것도 많이 먹고 사진도 많이 찍고 행복한 추억을 많이 쌓았다 ㅎㅎ

2022.02.18.
드디어 병천 생활을 청산했다... 4년 동안 울고 웃고 많이 정들었던 병천이었지만, 병천 탈출은 행복했다. (이러고 거의 매달 병천 갔었음... 난 병천 없이 못 살아...) 졸업식 때 많은 사람들과 사진도 찍고, 많은 사람들에게 축하도 받아서 너무 행복했다. 4년 동안 덕분에 버틸 수 있었고, 덕분에 무사히 졸업합니다! 다들 감사합니다 ❤️

2022.06.06.~06.11.
알찼던 SSAFY 일주일 방학... 파워 E인 나(MBTI 검사하면 E 100프로 나옴..)는 일주일 동안 천안, 춘천, 대전, 인천, 서울을 돌아다녔다. 친구가 인스타를 켜면 다음날 다른 지역에 있는 나를 보고 정말 홍길동인 줄 알았다고 했다. ㅋㅋㅋㅋ 일주일 밖에 안 되는 방학이었지만, 진짜 너무 행복한 방학이었다!!!

2022.12.12.~12.15.
SSAFY에서 만난 정현언니랑 제주 여행을 다녀왔다! 가기 직전 내가 감기기운이 있어서 코로나인줄 알고 진짜 식겁했다... 몇 년 만에 여행 가는 거였는데 코로나면 너무 억울할 거 같았다. 근데 다행히 코로나는 아니었고, 코찔찔이 상태로 제주 여행을 다녀오게 되었다. 내가 컨디션이 안 좋아서 언니도 힘들어질까 봐 걱정 많이 했었는데 언니가 많이 배려해 줘서 덕분에 편안하고 즐겁게 잘 여행할 수 있었다! 강정현 고마와 사랑햇❤️

2022년에 위에 적은 사람들 말고도 더 많은 사람들과 좋은 시간을 보냈다! 다들 내 옆에서 항상 응원해 주고, 함께 해줘서 고마워요 ❤️

8. 앞, 뒤로 한 달씩 생일인 사람 == 나

올해도 정말 행복한 생일을 보냈다. 많은 사람들이 함께 축하해 주셔서 더욱 행복하게 보낼 수 있었다. SSAFY 생활로 매일 약속을 잡을 순 없었기 때문에 조금씩 만나다 보니까 앞뒤로 한 달 가까이를 생일 파티를 하며 보냈다..! 너무너무 행복했다 ㅎㅎ

나의 귀여운 케이크들 자랑 ㅎㅎ

올해도 많은 사람들의 축하를 받아서 생일선물 언박싱도 엄두도 못 내고 있었다...❤️ 지인이랑 다솔이가 우리 집 집들이를 오면서 같이 도와줘서 거의 뭐 기계처럼 박스를 뜯고 박스를 정리해서 덕분에 선물을 모두 뜯을 수 있었다! 지인 다솔 다시 한번 고마워❤️

9. 마무리

쓰다 보니 정말 길어진 회고지만, 2022년을 되돌아볼 수 있어서 정말 좋았다.
SSAFY를 통해 개발자로서 성장할 수 있는 기회가 된 것 같아 정말 좋았다. 2022년 커밋을 보니 정말 열심히 산 것 같아 뿌듯하다!! 2023년도 취업도 하고 더 열심히 살아야겠다!

sa11k - Overview

sa11k has 10 repositories available. Follow their code on GitHub.

github.com

2022년도 나는 정말 행복한 사람이었다! 좋은 사람들과 함께 좋은 시간을 보낼 수 있어서 행복했다! 다들 고맙고 항상 응원합니다❤️

[백준] 1719번 택배 (JAVA)

다교이 — Thu, 2 Mar 2023 01:03:07 +0900

문제

- 택배 화물이 각 집하장들 사이를 오갈 때, 어떤 경로를 거쳐야 하는지 정해야 함

- 이를 경로표로 정리해야 함

- 경로표에는 한 집하장에서 다른 집하장으로 최단 경로로 화물을 이동시키기 위해 가장 먼저 거쳐야 하는 집하장을 나타냄

해결방법

다익스트라 알고리즘을 활용하여 문제를 해결하였다. 다익스트라 알고리즘에 대한 설명을 아래 포스팅을 확인하면 좋을 것 같다.

[알고리즘] 다익스트라 알고리즘 (Dijkstra Algorithm)

다익스트라 알고리즘 (Dijkstra Algorithm) 개념 - 특정한 한 정점(=노드)에서 출발하여 다른 모든 정점으로 가는 최단 경로를 구하는 알고리즘 - BFS와 DP를 활용한 최단경로 탐색 알고리즘 - DP를 활용

sa11k.tistory.com

다익스트라 기본 코드를 활용하여 문제를 해결하면서, 최단 경로로 확인되었을 때, 이전에 방문한 집하장의 정보를 저장할 수 있도록 2차원 배열 result를 사용하였다. result[][]는 화물을 이동시키기 위해 거쳐야하는 집하장 정보를 저장하는 배열로, 최소 이동 비용을 저장하는 min[] 배열을 update 하면서 같이 update할 수 있도록 하였다.

위 내용을 제외한 기본적인 틀은 다익스트라 기본 코드로 작성하였다. 아래 포스팅된 문제는 기본적인 다익스트라 코드를 익힐 수 있는 문제이다.

[백준] 1753번 최단경로 (JAVA)

문제 - 방향 그래프가 주어짐 - 시작점에서 다른 모든 정점으로의 최단 경로 구하기 - 다익스트라 기본 유형 해결방법 다익스트라 알고리즘을 사용하는 기본적인 유형으로 가중치가 있는 그래프

sa11k.tistory.com

코드

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

// Node class
class Node {
    int end;
    int weight;

    public Node (int end, int weight) {
        this.end = end;
        this.weight = weight;
    }
}

public class Main {
    static int n, m;
    static List<Node>[] list;
    static int[][] result;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        StringBuilder sb = new StringBuilder();

        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());

        list = new List[n+1];		// 집하장 간 경로 list
        result = new int[n][n];		// 경로표
		
        // 집하장 간 경로를 저장할 배열 초기화
        for(int i = 1; i<=n; i++) {
            list[i] = new ArrayList<>();
        }

        for(int i = 0; i<m; i++) {
            st = new StringTokenizer(br.readLine());
            int start = Integer.parseInt(st.nextToken());
            int end = Integer.parseInt(st.nextToken());
            int weight = Integer.parseInt(st.nextToken());
			
            // 단방향이 아니랑 양방향이므로 각각을 저장
            list[start].add(new Node(end, weight));
            list[end].add(new Node(start, weight));
        }
		
        // 1번 집하장부터 n번 집하장까지 최단 경로 검색
        for(int i = 1; i<=n; i++)
            dijkstra(i);
		
        // 경로표 추력
        for(int i = 0; i<n; i++) {
            for(int j = 0; j<n; j++) {
                if (i == j) sb.append("- ");
                else sb.append(result[i][j]).append(" ");
            }
            sb.append("\n");
        }

        System.out.println(sb);
    }
	
    // 다익스트라
    static void dijkstra(int start) {
        boolean[] visit = new boolean[n+1];		// 방문 여부 체크
        int[] min = new int[n+1];			// 최단 경로 값 저장

	// 최단 경로를 저장하기 위해선 MAX 값으로 초기화
        for(int i = 1; i<=n; i++) min[i] = Integer.MAX_VALUE;		

        PriorityQueue<Node> queue = new PriorityQueue<>((o1, o2) -> o1.weight - o2.weight);
        min[start] = 0;				// 시작 집하장은 최단 경로가 0
        queue.add(new Node(start, 0));		// 시작 집하장 queue에 저장

        while (!queue.isEmpty()) {
            Node now = queue.poll();
            // 현재 방문할 정점에 이미 최단 경로로 방문했다면 더이상 방문할 필요 없음
            if(min[now.end] < now.weight) continue;
            if(!visit[now.end]) visit[now.end] = true;		// 방문 처리
            for(int i = 0; i<list[now.end].size(); i++) {
                Node next = list[now.end].get(i);
                // 다음 방문할 정점이 방문하지 않았고, 최단 경로로 방문할 수 있다면
                if(!visit[next.end] && now.weight + next.weight < min[next.end]) {
                    min[next.end] = now.weight + next.weight;		// 최단 경로 값 저장
                    result[next.end-1][start-1] = now.end;		// 경로표 작성
                    queue.add(new Node(next.end, min[next.end]));
                }
            }
        }
    }
}

[백준] 11779번 최소비용 구하기 2 (JAVA)

다교이 — Thu, 2 Mar 2023 00:45:12 +0900

문제

- n개의 도시, m개의 버스

- 버스는 한 도시에서 출발하여 다른 도시에 도착

- A번째 도시에서 B번째 도시까지 가는데 드는 최소 비용과 경로 출력

해결방법

다익스트라 알고리즘을 활용하여 문제를 해결하였다. 다익스트라 알고리즘에 대한 설명은 아래 포스팅을 확인하면 좋을 것 같다.

[알고리즘] 다익스트라 알고리즘 (Dijkstra Algorithm)

sa11k.tistory.com

다익스트라 기본 코드를 활용하여 기본적인 문제 해결 틀을 잡았는데 이 문제에서는 경로도 함께 출력해야 했기 때문에 result_city를 따로 관리해 주었다. result_city라는 배열은 각 정점에 대해서 해당 정점으로 올 때 최소 비용을 가지면 이제까지 왔던 경로에 대해서 저장해 줄 수 있도록 ArrayList로 만들어주었다. dp를 활용해서 이전까지 저장되어 있던 내용들에 현재 정보까지 더하여 update 해주면서 모든 경로를 탐색하였고, 최종적으로 목적지에 도착했을 때 드는 최소 비용과 경로를 출력할 수 있도록 코드를 구성하였다.

다익스트라 기본 코드를 활용하여 해결한 문제의 해설은 아래 포스팅을 확인하면 좋을 것 같다.

[백준] 1753번 최단경로 (JAVA)

sa11k.tistory.com

처음 단순 다익스트라 기본 코드로 문제를 해결하려했을 때, 시간초과 문제가 발생하였다. 해당 문제를 해결하기 위해서는 현재 정점에 대해서 현재 정점을 방문하는데 드는 비용이 이미 최소 비용 배열에 저장된 값보다 크다면, 해당 과정을 건너 뛸 수 있기 때문에 continue 처리를 해주어야 시간초과를 벗어날 수 있다.

if(result_cost[now.end] < now.cost) continue;

코드

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

// Node class
class Node {
    int end;
    int cost;

    public Node(int end, int cost) {
        this.end = end;
        this.cost = cost;
    }
}

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

        int n = Integer.parseInt(br.readLine());        // 도시의 개수
        int m = Integer.parseInt(br.readLine());        // 버스의 개수

        List<Node>[] list = new List[n+1];			// 각 간선에 대한 정보
        boolean[] visited = new boolean[n+1];			// 각 정점에 대한 방문 여부
        List<Integer>[] result_city = new List[n+1];		// 해당 정점을 방문하기 전 방문한 정점
        int[] result_cost = new int[n+1];			// 해당 정점을 방문하기 위한 최소 비용
		
        // 초기화
        for(int i = 1; i<=n; i++) {
            list[i] = new ArrayList<>();
            result_city[i] = new ArrayList<>();
            result_cost[i] = Integer.MAX_VALUE;
        }

        for(int i = 0; i<m; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int start = Integer.parseInt(st.nextToken());
            int end = Integer.parseInt(st.nextToken());
            int cost = Integer.parseInt(st.nextToken());

            list[start].add(new Node(end, cost));
        }

        StringTokenizer st = new StringTokenizer(br.readLine());
        int start = Integer.parseInt(st.nextToken());
        int end = Integer.parseInt(st.nextToken());

	// 다익스트라
        PriorityQueue<Node> queue = new PriorityQueue<>((o1, o2) -> o1.cost - o2.cost);
        result_city[start].add(start);		// 출발 정점에 대한 정보 저장
        result_cost[start] = 0;			// 출발 정점의 최소비용은 0
        queue.add(new Node(start, 0));		// 출발 정점 queue에 추가
		
        while (!queue.isEmpty()) {
            Node now = queue.poll();				// 현재 방문할 정점
            // 현재 방문할 정점에 가는 최소 비용이 이미 저장된 값보다 지금 방문하려고 할 때 드는 비용이 더 크다면 pass
            if(result_cost[now.end] < now.cost) continue;
            if(!visited[now.end]) visited[now.end] = true;	// 현재 방문할 정점 방문 처리
            // 현재 방문할 정점에서 이동할 수 있는 정점에 대하여 조사
            for(int i = 0; i<list[now.end].size(); i++) {
                Node next = list[now.end].get(i);		// 다음 방문할 정점
                // 다음 방문할 정점이 방문하지 않았고, 최소 비용이 든다면
                if(!visited[next.end] && now.cost + next.cost <= result_cost[next.end]) {
                    result_cost[next.end] = now.cost + next.cost;	// 비용 Update
                    result_city[next.end].clear();			// 현재까지 이동했던 좌표들에 대한 내용 clear
                    // 이제까지 이동했던 내용에 대해서 다시 update
                    for(int j = 0; j<result_city[now.end].size(); j++) {
                        result_city[next.end].add(result_city[now.end].get(j));
                    }
                    // 다음 좌표까지 update
                    result_city[next.end].add(next.end);
                    // queue에 방문할 정점 추가
                    queue.add(new Node(next.end, result_cost[next.end]));
                }
            }
        }
		
        // 출력
        sb.append(result_cost[end]).append("\n").append(result_city[end].size()).append("\n");
        for(int i = 0; i<result_city[end].size(); i++) {
            sb.append(result_city[end].get(i) + " ");
        }

        System.out.println(sb);
    }
}

[알고리즘] 다익스트라 알고리즘 (Dijkstra Algorithm)

다교이 — Thu, 2 Mar 2023 00:09:45 +0900

다익스트라 알고리즘 (Dijkstra Algorithm)

개념

- 특정한 한 정점(=노드)에서 출발하여 다른 모든 정점으로 가는 최단 경로를 구하는 알고리즘

- BFS와 DP를 활용한 최단경로 탐색 알고리즘

- DP를 활용하는 이유는 최단 거리를 구할 때 그 이전까지 구했던 최단 거리 정보를 그대로 활용하기 때문

- 그래프의 간선마다 가중치가 존재할 때 사용 (음의 가중치는 존재하지 않음)

구현

- 최단 거리 테이블 MAX 값으로 초기화 (최단 거리를 저장해야 하므로 큰 수로 초기화 시킴)

- 출발 노드 설정

- 방문하지 않은 노드 중에서 최단 거리(가중치)가 가장 짧은 노드 선택

- 해당 노드를 거쳐 다른 노드로 이동하는 비용을 계산하여 최단 거리 테이블 갱신

- 계속해서 가중치가 가장 짧은 노드를 선택하면서 최단 거리 테이블 갱신

- 현재 노드로의 최단거리가 현재 가중치보다 작다면 update할 이유가 없으므로 continue ⭐️ (이 한 줄로 심화문제 풀 때, 시간초과 해결 가능..)

if(min[now.end] < now.weight) continue;

- 매번 최단 거리 테이블을 모든 원소를 탐색하는 방법이 있지만, 우선순위 큐를 사용하면 단순 탐색보다 시간 복잡도를 줄일 수 있음

코드

가장 기본적인 다익스트라 코드로 해결할 수 있는 백준 1753번 문제이다.

1753번: 최단경로

첫째 줄에 정점의 개수 V와 간선의 개수 E가 주어진다. (1 ≤ V ≤ 20,000, 1 ≤ E ≤ 300,000) 모든 정점에는 1부터 V까지 번호가 매겨져 있다고 가정한다. 둘째 줄에는 시작 정점의 번호 K(1 ≤ K ≤ V)가

www.acmicpc.net

이 문제에 대한 풀이는 아래 포스팅한 글에 자세히 작성해두었다.

[백준] 1753번 최단경로 (JAVA)

sa11k.tistory.com

[백준] 1753번 최단경로 (JAVA)

다교이 — Thu, 2 Mar 2023 00:09:22 +0900

문제

- 방향 그래프가 주어짐

- 시작점에서 다른 모든 정점으로의 최단 경로 구하기

- 다익스트라 기본 유형

해결방법

다익스트라 알고리즘을 사용하는 기본적인 유형으로 가중치가 있는 그래프에서 최단경로를 찾는 문제였다. 주어진 간선 정보를 저장하기 위해 각 정점에서 출발하는 간선에 대한 정보를 list에 저장하였고, 각 정점에 도착할 수 있는 최단 경로의 값을 result 배열에 저장하였다. 큐에 출발점부터 이어지는 정점들 중 최단거리로 이동할 수 있도록 넣어가면서 비교하여 최단거리를 구할 수 있도록 코드를 구성하였다.

다익스트라에 대한 자세한 설명은 아래 포스팅에서 확인할 수 있다.

[알고리즘] 다익스트라 알고리즘 (Dijkstra Algorithm)

sa11k.tistory.com

코드

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

// 노드 class
class Node {
    int end;
    int weight;

    public Node(int end, int weight) {
        this.end = end;
        this.weight = weight;
    }
}

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

        int V = Integer.parseInt(st.nextToken());
        int E = Integer.parseInt(st.nextToken());
        int K = Integer.parseInt(br.readLine());

        boolean[] visit = new boolean[V+1];     // 방문 처리 배열
        int[] result = new int[V+1];            // 최단 경로 값 저장 배열
        List<Node>[] list = new List[V+1];      // 연결 정보 저장 배열
		
        // 연결 정보 저장할 배열, 최단 경로 값 저장 배열 초기화
        for(int i = 1; i<=V; i++) {
            list[i] = new ArrayList<>();
            result[i] = Integer.MAX_VALUE;
        }

        for(int i = 0; i<E; i++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());       // 출발
            int v = Integer.parseInt(st.nextToken());       // 도착
            int w = Integer.parseInt(st.nextToken());       // 가중치

            list[u].add(new Node(v, w));
        }

        // 다익스트라
        PriorityQueue<Node> queue = new PriorityQueue<>((o1, o2) -> o1.weight - o2.weight);
        result[K] = 0;
        queue.add(new Node(K, 0));

        while(!queue.isEmpty()) {
            Node now = queue.poll();		// 현재 방문 정점
            if(!visit[now.end]) visit[now.end] = true;		// 방문처리
            // 현재 정정과 연결된 간선들에 대해 판단
            for(int i = 0; i<list[now.end].size(); i++) {
            	// 현재 정점에서 이어질 다음 정점
                Node next = list[now.end].get(i);
                // 다음 정점이 방문하지 않았고, 
                // 현재 가중치 + 해당 정점으로 향하는 가중치 값 < 해당 정점으로의 최단 경로 값이라면
                if(!visit[next.end] && now.weight + next.weight < result[next.end]) {
                    // 해당 정점으로의 최단 경로 값 Update
                    result[next.end] = now.weight + next.weight;
                    // 다음 방문할 예정이므로 queue에 넣어주기
                    queue.add(new Node(next.end, result[next.end]));
                }
            }
        }
		
        // 출력
        for(int i = 1; i<=V; i++) {
            if(result[i] == Integer.MAX_VALUE) System.out.println("INF");
            else System.out.println(result[i]);
        }
    }
}

[백준] 15683번 감시 (JAVA)

다교이 — Wed, 1 Mar 2023 16:19:52 +0900

문제

- 사무실에 총 K개의 CCTV가 설치되어 있음

- CCTV는 5가지 종류

- CCTV는 감시할 수 있는 방향에 있는 칸 전체를 감시할 수 있음

- 사무실에 벽이 있는데 CCTV는 벽을 통과할 수 없음

- CCTV가 감시할 수 없는 영역은 사각지대

- CCTV는 회전할 수 있는데, 항상 90도 방향으로 해야 하며, 감시하려고 하는 방향이 가로 또는 세로 방향이어야 함

- 0은 빈칸, 6은 벽, 1~5는 CCTV를 나타냄

- CCTV의 방향을 적절히 정해서, 사각 지대의 최소 크기를 구하기

해결방법

처음에는 그리디 방식으로 각 CCTV에서 감시할 수 있는 최대의 칸을 감시할 수 있도록 코드를 작성하였다. 하지만, 더 나은 방법으로 감시할 수 있는 방향이 있었다. 예를 들어 (0, 0)부터 CCTV에서 최대의 칸을 감시하기를 시작했다면, (0, 5)에 있는 CCTV가 바라볼 수 있는 방향이 여러가지인데 최적의 방향을 찾아 최대로 감시하고 나중에 (3, 5)에 있는 CCTV가 감시할 수 있는 방향을 찾아야 하는데, 벽에 가려지고 감시할 수 있는 방향이 이미 감시되고 있는 방향이라면 추가로 더 감시할 수 있는 부분이 없어진다. 실제로는 나중에 나온 CCTV가 먼저 그 방향을 감시하고 이전에 나온 CCTV가 다른 방향으로 감시를 해야 더 적은 사각 지대를 만들 수 있는 것이다.

1) 틀린 코드 - 각 CCTV에서 감시할 수 있는 최대의 칸을 감시하도록 작성한 코드

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

public class Main {
    static int N, M, result;
    static int[][] room;
    static boolean[][] cctv;
    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());
        result = N*M;

        room = new int[N][M];
        cctv = new boolean[N][M];

        for(int i = 0; i<N; i++) {
            st = new StringTokenizer(br.readLine());
            for(int j = 0; j<M; j++) {
                room[i][j] = Integer.parseInt(st.nextToken());
                if(room[i][j] != 0) result--;
            }
        }

        for(int i = N-1; i>=0; i--) {
            for(int j = M-1; j>=0; j--) {
                if(room[i][j] != 0)
                    result -= checkCCTV(i, j, room[i][j]);
            }
        }

        System.out.println(result);

    }

    // 각 위치에서 상우하좌 cctv 범위 구하기
    // 상
    static int checkTop(int i, int j, boolean check) {
        int count = 0;
        for(int top = i-1; top>=0; top--) {
            if(room[top][j] == 6) return count;
            if(room[top][j] != 0) continue;
            if(!check) count++;
            else {
                count++;
                room[top][j] = -1;
            }
        }
        return count;
    }

    // 우
    static int checkRight(int i, int j, boolean check) {
        int count = 0;
        for(int right = j+1; right<M; right++) {
            if(room[i][right] == 6) return count;
            if(room[i][right] != 0) continue;
            if(!check) count++;
            else {
                count++;
                room[i][right] = -1;
            }
        }
        return count;
    }

    // 하
    static int checkDown(int i, int j, boolean check) {
        int count = 0;
        for(int down = i+1; down<N; down++) {
            if(room[down][j] == 6) return count;
            if(room[down][j] != 0) continue;
            if(!check) count++;
            else {
                count++;
                room[down][j] = -1;
            }
        }
        return count;
    }

    // 좌
    static int checkLeft(int i, int j, boolean check) {
        int count = 0;
        for(int left = j-1; left>=0; left--) {
            if(room[i][left] == 6) return count;
            if(room[i][left] != 0) continue;
            if(!check) count++;
            else {
                count++;
                room[i][left] = -1;
            }
        }
        return count;
    }

    static int checkCCTV(int i, int j, int CCTV) {
        int max = 0;
        int maxDirection = 0;
        switch (CCTV) {
            case 1:
                // 상(0)
                int top = checkTop(i, j, false);
                if(max <= top) max = top;

                // 우(1)
                int right = checkRight(i, j, false);
                if(max <= right){
                    max = right;
                    maxDirection = 1;
                }

                // 하(2)
                int down = checkDown(i, j, false);
                if(max <= down) {
                    max = down;
                    maxDirection = 2;
                }

                // 좌(3)
                int left = checkLeft(i, j, false);
                if(max <= left) {
                    max = left;
                    maxDirection = 3;
                }

                // 해당하는 부분 색칠
                if(maxDirection == 0) checkTop(i, j, true);
                else if(maxDirection == 1) checkRight(i, j, true);
                else if(maxDirection == 2) checkDown(i, j, true);
                else if(maxDirection == 3) checkLeft(i, j, true);

                break;

            case 2 :
                // 상하(0)
                top = checkTop(i, j, false);
                down = checkDown(i, j, false);
                if(max <= top+down) max = top + down;

                // 좌우(1)
                left = checkLeft(i, j, false);
                right = checkRight(i, j, false);
                if(max <= left + right) {
                    max = left + right;
                    maxDirection = 1;
                }

                // 해당하는 부분 색칠
                if(maxDirection == 0) {
                    checkTop(i, j, true);
                    checkDown(i, j, true);
                } else {
                    checkLeft(i, j, true);
                    checkRight(i, j, true);
                }

                break;

            case 3 :
                // 상우(0)
                top = checkTop(i, j, false);
                right = checkRight(i, j, false);
                if(max <= top + right) max = top + right;

                // 우하(1)
                right = checkRight(i, j, false);
                down = checkDown(i, j, false);
                if(max <= right + down) {
                    max = right + down;
                    maxDirection = 1;
                }

                // 하좌(2)
                down = checkDown(i, j, false);
                left = checkLeft(i, j, false);
                if(max <= down + left) {
                    max = down + left;
                    maxDirection = 2;
                }

                // 좌상(3)
                left = checkLeft(i, j, false);
                top = checkTop(i, j, false);
                if(max <= left + top) {
                    max = left + top;
                    maxDirection = 3;
                }

                // 해당하는 부분 색칠
                if(maxDirection == 0) {
                    checkTop(i, j, true);
                    checkRight(i, j, true);
                } else if(maxDirection == 1) {
                    checkRight(i, j, true);
                    checkDown(i, j, true);
                } else if(maxDirection == 2) {
                    checkDown(i, j, true);
                    checkLeft(i, j, true);
                } else if(maxDirection == 3) {
                    checkLeft(i, j, true);
                    checkTop(i, j, true);
                }

                break;

            case 4 :
                // 좌우상(0)
                left = checkLeft(i, j, false);
                right = checkRight(i, j, false);
                top = checkTop(i, j, false);
                if(max <= left + right + top) max = left + right + top;

                // 좌우하(1)
                left = checkLeft(i, j, false);
                right = checkRight(i, j, false);
                down = checkDown(i, j, false);
                if(max <= left + right + down) {
                    max = left + right + down;
                    maxDirection = 1;
                }

                // 상하우(2)
                top = checkTop(i, j, false);
                down = checkDown(i, j, false);
                right = checkRight(i, j, false);
                if(max <= top + down + right) {
                    max = top + down + right;
                    maxDirection = 2;
                }

                // 상하좌(3)
                top = checkTop(i, j, false);
                down = checkDown(i, j, false);
                left = checkLeft(i, j, false);
                if(max <= top + down + left) {
                    max = top + down + left;
                    maxDirection = 3;
                }

                // 해당하는 부분 색칠
                if(maxDirection == 0) {
                    checkLeft(i, j, true);
                    checkRight(i, j, true);
                    checkTop(i, j, true);
                } else if(maxDirection == 1) {
                    checkLeft(i, j, true);
                    checkRight(i, j, true);
                    checkDown(i, j, true);
                } else if(maxDirection == 2) {
                    checkTop(i, j, true);
                    checkDown(i, j, true);
                    checkRight(i, j, true);
                } else if(maxDirection == 3) {
                    checkTop(i, j, true);
                    checkDown(i, j, true);
                    checkLeft(i, j, true);
                }

                break;

            case 5 :
                max = checkTop(i, j, true)
                        + checkDown(i, j, true)
                        + checkLeft(i, j, true)
                        + checkRight(i, j, true);

                break;

            case 6 :
                max = 0;

                break;

        }
        return max;
    }
}

위 방법으로 해결하지 못한 부분을 해결하기 위해 순열을 생각해보았다. 각 CCTV별로 바라볼 수 있는 방향의 경우에 따라 사각지대의 수가 달라지기 때문에 각 CCTV별 경우의 수 중에서 순열로 선택하고 그 경우에 따라 사각지대를 계산해보는 것이다.

1번 CCTV는 한 방향만을 감시하고 있기 때문에 (상, 우, 하, 좌) 4개의 방향 중 한 방향을 선택해서 감시해야 한다.

2번 CCTV는 양 방향을 감시하고 있기 때문에 (상하, 좌우) 2개의 방향 중 한 방향을 선택해서 감시해야 한다.

3번 CCTV는 90도로 감시하고 있기 때문에 (상우, 우하, 하좌, 좌상) 4개의 방향 중 한 방향을 선택해서 감시해야 한다.

4번 CCTV는 세 방향을 감시하고 있기 때문에 (좌상우, 상우하, 우하좌, 하좌상) 4개의 방향 중 한 방향을 선택해서 감시해야 한다.

5번 CCTV는 네 방향을 감시하고 있기 때문에 경우의 수는 1가지로 네 방향을 감시할 수 있다.

따라서 각 CCTV 정보가 주어졌을 때, 어떤 방향으로 선택할지를 경우의 수를 다 뽑아보고, 그 경우에 따라 사각지대를 구해 최소 값을 찾아낼 수 있도록 코드를 구성하였다.

코드

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

public class Main {
    static int N, M, maxCCTV, result;
    static int[] cctvDirCnt;
    static int[][] room;
    static boolean[][] cctv;
    static List<CCTV> cctvList;
	
    // CCTV class
    static class CCTV {
        int i;
        int j;
        int cctvNum;

        public CCTV(int i, int j, int cctvNum) {
            this.i = i;
            this.j = j;
            this.cctvNum = cctvNum;
        }
    }
    
    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());
        maxCCTV = Integer.MIN_VALUE;	// CCTV가 감시할 수 있는 최대 범위
        result = N*M;		// 정답 저장 변수

        room = new int[N][M];
        cctv = new boolean[N][M];
        cctvList = new ArrayList<>();

        for(int i = 0; i<N; i++) {
            st = new StringTokenizer(br.readLine());
            for(int j = 0; j<M; j++) {
                room[i][j] = Integer.parseInt(st.nextToken());
                if(room[i][j] != 0) {
                    result--;		// CCTV가 위치하는 곳은 사각지대가 아님
                    // 벽을 제외하고 CCTV 정보로 등록
                    if(room[i][j] != 6) {
                        cctvList.add(new CCTV(i, j, room[i][j]));
                    }
                }
            }
        }
		
        cctvDirCnt = new int[cctvList.size()];
        cctvDirection(0);
        System.out.println(result-maxCCTV);

    }

    // 각 위치에서 상우하좌 cctv 범위 구하기
    // 상
    static int checkTop(int i, int j, boolean check) {
        int count = 0;
        for(int top = i-1; top>=0; top--) {
            if(room[top][j] == 6) return count;
            if(check) {
                if(room[top][j] > 0) continue;
                if(room[top][j] == 0) count++;
                room[top][j] -= 1;
            }
            else {
                count++;
                if(room[top][j] < 0) room[top][j] += 1;
            }
        }
        return count;
    }

    // 우
    static int checkRight(int i, int j, boolean check) {
        int count = 0;
        for(int right = j+1; right<M; right++) {
            if(room[i][right] == 6) return count;
            if(check) {
                if(room[i][right] > 0) continue;
                if(room[i][right] == 0) count++;
                room[i][right] -= 1;
            }
            else {
                count++;
                if(room[i][right] < 0) room[i][right] += 1;
            }
        }
        return count;
    }

    // 하
    static int checkDown(int i, int j, boolean check) {
        int count = 0;
        for(int down = i+1; down<N; down++) {
            if(room[down][j] == 6) return count;
            if(check) {
                if(room[down][j] > 0) continue;
                if(room[down][j] == 0)count++;
                room[down][j] -= 1;
            }
            else {
                count++;
                if(room[down][j] < 0) room[down][j] += 1;
            }
        }
        return count;
    }

    // 좌
    static int checkLeft(int i, int j, boolean check) {
        int count = 0;
        for(int left = j-1; left>=0; left--) {
            if(room[i][left] == 6) return count;
            if(check) {
                if(room[i][left] > 0) continue;
                if(room[i][left] == 0) count++;
                room[i][left] -= 1;
            }
            else {
                count++;
                if(room[i][left] < 0) room[i][left] += 1;
            }
        }
        return count;
    }

    // CCTV 방향 순열로 선택 후 감시 영역 파악하는 함수
    static void cctvDirection(int cnt) {
    	// CCTV 방향을 모두 선택했다면
        if(cnt == cctvList.size()) {
            int sum = 0;
            // 감시 영역 파악
            for(int i = 0; i<cctvList.size(); i++) {
                sum += cctvDirCnt[i];
            }
            // 감시 영역이 최대가 되어야 사각지대가 최소가 됨
            maxCCTV = Math.max(maxCCTV, sum);
            return;
        }
		
        // CCTV 번호에 따라서 감시할 수 있는 방향의 경우의 수가 다름
        switch (cctvList.get(cnt).cctvNum) {
            // CCTV 1번
            case 1:
            	// 상 우 하 좌 4가지의 경우의 수 (순열)
                for(int i = 0; i<4; i++) {
                    // 뽑았을 때 확인 후
                    if(i == 0) cctvDirCnt[cnt] = checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    else if(i == 1) cctvDirCnt[cnt] = checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    else if(i == 2) cctvDirCnt[cnt] = checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    else if(i == 3) cctvDirCnt[cnt] = checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    // 이후 과정 진행
                    cctvDirection(cnt+1);
                    // 다른 방향을 선택하기 위해 뽑았던 것 되돌리기
                    if(i == 0) checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    else if(i == 1) checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    else if(i == 2) checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    else if(i == 3) checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                }
                break;
			
            // CCTV 2번
            case 2:
            	// 상하 좌우 2가지의 경우의 수 (순열)
                for(int i = 0; i<2; i++) {
                    // 뽑았을 때 확인 후
                    if(i == 0) {
                        cctvDirCnt[cnt] = checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    }
                    else if(i == 1) {
                        cctvDirCnt[cnt] = checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    }
                    // 이후 과정 진행
                    cctvDirection(cnt+1);
                    // 다른 방향을 선택하기 위해 뽑았던 것 되돌리기
                    if(i == 0) {
                        checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    }
                    else if(i == 1) {
                        checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    }
                }
                break;
			
            // CCTV 3번
            case 3:
            	// 상우 우하 하좌 좌상 4가지의 경우의 수 (순열)
                for(int i = 0; i<4; i++) {
                    // 뽑았을 때 확인 후
                    if(i == 0) {
                        cctvDirCnt[cnt] = checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    }
                    else if(i == 1) {
                        cctvDirCnt[cnt] = checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    }
                    else if(i == 2) {
                        cctvDirCnt[cnt] = checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    }
                    else if(i == 3) {
                        cctvDirCnt[cnt] = checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    }
                    // 이후 과정 진행
                    cctvDirection(cnt+1);
                    // 다른 방향을 선택하기 위해 뽑았던 것 되돌리기
                    if(i == 0) {
                        checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    }
                    else if(i == 1) {
                        checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    }
                    else if(i == 2) {
                        checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    }
                    else if(i == 3) {
                        checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    }
                }
                break;
			
            // CCTV 4번
            case 4:
            	// 좌상우 상우하 우하좌 하좌상 4가지의 경우의 수 (순열)
                for(int i = 0; i<4; i++) {
                    // 뽑았을 때 확인 후
                    if(i == 0) {
                        cctvDirCnt[cnt] = checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    }
                    else if(i == 1) {
                        cctvDirCnt[cnt] = checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    }
                    else if(i == 2) {
                        cctvDirCnt[cnt] = checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    }
                    else if(i == 3) {
                        cctvDirCnt[cnt] = checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                        + checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                    }
                    // 이후 과정 진행
                    cctvDirection(cnt+1);
                    // 다른 방향을 선택하기 위해 뽑았던 것 되돌리기
                    if(i == 0) {
                        checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    }
                    else if(i == 1) {
                        checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    }
                    else if(i == 2) {
                        checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    }
                    else if(i == 3) {
                        checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                        checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                    }
                }
                break;

	    // CCTV 5번
            case 5:
            	// 상우하좌 1가지의 경우의 수 뽑았을 때 확인 후
                cctvDirCnt[cnt] = checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                + checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                + checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, true)
                                + checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, true);
                // 이후 과정 진행
                cctvDirection(cnt+1);
                // 다른 방향을 선택하기 위해 뽑았던 것 되돌리기
                checkTop(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                checkRight(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                checkDown(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                checkLeft(cctvList.get(cnt).i, cctvList.get(cnt).j, false);
                break;
        }

    }
}

[백준] 9205번 맥주 마시면서 걸어가기 (JAVA)

다교이 — Tue, 28 Feb 2023 19:08:03 +0900

문제

- 상근이네 집에서 맥주 한 박스 들고 출발

- 맥주 한 박스에는 맥주가 20개 들어있음

- 50미터에 한 병씩 마실 것임 (50미터 가기 직전에 맥주 한 병을 마셔야 함)

- 가는 길에 맥주를 더 구매해야 할 수도 있음

- 편의점에 들렀을 때, 빈 병은 버리고 새 맥주 병을 살 수 있음

- 박스에 들어있는 맥주는 20병을 넘을 순 없음

- 편의점을 나선 직후에도 50미터를 가기 전에 맥주 한 병을 마셔야 함

- 상근이가 행복하게 목적지까지 도착할 수 있으면 "happy", 중간에 맥주가 바닥나서 더 이동할 수 없으면 "sad"를 출력

해결방법

맥주가 20병 있는데 1병 당 50미터를 이동할 수 있기 때문에 현재 좌표부터 다음 좌표(편의점 or 목적지)까지 1000미터 이내여야 이동이 가능하다. 따라서 현재 좌표부터 다음 좌표까지 거리를 확인하면서 이동할지를 확인한다.

코드

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

// 좌표 class
class Node {
    int i;
    int j;

    public Node(int i, int j) {
        this.i = i;
        this.j = j;
    }
}

public class Main {
    static int N;
    static Node sNode, fNode;
    static List<Node> list;
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());

        for(int tc = 1; tc<=T; tc++) {
            list = new ArrayList<>();
            N = Integer.parseInt(br.readLine());
            for(int i = 0; i<N+2; i++) {
                StringTokenizer st = new StringTokenizer(br.readLine());
                // 출발 위치
                if(i == 0)
                    sNode = new Node(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
                // 도착 위치
                else if(i == N+1)
                    fNode = new Node(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()));
                // 중간 편의점 위치
                else
                    list.add(new Node(Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken())));
            }
	    // 이동
            BFS();
        }
    }

    static void BFS() {
        Queue<Node> queue = new LinkedList<>();			// 이동 좌표 저장
        boolean[] visited = new boolean[N];			// 방문 처리
        queue.add(sNode);					// 출발 위치 저장
        while (!queue.isEmpty()) {
            Node now = queue.poll();		// 현재 위치
            // 현재 위치에서 도착 위치까지 1000미터 이내라면 행복하게 도착할 수 있음
            if(Math.abs(now.i - fNode.i) + Math.abs(now.j - fNode.j) <= 1000) {
                System.out.println("happy");
                return;
            }
	    // 편의점 방문
            for(int i = 0; i<N; i++) {
            	// 이제까지 방문했던 편의점인지 확인
                if(!visited[i]) {
                    // 다음 위치
                    Node next = list.get(i);
                    // 현재 위치에서 다음 편의점의 위치까지 1000미터 이내라면 편의점을 방문할 수 있음
                    if(Math.abs(now.i - next.i) + Math.abs(now.j - next.j) <= 1000) {
                        visited[i] = true;		// 방문처리
                        queue.add(next);		// 다음 방문 장소로 이동 좌표 저장
                    }
                }
            }
        }
	// 결국 도착하지 못했다면 "sad" 출력
        System.out.println("sad");
        return;
    }
}

[백준] 5427번 불 (JAVA)

다교이 — Mon, 27 Feb 2023 22:57:31 +0900

문제

- 상근이는 빈 공간과 벽으로 이루어진 건물에 갇힘

- 건물의 일부에 불이 났고, 상근이는 출구를 향해 뛰는 중

- 매 초마다, 불은 동서남북 방향으로 인접한 빈 공간으로 퍼져나감

- 벽에는 불이 붙지 않음

- 상근이는 동서남북 인접한 칸으로 이동 가능. 1초 걸림

- 상근이는 벽을 통과할 수 없고, 불이 옮겨진 칸 / 이제 불이 붙으려는 칸으로 이동할 수 없음

- 상근이가 있는 칸에 불이 옮겨옴과 동시에 다른 칸으로 이동할 수 있음

- 빌딩의 지도가 주어졌을 때, 얼마나 빨리 빌딩을 탈출할 수 있는지 구하기

- '.' : 빈공간 / '#' : 벽 / '@' : 상근이의 시작 위치 / '*' : 불

- 탈출할 수 없는 경우에는 "IMPOSSIBLE" 출력

해결방법

탈출을 위한 escape 함수와 불이 번지는 burn 함수를 따로 구현하여 문제를 해결하였다. 1초마다 불도 번지고 탈출을 위해 상근이가 움직여야했기 때문에 escape 함수 내에서 burn 함수를 호출해주었다. 각 함수(탈출, 불 번짐)에서는 상우하좌로 뻗어나갈 수 있도록 코드를 구성하였다.

코드

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

// 좌표 class
class Node {
    int i;
    int j;

    public Node(int i, int j) {
        this.i = i;
        this.j = j;
    }
}

public class Main {
    static int w, h, nowI, nowJ;
    static char[][] map;
    static Queue<Node> fire;
    static boolean[][] visited;
    static StringBuilder sb = new StringBuilder();

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

        int T = Integer.parseInt(br.readLine());

        for(int tc = 1; tc<=T; tc++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            w = Integer.parseInt(st.nextToken());
            h = Integer.parseInt(st.nextToken());
            map = new char[h][w];
            fire = new LinkedList<>();

            for(int i = 0; i<h; i++) {
                String s = br.readLine();
                for(int j = 0; j<w; j++) {
                    map[i][j] = s.charAt(j);
                    // 상근이의 위치
                    if(map[i][j] == '@') {
                        nowI = i;
                        nowJ = j;
                    }
                    // 불의 위치
                    else if(map[i][j] == '*') {
                        fire.add(new Node(i, j));		// 불 리스트에 저장해 줌
                    }
                }
            }
	    // 현재 위치부터 탈출 시작
            escape(nowI, nowJ);
        }
        System.out.println(sb);
    }
	
    public static void escape(int nowI, int nowJ) {
        Queue<Node> queue = new LinkedList<>();
        visited = new boolean[h][w];
        visited[nowI][nowJ] = true;
        queue.add(new Node(-1, -1));		// 불을 퍼뜨리기 위해 큐에 (-1, -1) 넣어줌
        queue.add(new Node(nowI, nowJ));	// 현재 상근이의 위치 큐에 넣어줌
        int time = -1;

        while (!queue.isEmpty()) {
            Node now = queue.poll();
			
            // (-1, -1)일 때, 불 번짐 함수 호출
            if(now.i == -1 && now.j == -1) {
                burn();		// 불 퍼뜨리기
                // 큐가 비어있지 않으면 다시 또 상근이가 움직일 것이고, 그 때마다 불도 함께 퍼져야 하므로
                if(!queue.isEmpty()) {
                    // (-1, -1) 다시 큐에 추가
                    queue.add(now);
                }
                // 1초 증가
                time++;
                continue;
            }
			
            // 상 우 하 좌
            int[] di = {1, 0, -1, 0};
            int[] dj = {0, 1, 0, -1};

            for(int d = 0; d<4; d++) {
                int ni = now.i + di[d];
                int nj = now.j + dj[d];
				
                // 범위를 벗어나면 상근이가 건물 밖으로 탈출한 것이므로 StringBuilder에 걸린 시간 저장 후 함수 탈출
                if(ni >= h || nj >= w || ni < 0 || nj <0) {
                    sb.append(time+1).append("\n");
                    return;
                }
				
                // 상근이가 접근할 수 있는 곳이라면 큐에 저장
                if(map[ni][nj] == '.' && !visited[ni][nj]) {
                    queue.add(new Node(ni, nj));
                    visited[ni][nj] = true;
                }
            }
        }
	// 탈출 실패했다면 "IMPOSSIBLE" StringBuilder에 저장
        sb.append("IMPOSSIBLE\n");
    }
	
    // 불 번짐 함수
    public static void burn() {
        int size = fire.size();		// 현재 번질 수 있는 불의 개수

        for(int i = 0; i<size; i++) {
            Node now = fire.poll();
			
            // 해당 불의 상 우 하 좌로 불 번짐
            int[] di = {1, 0, -1, 0};
            int[] dj = {0, 1, 0, -1};

            for(int d = 0; d<4; d++) {
                int ni = now.i + di[d];
                int nj = now.j + dj[d];
				
                // 불이 번질 수 있는 위치에 있다면 불 번짐
                if(ni >= 0 && nj >= 0 && ni < h && nj <w && (map[ni][nj] == '.' || map[ni][nj] == '@')) {
                    fire.add(new Node(ni, nj));
                    map[ni][nj] = '*';
                }
            }
        }
    }
}

[백준] 1926번 그림 (JAVA)

다교이 — Mon, 27 Feb 2023 00:55:26 +0900

문제

- 큰 도화지에 그림이 그려져 있을 때, 그 그림의 개수와 그 그림 중 넓이가 가장 넓은 것의 넓이 출력

- 그림이라는 것은 1로 연결된 것을 한 그림이라고 정의

- 가로나 세로로 연결된 것은 연결이 된 것

- 대각선으로 연결이 된 것은 떨어진 그림

- 그림의 넓이란 그림에 포함된 1의 개수

해결방법

BFS를 활용하여 도화지를 탐색할 수 있도록 하였다. 상, 우, 하, 좌 순서로 각 위치에서 더 뻗어나갈 수 있는 위치를 탐색하였다. 뻗어나가면서 그림의 크기를 구해주었고, 최대 그림의 크기를 비교하면서 update 할 수 있도록 하였다. BFS 코드가 호출될 때는 그림 하나가 그려지는 것이기 때문에 BFS 함수 하단 부분에서 그림의 개수를 update 할 수 있도록 하였다.

코드

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

// 그림이 그려진 좌표를 위한 class
class Node {
    int i;
    int j;

    public Node(int i, int j) {
        this.i = i;
        this.j = j;
    }
}

public class Main {
    static int n, m, cnt, maxSize;
    static int[][] image;			// 도화지 배열
    static boolean[][] 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());
        image = new int[n][m];
        visited = new boolean[n][m];

        for(int i = 0; i<n; i++) {
            st = new StringTokenizer(br.readLine());
            for(int j = 0; j<m; j++) {
                image[i][j] = Integer.parseInt(st.nextToken());
            }
        }
		
        for(int i = 0; i<n; i++) {
            for(int j = 0; j<m; j++) {
            	// 그림이 그려져있는데 방문하지 않았다면 BFS 탐색 시작
                if(image[i][j] == 1 && !visited[i][j]) {
                    BFS(i, j);
                }
            }
        }
		
        // 그림 개수 출력
        System.out.println(cnt);
        // 그림 중 넓이가 가장 넓은 것의 넓이 출력
        System.out.println(maxSize);
    }
	
    // 그림 탐색
    public static void BFS(int i, int j) {
        Queue<Node> queue = new LinkedList<>();
        queue.add(new Node(i, j));
        int count = 0;
        // 상 우 하 좌
        int[] di = {1, 0, -1, 0};
        int[] dj = {0, 1, 0, -1};
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            count++;	// 그림 크기 키우기
            // 네 방향 탐색
            for(int d = 0; d<4; d++) {
                int ni = node.i + di[d];
                int nj = node.j + dj[d];
				
                if(ni < 0 || ni >= n || nj < 0 || nj >= m) continue;
                if(visited[ni][nj] || image[ni][nj] == 0) continue;
                visited[ni][nj] = true;
                queue.add(new Node(ni, nj));
            }
        }

        cnt++;
        if(count > 1) count--;
        maxSize = Math.max(maxSize, count);
    }
}

[백준] 7662번 이중 우선순위 큐 (JAVA)

다교이 — Mon, 27 Feb 2023 00:20:54 +0900

문제

- 이중 우선순위 큐는 전형적인 우선순위 큐처럼 데이터를 삽입, 삭제할 수 있음

- 차이점은 데이터를 삭제할 때 연산 명령에 따라 우선순위가 가장 높은 데이터 또는 가장 낮은 데이터 중 하나를 삭제하는 것

- 각 줄에 연산을 나타내는 문자('D' 또는 'I')와 정수 n이 주어짐

- 'I n'은 정수 n을 큐에 삽입하는 연산 (동일한 정수가 삽입될 수 있음)

- 'D 1'는 큐에서 최댓값 삭제 / 'D -1'는 큐에서 최솟값 삭제 (최댓값, 최솟값이 둘 이상인 경우 하나만 삭제 됨)

- 큐가 비어있는데 적용할 연산이 'D'라면 무시 가능

- 모든 연산을 처리하고 최종적으로 큐에 저장된 데이터 중 최댓값과 최솟값 출력

해결방법

TreeMap 자료 구조를 활용하여 문제를 해결하였다. 숫자와 해당 숫자가 들어있는 개수를 함께 treemap에 저장할 수 있도록 구성하였다. 삽입 과정에서 getOrDefault 메서드를 사용하여 각 숫자가 몇개가 포함되어 있는지 확인할 수 있도록 하였다. getOrDefault 메서드에 대한 자세한 사용법은 아래 포스팅을 확인하면 좋을 것 같다.

[자료구조] TreeMap - getOrDefault

getOrDefault(Object Key, V DefaultValue) - 찾는 키가 존재한다면 찾는 키의 값을 반환하고 없다면 기본 값을 반환하는 메서드 - Key : 값을 가져와야 하는 요소의 키 - DefaultValue : 지정된 키로 매핑된 값이

sa11k.tistory.com

삭제 과정에서는 연산 내용(1, -1)에 따라 treemap에 저장된 숫자들 중에서 최댓값, 최솟값을 구해서 개수를 줄여주거나 개수가 1개인 경우엔 삭제할 수 있도록 하였다.

코드

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 T = Integer.parseInt(br.readLine());

        for(int tc = 1; tc<=T; tc++) {
            int k = Integer.parseInt(br.readLine());
            TreeMap<Integer, Integer> treemap = new TreeMap<>();

            for(int i = 0; i<k; i++) {
                StringTokenizer st = new StringTokenizer(br.readLine());
                // 삽입 연산
                if(st.nextToken().equals("I")) {
                    int num = Integer.parseInt(st.nextToken());
                    // 해당 숫자가 있는지 확인하여 개수와 함께 저장
                    treemap.put(num, treemap.getOrDefault(num, 0) + 1);
                } 
                // 삭제 연산
                else {
                    int num = Integer.parseInt(st.nextToken());
                    // 최댓값 삭제
                    if(num == 1) {
                        if(treemap.size() == 0) continue;
                        // 최댓값 개수 받아오기
                        int value = treemap.get(treemap.lastKey());
                        // 개수가 1개라면 아예 treemap에서 삭제
                        if(value == 1) treemap.remove(treemap.lastKey());
                        // 1개 이상이라면 개수 -1
                        else treemap.put(treemap.lastKey(), value-1);
                    } 
                    // 최솟값 삭제
                    else {
                        if(treemap.size() == 0) continue;
                        // 최솟값 개수 받아오기
                        int value = treemap.get(treemap.firstKey());
                        // 개수가 1개라면 아예 treemap에서 삭제
                        if(value == 1) treemap.remove(treemap.firstKey());
                        // 1개 이상이라면 개수 -1
                        else treemap.put(treemap.firstKey(), value-1);
                    }
                }
            }
            // treemap이 비었다면 EMPTY 출력
            if(treemap.size() == 0) System.out.println("EMPTY");
            // 최댓값 최솟값 출력
            else System.out.println(treemap.lastKey() + " " + treemap.firstKey());
        }
    }
}