개미의 개열시미 프로그래밍

[MSSQL] WITH(NOLOCK) , ISNULL

YunHyeok — Tue, 3 Jan 2023 20:22:05 +0900

WITH(NOLOCK)

READ UNCOMMITTED

- 트랜잭션에서의 변경 내용 여부에 상관 없이 다른 트랙잭션에서 값 읽기 가능

- 정합성에 문제가 생길 수 있음

*정합성 : 데이터가 서로 모순 없이 일관되게 일치해야 함을 의미

READ COMMITTED

- 가장 보편적인 격리 수준

- 트랜잭션에서 데이터 변경을 하더라도 COMMIT이 완료된 데이터만 다른 트랜잭션에서 읽기 가능

WITH(NOLOCK)

- MSSQL는 READ COMMIITED 격리 수준이 기본이며 조회(읽기)는 작업 후에나 가능하다. 이를 방지하기 위해 활용하는것이 WITH(NOLOCK)

- READ COMMITED를 읽기(조회)시 READ UNCOMMITED하게 작업할 수 있는 문법

사용법

SELECT *
FROM 테이블명 WITH(NOLOCK)

- 정합성 문제 : committed 전에도 조회 가능한 점은 장점이 될 수 있으나 Rollback이 되는 경우 데이터를 잘못 읽을 수 있음

IS NULL

SELECT ISNULL(컬럼, 대체값)

- 컬럼값이 null인 경우에 대체값으로 변환

[활용 경우]

- 컬럼값이 null인 경우 적절히 처리하기 위함

2022 현대오토에버 상반기 신입 대규모 채용 합격 후기(코딩테스트/1차면접/2차면접)

YunHyeok — Wed, 6 Jul 2022 22:22:52 +0900

서류접수 : 2022.04.20(수) ~ 2022.05.02(월)
코딩테스트 : 2022.05.07 (토)
1차 면접: 2022.05.27 (금)
2차 면접: 2022.06.10 (금)
합격자 발표 : 2022.07.04 (월)

합격후기를 쓰려니 4월부터 시작된 과정이라는 게.. 시간이 이렇게 빨라도 되나 싶다. 원래는 불합격 후기를 쓰고 있었는데 7월 4일에 추가합격 전화를 받고 합격후기가 된 포스팅이다 서류 준비부터 2차 면접까지 상세하게 써보려고 한다!! 많은 사람들이 도움을 많이 받길 기대하며~

1.서류 준비 (지원 직무 : ICT 어플리케이션 개발 및 운영)

간단하게나마 준비했을 당시 스펙을 끄적여보려 한다. 자소서나 다른 부분은 그렇게 잘 쓴다고 생각하지 않기 때문에ㅎㅎ

- 4년제 지방거점국립대 (편입학)
- 보안연구실 학부 인턴 (6개월)
- 기업 인턴 2회
- 네트워크 회사 야간 계약직 (3년 10개월)
- 공모전 2회 수상
- 영어점수 (토익스피킹 Level 5, 120)
- 자격증 (정보처리산업기사, 정처기, SQLD)
- 삼성 청년 SW 아카데미 7기(+SSAFYcial)

지원서나 자소서에 작성했던 모든 내용이 면접에서 도움이 정말 많이 도움되었다. 무엇보다 학부 때 이것저것 했었던 경험들이 지원했던 직무에 대한 얘기를 할 때 전문성이 떨어져 보일 수 있어서 걱정을 많이 했는데 SSAFY 교육 과정을 통해 이 부분을 매꾸려고 노력했던 점이 도움이 많이 된 것 같다.

2. 코딩테스트

총 세문제가 출제가 되었는데 SSAFY에서 알고리즘 교육을 들은 후라서 난이도는 쉽게 느껴졌다. 그 당시 백준 티어 골드2 였는데 이 정도면 무난하게 풀 수 있을 것 같다. 하지만 마지막 문제를 실수해서 ~~아마 2솔이었을 것 같다..ㅠ~~

난이도 : 골드2 기준 쉬운 편
1번 문제 : 단순 구현
2번 문제 : 순열, 조합, 부분집합 (여기서 뭘썼는지 기억은 잘 안 나지만 해당 내용들을 숙지하고 있으면 쉽게 풀 수 있는 문제!)
3번 문제 : 구현 + 문자열 다루는 문제 ( 문자열을 다루는 문제였고 내 기억엔 재귀를 썼었던 것 같다.)

3. 1차 면접 (직무 면접)

1차 면접을 준비할 때 1학기 최종 프로젝트를 진행 중이었기 때문에 준비를 거의 하지 못했다. 하지만 싸피 1학기 내내 배웠던 내용, 실습과제와 프로젝트를 했던 경험이 정말 많은 도움이 되었다. 또 오토에버에서 일했던 형의 조언을 받았었는데 기술면접에서 본인이 했던 프로젝트의 내용을 확실히 정리하고 가야 한다고 말해주셨다. 단순히 무슨 기술을 썼고, 어떤 알고리즘을 활용했다가 아니라 내가 왜 그 기술과 알고리즘을 프로젝트에서 왜 썼는지 면접관님께 잘 말씀드리라고 했다. 항상 코딩을 하기 전에 많은 것을 고려하는 개발자 모습으로 보이는 게 좋아 보일 것 같아 이 부분을 연습을 많이 했다.

또 1차 면접은 2개의 세션으로 나눠서 진행이 됐다. b세션은 코딩 테스트 관련 질문이 나온다고 유튜브나 다른 블로그에서 본 적이 있지만 코딩 테스트에 대해 묻지 않으셨다.

a세션 (면접관 2, 지원자 1로 진행되었다. 분위기는 정말 편한 분위기를 조성해주셨다.)

장단점, 취미를 포함한 자연스러운 자기소개
본인이 생각했을 때 좋은 회사란?
연봉, 워라밸, 분위기 등 하나만 선택해야 한다면?
갈등 경험이 있는지 있으면 어떻게 해결했는지?
제일 존경하는 인물은?
인턴 하면서 느낀 점이 있다면?
스프링에서 제일 인상 깊은 기능은?
컨테이너란?

a세션에서는 위의 질문들을 받았고 인성면접 같은 느낌을 받았다. 편안한 분위기를 만들어주셔서 웃으면서 진행할 수 있었다.

b세션 (1대1 면접)

간단한 자기소개와 지원동기
예상과 다른 직무를 맡게 된다면?
인턴 때 했던 프로젝트 설명 -> 활용한 알고리즘은 뭐가 있었는지
본인이 구현했던 프로젝트 중 제일 어려웠던 것이 어떤 것이 었는지, 어떻게 해결했는지
객체지향의 장점

그리고 상황기술질문? 이라고 해야 되는 건지 모르겠지만 본인이 제작한 웹페이지에 어떤 문제가 발생했을 때 어디부터 살펴볼 것이며 어떻게 처리할 건지 이런 질문이 나왔다. 처음에 많이 당황했지만 그 상황을 생각해보며 논리적으로 대답하려고 노력했다. 이런 질문들이 한 다섯 개 정도? 나왔었다.

아는 형과 통화하면서 면접 때 대답했던 내용을 상기시키며 피드백을 받았는데 2차 면접에서도 비슷한 면접 질문들이 나오면서 정말 많이 도움을 받았다..

4. 2차 면접 (임원 면접)

- 면접관 3, 지원자 2 (면접관은 세분이셨고 한분은 인사담당자분이셨다.)
- 총 30분 진행 (지원자 한 명씩 15분씩 질문한 듯)

지원서에 있던 모든 경험 하나하나에 대해 어떤 질문이 나오면 이 경험을 말해야겠다, 저 경험을 말해야겠다. 이런 식으로 많이 연습했던 것 같다. 역시나 마지막 2차 면접에서는 자소서에 썼던 프로젝트 내용보다는 지원서에 있는 인턴, 공모전, 경력에 대해 많이 물어보셨다.

인사담당자님

지원서에 있는 내용 확인차 질문 (인턴 기간 확인 질문이 나왔다.)
자기소개

임원1

회사에 관련된 기사를 최근에 본 적 있는지
인턴 때 했던 역할과 해당 회사가 어떤 서비스를 제공하는지
공모전 때 했던 내용
mz세대들이 오토에버에 들어오고 싶어 하는 이유가 있는지, 회사를 지원한 이류를 묻는 듯..?

임원2

회사에 지원한 이유
계약직 사원으로 4년 가까이 일했는데 이유가 뭔지, 학부생활과 병행하는데 안 힘들었는지 -> 네트워크 근무는 개발과 무관한데 오랜 기간 한 이유 -> 네트워크 근무와 개발 직무로 수행한 인턴 중 뭐가 힘들었는지
후배들에게 인턴 경험에 대해 어떻게 설명할 건지, 추천을 한다면 이유가 있는지
인턴 때 어떤 어려움이 있었는지
스트레스 어떻게 푸는지
주변에서 본인을 어떻게 생각하고 불리는지, 별명이 있다면 뭔지
본인의 단점
마지막 입사 후 포부를 자신의 역량과 같이 말해줄 수 있는지

인성면접이었지만 임원면접이라 1차 면접보다 분위기가 살짝 차가웠던 것 같다. 아쉬운 게 있었다면 지원동기를 말할 때 회사의 장점만 말하면서 입사하고 싶다! 이런 느낌을 줬던 점이었다. 본인의 기술 스택과 역량을 지원동기에 녹이는 게 좋을 것 같았고 다른 질문들에서도 본인의 기술 스택을 어필하는 게 필요했다고 면접이 끝난 후 계속 후회했다..

결국은 불합격 통보를 받았지만 후순위 대기자에 선정이 되었다. 6월 30일까지 추가합격 메일이 오지 않아서 끝났구나 싶었는데 7월 4일에 갑작스럽게 티오가 발생하여 입사할 수 있냐는 전화를 받았다.. 장난 전화인 줄..ㅜ 알았지만 다음날 추가합격 메일을 받고 마음이 놓였다..ㅎ

입사하기로 결정했고 SSAFY를 퇴소하게 되었다.. 시원섭섭하지만 좋은 기회라고 생각했고 앞으로도 열심히 하는데 큰 동기부여가 된 것 같다. 합격하는데 많이 도움을 준 형들과 친구, 싸피동기들에게 무한감사

[슬기로운 SSAFY생활 - 5화] SSAFY 7기 스터디에 대해 알아보기

YunHyeok — Tue, 5 Jul 2022 17:45:55 +0900

개미의 개열시미 프로그래밍

안녕하세요. SSAFYcial 7기 기자단 조윤혁입니다!!

SSAFY교육생들이 어떻게 스터디 생활을 하고 있는지

알아보는 시간입니다~!!

스터디는 반이 배정이 되고 자치회의 주도하에

모집이 되기도 하고 개인적으로 반 단톡방에서 모집을 하기도 합니다!

대전 6반에서 제일 성실한 교육생 두분과 함께하게 되었습니다

교육생 인터뷰

이상 SSAFYcial 7기 조윤혁 기자였습니다!!

[SSAFYcial] #05. SSAFY 7기 대전캠퍼스 박동섭 교육프로님 인터뷰

YunHyeok — Tue, 5 Jul 2022 17:31:58 +0900

개미의 개열시미 프로그래밍

안녕하세요. SSAFYcial 7기 기자단 조윤혁입니다!
교육생들의 원활한 SSAFY생활을 위해
항상 애쓰고 고생하시는 교육프로님 인터뷰입니다!

언제나 밝은 에너지로
교육생들을 케어해주시는! 힘을 주시는!
박동섭 프로님을 소개합니다

프로님 자기소개

프로님과 인터뷰

1학기 동안 늘 부족하고 늦게 일어나는 저를
따뜻하게 챙겨주셔서 감사합니다 프로님ㅎㅎ
이상 SSAFYcial 7기 조윤혁 기자였습니다!!

2022년 상반기 회고 & 7월 목표

YunHyeok — Wed, 22 Jun 2022 01:00:33 +0900

고등학생 때 캘린더에 꼭 이전 주에 못했던 일들에 대해 반성하는 내용을 적곤 했었는데 작성하면서 깨달은 점이 많았었고 너무 나태해진 나에게 필요하다고 생각해서 이제 한 달에 한 번은 회고하는 시간을 가져야겠다고 생각했다. 6월이 아직 다 끝나지 않아 이른 감이 있지만 이번 달은 빨리 끝났으면 해서.. 양식은 친구 거 약간 카피^^

[상반기 회고 및 목표 설정하기]

1. 상반기에 겨우 11개 기업에 원서를 넣었다. 하반기에는 자소서도 쌓였으니 많이 넣어야 겠다.

-> 거의 다 서류 탈락이지만 11개 기업 전형 결과 포스팅하고 부족했던 점을 정리해야겠다.

2, 블로그 171개 포스팅

-> 요즘 싸피 8기 면접전형이 진행 중이고 롯데정보통신, 다우도 결과를 기다리는 사람이 많아서 평균 하루 방문자가 300 정도 된다ㄷㄷ 조금이나마 도움이 돼서 보시는 거라 생각하고 앞으로도 취준 과정에서 얻은 내용을 많이 올려야겠다. (오토에버 최종 불합 이야기도..ㅠ) 알고리즘도 이제 꾸준히 올리기!!

3. 스프링 강의(김영한)

-> 기본 강의만 절반 정도 넘게 들었는데 오늘부터 최대한 많이 들어야겠다. 백앤드를 담당한 팀원한명이 취업성공을 해서 빈자리를 위해 공부를 많이 해야 될 것 같다.

4. 알고리즘 골드 2

-> 알고리즘 감각을 끌어올려야겠다. 1학기 프로젝트를 하면서 죽이 잘 맞았던 친구랑 공부를 같이하고 싶어서 스터디에 들어갔는데 분위기도 좋고 좋은 거 같다. 골드 1을 목표로

5. 운동하기

-> 체력이 너무 떨어져서 2학기를 위해 런데이 키고 달려야겠다.

6월은 유난히 힘든 달이었는데 12년을 키우던 반려견도 무지개다리를 건넜고 안 좋은 일이 자꾸 겹쳐서 3주를 그냥 날려버렸다.. 게다가 오늘 최종 불합 소식까지.. 7월 빨리 와라..^^ 면접 준비하느라 방학 때 어디 놀러 가지도 못했는데 대면교육 전에 빨리 티켓 구해서 제주도나 부산으로 리프레쉬를 하러 가려고 한다!

[슬기로운 SSAFY생활 - 4화] SSAFY7기 1학기 관통프로젝트 최우수자 인터뷰

YunHyeok — Tue, 31 May 2022 15:38:24 +0900

개미의 개열시미 프로그래밍

안녕하세요. SSAFYcial 7기 기자단 조윤혁입니다!

1학기 막바지에는 그동안 배운 내용으로 프로젝트를 진행하는데요
예비 SSAFY인들의 프로젝트 꿀팁을 위해!!
1학기 프로젝트 최우수자 두분을 모시고 인터뷰를 진행하였습니다

최우수자 자기소개

최우수자 인터뷰

이상 SSAFYcial 7기 조윤혁 기자였습니다!!

[SSAFYcial] #04. SSAFY 7기 전공반 양유진 교수님과의 인터뷰

YunHyeok — Tue, 31 May 2022 15:37:46 +0900

개미의 개열시미 프로그래밍

안녕하세요. SSAFYcial 7기 기자단 조윤혁입니다!
1학기 알고리즘부터 코딩 교육까지 늘 유쾌하고 재밌는 설명으로
수업을 해주시는 양유진 교수님 인터뷰입니다!ㅎㅎ

교육생들이 지치지 않도록 항상 밝은 에너지로
수업을 해주시는 양유진 교수님을 알아볼까요?

교수님의 자기소개

교수님 TMI

교수님과의 인터뷰

1학기동안 교수님께 많이 배웠습니다.
교수님! 정말 감사합니다^_^
이상 SSAFYcial 7기 조윤혁 기자였습니다!!

[슬기로운 SSAFY생활 - 3화] SSAFY의 자치회 알아보기

YunHyeok — Sun, 8 May 2022 03:16:14 +0900

개미의 개열시미 프로그래밍

안녕하세요. SSAFYcial 7기 기자단 조윤혁입니다!
이번에는 교육생과 사무국의들의 원만한 소통을 위해

노력하는 자치회를 알아보는 시간입니다!ㅎㅎ

SSAFY의 기둥!!

자치회에 대해 본격적으로 알아보겠습니다!

유난히 조용하고 어색했던 우리반의 분위기를

180도 바꾼 일등 공신 두 분을 모셨습니다!

자치회 두 분의 이야기를 들어볼까요?!

++ 그 외 못 다한 말 ++

우리 반에게 마지막으로 하고 싶은 말은?

정 진 반장님 : 여러모로 비대면이라는 점에서 굉장히 아쉬운 시간이 지나갔습니다. 한분 한분 직접 얘기 할 때는 할 말도 많고 재밌는 분들도 계셨는데 막상 수업 시간 이외엔 만나기도 힘들고 수업시간에도 각자 수업만 받고 헤어지면서 서로에 대해 아직도 잘 모르고 어색한 분들이 많아서 아쉽습니다. 좀 더 친해지고자 싸피데이도 더 열심히 해보기도 했지만 확실히 대면으로 직접 만나서 소통하는것만 못하다는 느낌도 드네요. 앞으로 얼마 남지 않은 시간 더 친해졌으면 좋겠습니다.

주 혜 령 CA님 : 온라인 수업이라 한 학기의 반이 지나도 조금 어색하기도 하고 공부할 것들이 넘쳐나서 같이 보낼 시간이 많이 없어 아쉬운데 항상 이벤트에도 열심히 참여해 즐겨주시고 뭐든 열심히 해주셔서 감사합니다!

이상 SSAFYcial 7기 조윤혁 기자였습니다!!

[SSAFYcial] #03. SSAFY 人들의 대축제! 'MeetUp'

YunHyeok — Sat, 7 May 2022 21:40:23 +0900

개미의 개열시미 프로그래밍

안녕하세요. SSAFYcial 7기 기자단 조윤혁입니다!

SSAFY 교육생들이 수업으로 쌓인 피로를 한방에 날려줄 행사가 진행되었습니다.
바로! SSAFY 人들의 대축제로 불리는 'MeetUp'에 대한 기사입니다!ㅎㅎ

기다리고 기다렸던 SSAFY의 대축제!!

교육생들을 위해 특별한 분들이 와주셨습니다ㅎㅎ

카드뉴스를 통해 확인해볼까요?

공연의 첫 시작은 뮤지컬 그룹 'SPES'분들이 오셨습니다!

처음 들어보는 뮤지컬 배우들의 목소리.. 너무 감미로웠습니다

이어서 국내 최고의 심리학자 김경일 교수님!!

재치 있고 유머러스함으로 시간 가는 줄 몰랐던 강연이었습니다

다음 강연으로는 삼정전자의 유종민 상무님께서

삼성 나눔스토리라는 주제로 강연을 해주셨습니다!!

작더라도 나눔을 실천해야겠다는 마음이 생긴 시간이었습니다.

마지막으로, 김종국 가수님의 공연과 SSAFY 7기 교육생들과의 인터뷰 시간!!

하루 종일 수업을 듣는 교육생들을 위해 간단한 체조도 알려주셨습니다ㅎㅎ

++ 그 외 사진들 ++

멀티캠퍼스 20층 식당에서 멋진 뷰가 보이는 맛있는 점심식사와

현장방문을 했던 교육생들을 위한 롤케이크 선물도 받았습니다

좋은 추억을 선물해주신 SSAFY프로님께

감사의 말씀 전합니다^_^

이상 SSAFYcial 7기 조윤혁 기자였습니다!!

[알고리즘] 백준16236 아기상어 - 자바

YunHyeok — Mon, 25 Apr 2022 22:32:03 +0900

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

16236번: 아기 상어

N×N 크기의 공간에 물고기 M마리와 아기 상어 1마리가 있다. 공간은 1×1 크기의 정사각형 칸으로 나누어져 있다. 한 칸에는 물고기가 최대 1마리 존재한다. 아기 상어와 물고기는 모두 크기를 가

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;

public class BOJ_16236_아기상어 {
	static int N, ans, eatCnt;
	static int sharkSize = 2;
	static int[][] map;
	static Queue<Point> q = new LinkedList<>();
	final static int[] dy= {-1, 1, 0, 0};
	final static int[] dx = {0, 0, -1, 1};
	
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		
		N = parse(br.readLine());
		
		map = new int[N][N];
		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j=0; j<N; j++) {
				map[i][j] = parse(st.nextToken());
				if(map[i][j] == 9) {
					q.offer(new Point(i, j));
					map[i][j] = 0;
				}
			}
		}
		
		while(sharkFine());
		System.out.println(ans);
	}
	
	
	private static boolean sharkFine() {
		boolean[][] visited = new boolean[N][N];
		PriorityQueue<Point> pq = new PriorityQueue<>();
		
		int dist = 0;
		
		while(!q.isEmpty()) {
			int size = q.size();
			for(int s=0; s<size; s++) {
				Point point = q.poll();
				
				for(int d=0; d<4; d++) {
					int y = point.y + dy[d];
					int x = point.x + dx[d];
					if(y>=0 && x>=0 && y<N && x<N && !visited[y][x]) {//범위체크
						if(sharkSize > map[y][x] && map[y][x] != 0) { // 아기상어가 더 크면
							pq.offer(new Point(y, x));
						}
						if(sharkSize >= map[y][x]) { // 아기상어가 지나갈 수 있다면 
							q.offer(new Point(y, x));
						}
						visited[y][x] = true;
					}
				}
			}
			
			dist++;
			
			if(!pq.isEmpty()) {
				q = new LinkedList<>(); // 한마리라도 잡히면 초기화
				Point fish = pq.poll();
				map[fish.y][fish.x] = 0;
				q.offer(fish);
				pq = new PriorityQueue<>(); // 한 마리 뻇으니까 초기화
				ans+=dist; // 거리 누적
				
				if(sharkSize == ++eatCnt) {
					sharkSize++;
					eatCnt=0;
				}
				return true;
			}
			
		}
		
		return false;
	}


	private static int parse(String str) {
		return Integer.parseInt(str);
	}

	private static class Point implements Comparable<Point>{
		int y, x;
		Point(int y, int x){
			this.y = y;
			this.x = x;
		}
		@Override
		public int compareTo(Point o) {
			if(this.y == o.y) {
				return this.x-o.x;
			}
			return this.y-o.y;
		}
	}
	
	
}

[풀이 로직]

ans : 출력해야 할 거리 값
eatCnt : 물고기를 먹을 때마다 +1
큐는 두개를 선언했는데 static으로 선언한 큐는 아기 상어가 이동 가능한 공간을 담을 용도, shakeFind라는 함수 내에 선언된 우선순위 큐는 문제의 '거리가 가까운 물고기가 많다면, 가장 위에 있는 물고기, 그러한 물고기가 여러마리라면, 가장 왼쪽에 있는 물고기를 먹는다.' 조건을 위해 선언해주었다. 이떄 Point 클래스 내에 comparable을 구현해주어야 한다.

shakeFind함수를 while문으로 계속 반복하는데 물고기를 한 마리도 잡지 못하는 경우 false가 반환되어 반목 문이 종료된다.
shakeFind함수 내에 while문에서 size만큼 for문을 돌게끔했는데 이는 물고기를 잡기까지의 거리를 구하기 위함이다.
2-1. 만약, 아기상어가 물고기를 한 마리라도 먹게 되면 물고기를 한 마리만 우선순위 큐에서 뺸뒤 다음 첫 시작을 위해 큐에 넣어준다.
2-2. 문제에서 제시된대로 아기 상어의 크기가 지금까지 먹은 물고기의 개수와 같으면 아기 상어의 크기를 올려주고 먹은 물고기의 수를 초기화해준다.

[알고리즘] 백준14890 경사로 - 자바

YunHyeok — Sat, 23 Apr 2022 18:03:41 +0900

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

14890번: 경사로

첫째 줄에 N (2 ≤ N ≤ 100)과 L (1 ≤ L ≤ N)이 주어진다. 둘째 줄부터 N개의 줄에 지도가 주어진다. 각 칸의 높이는 10보다 작거나 같은 자연수이다.

www.acmicpc.net

[풀이 코드]

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

public class BOJ_14890_경사로 {
	static int N, L, ans;
	static int[][] map;
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		N = parse(st.nextToken());
		L = parse(st.nextToken());
		
		map = new int[N][N];
		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j=0; j<N; j++) {
				map[i][j] = parse(st.nextToken());
			}
		}
		
		for(int i=0; i<N; i++) {
			dfs(map[i], 0, 1); // 행 검사
			
			int[] arr = new int[N]; // 열 일차원 배열로 만들어주기
			for(int j=0; j<N; j++) {
				arr[j] = map[j][i];
			}
			dfs(arr, 0, 1); // 열 검사
			
		}
		System.out.println(ans);
	}
	
	private static void dfs(int[] arr, int idx, int cnt) {
		if(idx == N-1) {
			ans++;
			return;
		}
		
		if(idx >= N) {
			return;
		}
		
		if(arr[idx] == arr[idx+1]) { // 평지
			dfs(arr, idx+1, cnt+1);
		}
		if(arr[idx] - arr[idx+1] == -1 && cnt >= L) { // 오르막
			dfs(arr, idx+1, 1);
		}
		if(arr[idx] - arr[idx+1] == 1 ) { // 내리막
			if(idx+L < N && check(arr, idx)) { // 내리막 갈 수 있는지 여부 체크하는 함수
				dfs(arr, idx+L, 0);
			}
		}
		
	}

	private static boolean check(int[] arr, int idx) {
		int temp = arr[idx]-1; // 한칸 아래
		for(int l=1; l<=L; l++) {
			if(arr[idx+l] != temp) return false;
		}
		return true;
	}
	

	private static int parse(String str) {
		return Integer.parseInt(str);
	}

}

코드를 다 작성하고 나니까 dfs() 함수를 한 번만 쓰고 싶었는데 스터디원이 리팩터링을 해주신 걸 참조했다. 일차원 배열만 dfs에 넣어주면 되도록 작성했다.

[풀이 로직]

dfs함수에 들어가는 파라미터는 일차원 배열, idx, cnt이다. idx는 한칸한칸 앞으로 가기 위함이고 cnt변수는 오르막 길을 가기 위해 현재 위치한 곳에 도달하기까지를 몇 칸을 왔는지 넣어주었다.

dfs함수 내에서 세가지의 조건문으로 나눠 작성했다.

평지로 가는 경우
오르막길로 가는 경우
cnt변수가 L보다 같거나 크면 갈 수 있으니 idx+1(한 칸 위로), cnt(변수를 1로 초기화해서 다시 dfs() 함수 수행
내리막길로 가능 경우
cnt변수가 필요 없다. 내리막의 경우는 앞을 내다봐야 되기 때문에 따로 check() 함수를 만들어서 현재 위치한 곳부터 L까지의 거리를 탐색했다.

[알고리즘] 백준20056 마법사 상어와 파이어볼 - 자바

YunHyeok — Sat, 23 Apr 2022 14:37:08 +0900

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

20056번: 마법사 상어와 파이어볼

첫째 줄에 N, M, K가 주어진다. 둘째 줄부터 M개의 줄에 파이어볼의 정보가 한 줄에 하나씩 주어진다. 파이어볼의 정보는 다섯 정수 ri, ci, mi, si, di로 이루어져 있다. 서로 다른 두 파이어볼의 위치

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;


public class BOJ_20056_마법사상어와파이어볼2 {
	static int N, M, K;
	static int[][][] map;
	static Queue<Point> q = new LinkedList<>();
	static int[] dy = {-1, -1, 0, 1, 1, 1, 0, -1};
	static int[] dx = {0, 1, 1, 1, 0, -1, -1, -1};
	
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		N = parse(st.nextToken());
		M = parse(st.nextToken());
		K = parse(st.nextToken());
		
		map = new int[N][N][6];
		for(int i=0; i<M; i++) {
			st = new StringTokenizer(br.readLine());
			int y = parse(st.nextToken())-1;
			int x = parse(st.nextToken())-1;
			int m = parse(st.nextToken()); // 질량
			int s = parse(st.nextToken()); // 속도
			int dir = parse(st.nextToken()); // 방향

			map[y][x][0]++;
			map[y][x][1] += m;
			map[y][x][2] += s;
			map[y][x][5] += dir;
			
			if(dir%2==0) map[y][x][3]++; // 짝수
			else map[y][x][4]++; // 홀수
			
			q.offer(new Point(y, x, m, s, dir));
		}
		
		while(K-- > 0) {
			move();
			divide();
		}
		resultPrint();
	}

	private static void resultPrint() {
		int ans = 0;
		for(int i=0; i<N; i++) {
			for(int j=0; j<N; j++) {
				ans += map[i][j][1];
			}
		}
		System.out.println(ans);
	}

	private static void divide() {
		for(int i=0; i<N; i++) {
			for(int j=0; j<N; j++) {
				if(map[i][j][0] >= 2) {
					fireDivide(i, j);
				}else if(map[i][j][0] == 1) {
					q.offer(new Point(i, j, map[i][j][1], map[i][j][2], map[i][j][5]));
				}
			}
		}
	}

	private static void fireDivide(int i, int j) {
		int size = map[i][j][0]; // 개수
		int mSum = map[i][j][1]/5; // 질량의 합
		int speadSum = map[i][j][2]/size; //속도의 합
		int even = map[i][j][3]; // 짝수
		int odd = map[i][j][4]; // 홀수
		
		if(mSum != 0) {		
			map[i][j][0] = 4;	
			map[i][j][1] = mSum * 4;
			map[i][j][2] = speadSum*4;
			map[i][j][5] = 0;
			
			for (int f = 0; f < 4; f++) {
                q.offer(new Point(i, j, mSum, speadSum, (f * 2 + ((even == size || odd == size) ? 0 : 1) )));
            }
            map[i][j][3] = (even == size || odd == size) ? 4 : 0;
            map[i][j][4] = 4 - map[i][j][3];
			
		}else {
			for(int k=0; k<=5; k++) { // 초기화
				map[i][j][k] = 0;
			}
		}
	}

	private static void move() {
		while(!q.isEmpty()) {
			Point point = q.poll();
			map[point.y][point.x][0]--;
			map[point.y][point.x][1] -= point.m;
			map[point.y][point.x][2] -= point.s;
			map[point.y][point.x][5] -= point.dir; 
			
			if(point.dir%2==0) map[point.y][point.x][3]--; // 짝수
			else map[point.y][point.x][4]--; // 홀수
			
			int y = (point.y + dy[point.dir]*point.s + N*1000)%N;
			int x = (point.x + dx[point.dir]*point.s + N*1000)%N;
			
			map[y][x][0]++;
			map[y][x][1] += point.m;
			map[y][x][2] += point.s;
			map[y][x][5] += point.dir;
			
			if(point.dir%2==0) map[y][x][3]++; // 짝수
			else map[y][x][4]++; // 홀수
			
		}
	}

	static class Point{
		int y, x, m, s, dir;
		
		Point(int y, int x, int m, int s, int dir){
			this.y = y;
			this.x = x;
			this.m = m;
			this.s = s;
			this.dir = dir;
		}
	}
	
	private static int parse(String s) {
		return Integer.parseInt(s);
	}
}

정말 힘들게 풀었던 문제.. 처음에는 큐만 활용하려고 하다 보니 반복문이 많아져서 시간 초과가 자꾸 나왔다. 그리고 문제에서 놓치는 부분이 없도록 잘 체크해야 한다.

[이 문제를 풀면서 부족하다고 느낀 점]

기본기? 가 부족했던 것 같다. 어떤 상황에 for문을 써야 할지 while문을 써야할지 잘 생각해야겠다. 내가 막혔던 부분 중 하나가 while(size-- > 0) 이렇게 size가 다 감소하면 while문을 빠져나오게 구현했는데 반복문을 나온 후에 다시 size로 뭘 하려고 하다가 자꾸 음수 값이 나와서 헤맸던 것 같다... 완전 바보 같은 실수..
두 번째는 위 코드에서 보면 (point.y + dy[point.dir]*point.s + N*1000)%N; 이렇게 모듈러 연산을 해준 부분이 있는데 처음에는 이렇게 간단한 방법이 있는 줄 모르고 직접 if문으로 파이어볼이 주어진 범위를 나갔을 경우를 처리해줬다. 여기서 1000을 곱한 이유는 1 ≤ si ≤ 1,000 속도의 최댓값이 1000이기 때문이다.

[풀이 로직]

함수는 크게 아래처럼 3개로 구현했다.

move() : 파이어볼을 이동시킨다!
divide() : 2개 이상 모인 파이어볼은 fireDivde()함수로 이동하도록하고 불이 하나밖에 없다면 다시 큐에 담아준다.
2-1. fireDivide() : 2개이상 모인 파이어볼을 문제에서 주어진대로 나눠준다!

위 로직을 문제에서 주어진 K만큼 반복하면 된다.

그리고 3차원 배열을 활용했다는 점도 문제를 푸는 데 있어 매우 중요했던 것 같다.

3차원 배열을 활용한 이유는 단순히 큐로만 풀려고 하면 반복문을 정말 많이 쓰게 된다.
map = new int [N][N][6]; 3차원 배열에 순서대로 파이 볼의 개수, 질량의 합, 속도의 합, 짝수 카운팅, 홀수 카운팅, 방향!
제일 헷갈렸던 건 방향을 담는 것인데 불이 하나만 담기는 경우만 신경 쓰면 된다. 두 개부터는 어차피 fireDivide함수에서 처리가 되기 때문에 전혀 신경을 안 써줘도 된다.

이 문제를 풀 수 있도록 도와준 스터디원에게 정말 감사하다...

[알고리즘] 백준16234 인구 인동 - 자바

YunHyeok — Wed, 20 Apr 2022 22:07:52 +0900

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

16234번: 인구 이동

N×N크기의 땅이 있고, 땅은 1×1개의 칸으로 나누어져 있다. 각각의 땅에는 나라가 하나씩 존재하며, r행 c열에 있는 나라에는 A[r][c]명이 살고 있다. 인접한 나라 사이에는 국경선이 존재한다. 모

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
	static int N, L, R, day;
	static int[][] map;
	static boolean[][] visited;
	static int[] dy = {-1, 1, 0, 0};
	static int[] dx = {0, 0, -1, 1};
	
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
	
		N = Integer.parseInt(st.nextToken());
		L = Integer.parseInt(st.nextToken());
		R = Integer.parseInt(st.nextToken());
		map = new int[N][N];
		
		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j=0; j<N; j++) {
				map[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		
		while(check()) {
			day++;
		}
		
		System.out.println(day);
		
	}
	
	private static boolean check() {
		boolean flag = false;
		visited = new boolean[N][N];
		for(int i=0; i<N; i++) {
			for(int j=0; j<N; j++) {
				if(!visited[i][j] && bfs(i, j)){
					flag = true;
				}
			}
		}
		return flag;
	}

	private static boolean bfs(int i, int j) {
		Queue<Point> q = new LinkedList<>();
		Queue<Point> unionQ = new LinkedList<>();
		visited[i][j] = true;
		q.offer(new Point(i, j));
		unionQ.offer(new Point(i, j));
		int sum=map[i][j];
		
		while(!q.isEmpty()) {
			Point p = q.poll();
			
			for(int d=0; d<4; d++) {
				int y = p.y + dy[d];
				int x = p.x + dx[d];
				if(y>=0 && x>=0 && y<N && x<N && !visited[y][x]) {
					int diff = Math.abs(map[p.y][p.x] - map[y][x]);
					if(diff >= L && diff <= R) {
						q.offer(new Point(y, x));
						unionQ.offer(new Point(y, x));
						visited[y][x] = true;
						sum += map[y][x];
					}
				}
			}
			
		}
		
		int num = sum / unionQ.size();
		if(unionQ.size()>1) {
			Move(unionQ, num);
			return true;
		}
		
		return false;
	}
	
	private static void Move(Queue<Point> q, int sum) {
		while(!q.isEmpty()) {
			Point p = q.poll();
			map[p.y][p.x] = sum;
		}
	}

	static class Point{
		int y, x;
		Point(int y, int x){
			this.y = y;
			this.x = x;
		}
	}
}

while() 문 안에서 check() 함수를 통해 인구이동이 가능한지 먼저 체크한다.
check() 문 안에서 이중 for문을 돌며 bfs() 함수를 수행하는데 이때 방문 배열 visited를 신경 써야 한다.
bfs() 문 안에서는 두 개의 큐를 썼는데 q는 이동 가능한 좌표를 담고 unionQ는 연결되는 땅을 담는다.
1. unionQ에 하나 이상 연결된 땅이 있다면 Move() 함수를 통해 map을 문제에서 주어진 방식대로 변경시켜준다.

싸피에서 친해진 알고리즘 스승님께 혼나가며 배우는 중... 요새 나를 놀리는 데 재미 들리신 것 같다..ㅜ 많이 배우는 중

https://kkap999.tistory.com/category/%ED%94%8C%EB%B0%8D

'플밍' 카테고리의 글 목록

문제풀이 모음집 CS, 개발공부: https://github.com/rkarud1234/Study_Programming

kkap999.tistory.com

[슬기로운 SSAFY생활 - 2화] SSAFY 7기 싸피데이 알아보기

YunHyeok — Mon, 4 Apr 2022 13:11:56 +0900

개미의 개열시미 프로그래밍

안녕하세요. SSAFYcial 7기 기자단 조윤혁입니다!
예비 SSAFY인들의 슬기로운 SSAFY생활을 위해
이번에는 싸피 교육생들의 스트레스를 날려주는 날!
"싸피데이"에 대한 기사입니다!ㅎㅎ

갑자기 어려워진 수업을 버티고 버텨..
드디어 싸피데이를 맞이했습니다!

이번 싸피데이를 통해 급?친해진 저희 6반!!
무슨일이 있었길래 가까워질 수 있었는지
싸피데이를 진행해주신 진행자 두 분을 모셨습니다~!!

싸피데이 이후 급 친해진 저희 반은
게더에 모여서 새벽 3시 넘게 떠들었습니다~

이상 SSAFYcial 7기 조윤혁 기자였습니다!!

[알고리즘] 백준11727 2xn 타일링2 - 자바

YunHyeok — Thu, 31 Mar 2022 22:21:37 +0900

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

11727번: 2×n 타일링 2

2×n 직사각형을 1×2, 2×1과 2×2 타일로 채우는 방법의 수를 구하는 프로그램을 작성하시오. 아래 그림은 2×17 직사각형을 채운 한가지 예이다.

www.acmicpc.net

[풀이 코드]

package dp;

import java.util.Scanner;

public class BOJ_11727_2xn타일링2 {
	static int[] D;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		D = new int[1001];
		
		D[1] = 1;
		D[2] = 3;
		for(int i=3; i<=N; i++) {
			D[i] = D[i-1] + D[i-2]*2;
			D[i] %= 10007;
		}
		
		System.out.println(D[N]);
	}

}

https://reliablecho-programming.tistory.com/166

[알고리즘] 백준11726 2xn 타일링 - 자바

https://www.acmicpc.net/problem/11726 11726번: 2×n 타일링 2×n 크기의 직사각형을 1×2, 2×1 타일로 채우는 방법의 수를 구하는 프로그램을 작성하시오. 아래 그림은 2×5 크기의 직사각형을 채운 한 가지..

reliablecho-programming.tistory.com

타일링 첫번째 시리즈 문제를 풀었으면 쉽게 풀 수 있는 문제이다!

[알고리즘] 백준11726 2xn 타일링 - 자바

YunHyeok — Thu, 31 Mar 2022 21:31:44 +0900

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

11726번: 2×n 타일링

2×n 크기의 직사각형을 1×2, 2×1 타일로 채우는 방법의 수를 구하는 프로그램을 작성하시오. 아래 그림은 2×5 크기의 직사각형을 채운 한 가지 방법의 예이다.

www.acmicpc.net

[풀이 코드]

package dp;

import java.util.Scanner;

public class BOJ_11726_2xn타일링 {
	static int N;
	static int[] D;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		
		D = new int[1001];
		D[1] = 1;
		D[2] = 2;	
		
		for(int i=3; i<=N; i++) {
			D[i] = D[i-1] + D[i-2];
			D[i] %= 10007;
		}
		System.out.println(D[N]);
		
	}

}

- D [n]은 2xn을 채우는 방법의 수

- D[n]에서 맨 오른쪽을 채울 수 있는 경우는 아래 이미지에서 2x1 도형이 맨 오른쪽에 오는 경우와 1x2도형이 두 개 쌓여 맨 오른쪽에 오는 경우이다.

- 맨오른쪽에 올 수 있는 건 두 경우의 수밖에 없으며 점화식은 D [n] = D [n-1] + D [n-2]가 된다.

[SSAFYcial] #02. SSAFY만의 알고리즘 게임 평가! '일타싸피'

YunHyeok — Tue, 15 Mar 2022 23:17:05 +0900

개미의 개열시미 프로그래밍

안녕하세요!!ㅎㅎ

SSAFYcial 7기 기자단 조윤혁입니다.

예비 SSAFY인들을 위해

알고리즘을 흥미진진한 게임으로 평가하는

일.타.싸.피에 대한 소개를 전하러 왔습니다!

간단한 소개

포켓볼과 동일한 룰을 적용하지만

훨씬 적은 수의 공으로 플레이하게 됩니다!

Rule

평가는 하루동안

오전, 오후 타임으로 나눠집니다!

오전에는 개인평가를 진행하고

오후에는 반 대항전이 진행됩니다!

Interview

전국 45개 반의 1등 팀들은 치열한 전국 대항전을 치르게 됩니다.

이번 기사에서는 저희 반에서 1등을 하신 에이스 두 분을 모셨습니다!

좋은 성적을 내지 못한 저는 많이 아쉬웠습니다..ㅜ

하지만 SSAFY 8기가 되실 여러분은 꿀팁을 보셨으니

걱정 덜으셨겠죠?ㅎㅎ

이상 SSAFYcial 7기

조윤혁 기자였습니다!!

[알고리즘]백준2234 성곽 - 자바

YunHyeok — Thu, 10 Mar 2022 03:30:06 +0900

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

2234번: 성곽

첫째 줄에 두 정수 N, M이 주어진다. 다음 M개의 줄에는 N개의 정수로 벽에 대한 정보가 주어진다. 벽에 대한 정보는 한 정수로 주어지는데, 서쪽에 벽이 있을 때는 1을, 북쪽에 벽이 있을 때는 2를,

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.StringTokenizer;

public class BOJ_2234_성곽 {
	static int N, M, oneCnt, max, rMax;
	static int[][] graph;
	static int[][] visited;
	static int[] dy = { 0, -1, 0, 1 };
	static int[] dx = { -1, 0, 1, 0 };
	static int[] dir = { 1, 2, 4, 8 };
	static int color = 1;
	static Map<Integer, Integer> map = new HashMap<>();

	static class Point {
		int y, x, wall;

		Point(int y, int x, int wall) {
			this.y = y;
			this.x = x;
			this.wall = wall;
		}
	}

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

		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());

		graph = new int[M][N];
		visited = new int[M][N];
		for (int i = 0; i < M; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j = 0; j < N; j++) {
				graph[i][j] = Integer.parseInt(st.nextToken());
			}
		} // 그래프 입력받기


		for (int i = 0; i < M; i++) {
			for (int j = 0; j < N; j++) {
				if (visited[i][j] == 0) {
					int twoCnt = bfs(i, j, graph[i][j]);
					map.put(color, twoCnt); //#3
					max = Math.max(max, twoCnt); //#2. 가장 넓은 방의 넓이
					oneCnt++; // #1. 이 성에 있는 방의 개수
					color++; // visited배열 1~5로 구간 나누기
				}
			}
		}

		removeSearch(); // #3. 하나의 벽을 제거하여 얻을 수 있는 가장 넓은 방의 크기

		System.out.println(oneCnt);
		System.out.println(max);
		System.out.println(rMax);

	}

	static int bfs(int i, int j, int wallNum) {
		Queue<Point> q = new LinkedList<>();
		q.offer(new Point(i, j, wallNum));
		visited[i][j] = color;
		int twoCnt = 1;
		while (!q.isEmpty()) {
			Point point = q.poll();

			boolean[] move = new boolean[4];

			// 벽에대한 정보를 통해 이동할 수 있는 경우를 move배열에 넣어주기
			int wallN = 15 - point.wall;
			for (int num = 3; num >= 0; num--) {
				if (wallN >= dir[num]) {
					wallN -= dir[num];
					move[num] = true;
				}
			}

			for (int m = 0; m < move.length; m++) {
				if (move[m]) {
					int y = point.y + dy[m];
					int x = point.x + dx[m];
					if (visited[y][x] == 0) {
						q.offer(new Point(y, x, graph[y][x]));
						visited[y][x] = color;
						twoCnt++;
					}
				}

			}
		}
		return twoCnt;
	}

	static void removeSearch() {
		// 오른쪽, 아래만 확인
		for (int i = 0; i < M; i++) {
			for (int j = 0; j < N; j++) {
				if(j+1 < N) {
					if (visited[i][j] != visited[i][j + 1]) {
						int removeCnt = map.get(visited[i][j]) + map.get(visited[i][j + 1]);
						rMax = Math.max(rMax, removeCnt);
					}
				}
				if(i+1< M) {
					if (visited[i][j] != visited[i + 1][j]) {
						int removeCnt = map.get(visited[i][j]) + map.get(visited[i + 1][j]);
						rMax = Math.max(rMax, removeCnt);
					}
				}
				
			}
		}
	}
}

1번 이성에 있는 방의 개수와 2번 가장 넓은 방의 넓이를 구하는 건 어렵지 않았지만 3번 "하나의 벽을 제거하여 얻을 수 있는 가장 넓은 방의 크기"는 고민을 많이 했다.

먼저, visited배열을 활용하여 방의 구간을 나눠주었다. 방의 개수가 총 5개니까 1, 2, 3, 4, 5값을 2차원 visited배열에 넣어줬다. 그리고 map의 키 값으로는 나눠진 영역값이 들어가고 value값으로는 방 영역의 총 갯수가 들어간다.

후에 removeSearch함수 안에서 인접한 오른쪽, 아래쪽을 탐색하면서 다르면 더해주고 max값을 저장하도록 했다.

[프로그래머스] LEVEL2 전력망을 둘로 나누기 - 자바

YunHyeok — Mon, 7 Mar 2022 21:42:13 +0900

https://programmers.co.kr/learn/courses/30/lessons/86971

코딩테스트 연습 - 전력망을 둘로 나누기

9 [[1,3],[2,3],[3,4],[4,5],[4,6],[4,7],[7,8],[7,9]] 3 7 [[1,2],[2,7],[3,7],[3,4],[4,5],[6,7]] 1

programmers.co.kr

[풀이 코드]

import java.util.*;

class Solution {
    static List<List<Integer>> list; 
    public int solution(int n, int[][] wires) {
        int answer = -1;
        list = new ArrayList<>();
        for(int i=0; i<n+1; i++){
            list.add(new ArrayList<>());
        }
        
        for(int i=0; i<wires.length; i++){
            list.get(wires[i][0]).add(wires[i][1]);
            list.get(wires[i][1]).add(wires[i][0]);
        }
        

        int min = Integer.MAX_VALUE; // 최댓값 설정
        for(int i=1; i<=n; i++){
            for(int num : list.get(i)){
                if(i < num) {
                    int tCnt = bfs(i, num, n); //BFS한번만!!
                    min = Math.min(min, Math.abs(tCnt - (n-tCnt))); 
                }
            }
        }
        
        return min;
    }
    
    static int bfs(int start, int end, int n){
        Queue<Integer> q = new LinkedList<>();
        boolean[] visited = new boolean[n+1];
        int cnt = 1;
        q.offer(start);
        visited[start] = true;
        
        while(!q.isEmpty()){
            int v = q.poll();
            
            for(int i : list.get(v)){
                if(!visited[i] && i != end){
                    q.offer(i);
                    visited[i] = true;
                    cnt++;
                }
            }
        }
        return cnt;
    }
}

만약에 각 노드마다 가중치가 있다고 가정한다고 해도 BFS로 풀 수 있을지가 궁금하다.

이때 간선이 중복되어 탐색되는 부분을 방지하기 위해 if(i < num) 조건문을 넣어줬다. 이 부분은 직접 간선 리스트를 그려보면 이해가 빨리 된다.

for문을 n번만큼 돌면서 나눠진 두 구역 중 한 구역만 bfs탐색을 실행한다. 나머지 한구역은 총합에서 bfs탐색 후 나온 값을 빼주면 된다.

[알고리즘] 백준14500 테트로미노 - 자바

YunHyeok — Sun, 6 Mar 2022 17:35:08 +0900

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

14500번: 테트로미노

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다. 정사각형은 서로 겹치면 안 된다. 도형은 모두 연결되어 있어야 한다. 정사각형의 변

www.acmicpc.net

[풀이 코드]

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


public class BOJ_14500_테트로미노 {
	static int N, M;
	static int[][] map;
	static boolean[][] visited;
	static int[] dy = {-1, 1, 0, 0};
	static int[] dx = {0, 0, -1, 1};
	static int max = Integer.MIN_VALUE;
	
	
	
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());
		
		map = 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++) {
				map[i][j] = Integer.parseInt(st.nextToken());
			}
		} // map 입력받기
		
		for(int i=0; i<N; i++) {
			for(int j=0; j<M; j++) {
				dfs(0, i, j, 0); // ㅗ 모양 빼고 탐색
				carShape(i, j); // ㅗ 모양 탐색
			}
		} 
		
		System.out.println(max);
		
		
	}
	static void dfs(int idx, int i, int j, int sum) {
		if(idx == 4) {
			max = Math.max(max, sum);
			return;
		}
		
		for(int d=0; d<4; d++) {
			int y = i + dy[d];
			int x = j + dx[d];
			if(y>=0 && x>=0 && y<N && x<M) {
				if(!visited[y][x]) { // 모든 경우를 다 탐색해야하는 순열이니까?
					visited[y][x] = true;
					dfs(idx+1, y, x, sum + map[y][x]);
					visited[y][x] = false;
				}
			}
		}
		
	}
	
	static void carShape(int i, int j) {
		int min = Integer.MAX_VALUE; // 추가한 칸 중에 제일 작은 값 저장 
		int cnt = 0; // 칸이 몇개 붙었는지
		int sum = map[i][j]; // 선택한 칸 포함하기
		
		for(int d=0; d<4; d++) {
			int y = i + dy[d];
			int x = j + dx[d];
			if(y>=0 && x>=0 && y<N && x<M) {
				cnt++;
				min = Math.min(min, map[y][x]);
				sum += map[y][x];
			}
		}
		if(cnt == 4) { // 만약 + 모양이라면 제일 작은 칸 하나를 빼준다.
			sum -= min;
			max = Math.max(max, sum);
		}else if(cnt == 3) { // 자동차 모양이라면 바로 max값과 비교한다.
			max = Math.max(max, sum);
		}
	}

}

'ㅗ' 모양을 제외한 다른 모양들은 dfs 순열을 통해 만들 수 있는 점이 팁?이다.
dfs() 함수는 'ㅗ' 모양을 제외한 다른 모양들을 탐색하면서 최댓값을 찾는 함수
carShape() 함수는 '+' 모양으로 탐색한 후 튀어나온 제일 작은 칸을 빼준다. 그리고 저장되어 있던 최댓값과 비교를 한다.

[짧게 정리하는 CSS] 자식결합자 이해하기

YunHyeok — Fri, 4 Mar 2022 11:02:58 +0900

자식 결합자 ( > )

첫 번째 요소의 바로 아래 자식인 노드를 선택한다.

오류가 났던 부분

두 개의 테이블이 있다고 가정할 때, 각각 id를 table1, table2로 주었다.

그때 위의 이미지처럼 table 2 tr, td에게만 border값을 주고 싶은 경우가 있었다.

[성공한 경우]

.table2 > tr,
.table2 td{
	border: 1px solid darkgray;
}

- .table > tr, . table 2 > tr > td로 해줘도 됐을 것이다.

[실패한 경우]

.table2 > tr, td{
	border: 1px solid darkgray;
}

- 코드 상 td는 tr로 감싸져 있기 때문에 한번 더 >를 써줘야 했다.

- 실패한 경우의 코드는 table1의 td까지도 border값이 들어간다.

[짧게 정리하는 CSS] 4가지 포지셔닝

YunHyeok — Wed, 2 Mar 2022 21:31:40 +0900

CSS 포지셔닝이란?

HTML의 엘리먼트 위치를 제어하는 방법
레이아웃을 설계하는데 중요한 속성

포지셔닝의 4가지 종류

: CSS의 position을 지정하여 위치를 지정할 수 있다.

1. static

position속성의 기본값
엘리먼트 나열 순서대로 배치

2. relative

부모 엘리먼트를 기준으로 위치가 정해짐

3. absolute

부모 엘리먼트 중에 relative타입이 지정된 부모를 기준으로 위치가 정해짐
부모 엘리먼트와 연결성이 끊겨 해당 엘리먼트는 자신의 컨텐츠 크기만 해짐
부모 엘리먼트 또한 자식 엘리먼트를 없는 셈 친다.

4. fixed

absolute와 같이 자신의 컨텐츠 크기가 된다는 점
특정한 엘리먼트를 화면에 고정시켜서 스크롤로부터 완전히 독립

[참고자료]

https://opentutorials.org/course/2418/13414

[슬기로운 SSAFY생활 - 1화] SSAFY 7기 합격 꿀팁 인터뷰

YunHyeok — Wed, 2 Mar 2022 12:54:23 +0900

개미의 개열시미 프로그래밍

안녕하세요. SSAFYcial 7기 기자단 조윤혁입니다!

예비 SSAFY인들의 슬기로운 SSAFY생활을 위해

이번 기사는따끈따끈한 7기에 합격한 교육생 세 분을 모셨습니다.

이 글은 전공자 반분들의 면접 꿀팁입니다!

비전공자 반의 면접 팁은 기회가 되면 인터뷰할 수 있도록 하겠습니다ㅎㅎ

이제 7기 교육생들의 면접 꿀팁 알아볼까요?

이상 SSAFYcial 7기 조윤혁 기자였습니다!!

[알고리즘] 백준3190 뱀 - 자바

YunHyeok — Wed, 2 Mar 2022 02:00:27 +0900

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

3190번: 뱀

'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다. 게임

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class BOJ_3190_뱀 {
	static int N, K, dir;
	static int[][] map;
	static int dy[] = {0, 1, 0, -1};
	static int dx[] = {1, 0, -1, 0};
	static Queue<DPoint> dp = new LinkedList<>();
	static Deque<Point> q = new ArrayDeque<>();
	int i, j;
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		
		N = Integer.parseInt(br.readLine());
		map = new int[N][N]; // 입력부터 귀찮아 갈 수 있는 곳은 0으로!
		
		K = Integer.parseInt(br.readLine());
		for(int i=0; i<K; i++) {
			st = new StringTokenizer(br.readLine());
			int y = Integer.parseInt(st.nextToken());
			int x = Integer.parseInt(st.nextToken());
			map[y-1][x-1] = 1; // 사과는 1로 두기
		}
		
		K = Integer.parseInt(br.readLine());
		for(int i=0; i<K; i++) {
			st = new StringTokenizer(br.readLine());
			int sec = Integer.parseInt(st.nextToken());
			char move = st.nextToken().charAt(0);
			dp.add(new DPoint(sec, move));
		}// dp큐에 방향 변환 정보를 담기
		
		
		
		q.offer(new Point(0, 0)); //시작지점 넣어주기
		int i = 0, j = 0, sec = 0;
		
		while(true) {
			sec++;
			int y = i + dy[dir];
			int x = j + dx[dir];
			
			if(check(y, x)) // 벽이랑 몸통이랑 부딪히면 끝
				break;
			
			if(map[y][x] == 1) { // 앞에 사과라면
				map[y][x] = 0; // 와 설마 이거 안해줘서..? 맞네;
				q.offerLast(new Point(y, x));
			}else { // 사과가 아니라면
				q.offerLast(new Point(y, x)); // 머리 붙이기
				q.pollFirst(); // 꼬리 자르기
			}
			
			i = y;
			j = x; 
			
			if(!dp.isEmpty() && sec == dp.peek().sec) { // 비어있지 않고 현재 초와 입력받은 dp큐의 초가 같다면
				DPoint dpoint = dp.poll();
				if(dpoint.move == 'D') { // 오른쪽으로 가야한다면
					dir++;
					if(dir == 4) dir=0;
				}else { // 왼쪽으로 가야한다면
					dir--;
					if(dir == -1) dir = 3;
				}
			}
			
		}
		
		System.out.println(sec);
		
		
	}
	
	static boolean check(int y, int x) {
		if(y < 0 || x < 0 || y >= N || x >= N) {// 벽도 안부딪히고
			return true;
		}
		for(Point point : q) {
			if(y == point.y && x == point.x)
				return true;
		}
		return false;
	}
	
	static class Point{ // 좌표
		int y, x;
		Point(int y, int x){
			this.y = y;
			this.x = x;
		}
	}
	
	static class DPoint{ // 방향 변환 정보
		int sec;
		char move;
		DPoint(int sec, char move){
			this.sec = sec;
			this.move = move;
		}
	}
	
	

	
}

구현 문제.. 특히 삼성 SW 역량 기출문제들은 신경 쓸게 참 많은 것 같다. 그래도 재밌게 풀었던 문제
문제를 이해하는데 시간이 오래 걸렸는데 방향전환을 해줄 땐 내 머리가 아닌 뱀머리를 돌려야 된다. 내 입장에서 백날 돌리니 문제가 이해가 가지 않았다.. 뭐한 거지
벽이랑 몸통이랑 부딪히면 끝이 나기 때문에 따로 함수로 빼서 처리를 해주었다.
이어서 입력받은 맵에 사과가 있는 부분을 1로 해줬는데 사과를 먹으면 무조건 0으로 바꿔줘야 한다. 정말 당연한 건데 이 부분을 빼먹어서 애꿎은 시간만 버렸다.
이 문제의 핵심은 deque를 쓴다는 점과 뱀머리가 몸통에 닿을 때를 처리해주는 부분인 것 같다.

[알고리즘] 백준17144 미세먼지 안녕! - 자바

YunHyeok — Fri, 25 Feb 2022 19:57:49 +0900

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

17144번: 미세먼지 안녕!

미세먼지를 제거하기 위해 구사과는 공기청정기를 설치하려고 한다. 공기청정기의 성능을 테스트하기 위해 구사과는 집을 크기가 R×C인 격자판으로 나타냈고, 1×1 크기의 칸으로 나눴다. 구사

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class BOJ_17144_미세먼지안녕 {
	static int R, C, T, result;
	static ArrayList<Point> mList = new ArrayList<>(); // 먼지를 담을 리스트
	static ArrayList<Point> aList = new ArrayList<>(); // 공기청소기 좌표를 담을 리스트
	static int[] my = {-1, 1, 0, 0};
	static int[] mx = {0, 0, -1, 1}; // 먼지 델타
	static int[][] graph;
	static Queue<Point> q = new LinkedList<>();
	static int[] ay = {0, -1, 0, 1, 0, 1, 0, -1};
	static int[] ax = {1, 0, -1, 0, 1, 0, -1, 0}; // 공기청정기 상
	
	
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		R = Integer.parseInt(st.nextToken());
		C = Integer.parseInt(st.nextToken());
		T = Integer.parseInt(st.nextToken());
		graph = new int[R][C];
		
		for(int r=0; r<R; r++) {
			st = new StringTokenizer(br.readLine());
			for(int c=0; c<C; c++) {
				int weight = Integer.parseInt(st.nextToken());
				graph[r][c] = weight;
				if(weight > 0)
					mList.add(new Point(r, c, weight));
				else if(weight < 0)
					aList.add(new Point(r, c, -1));
			}
		}
		
		
		for(int t=0; t<T; t++) {
			//먼지 담기 
			for(int i=0; i<mList.size(); i++) {
				int y = mList.get(i).y;
				int x = mList.get(i).x;
				if(graph[y][x] < 5) continue;
				int cnt = 0;
				for(int m=0; m<4; m++) {
					int yy = y + my[m];
					int xx = x + mx[m];
					if(yy>=0 && xx>=0 && yy<R && xx<C) {
						if(graph[yy][xx] >= 0) {
							q.offer(new Point(yy, xx, graph[y][x]/5)); 
							cnt++;
						}
					}
				}
				graph[y][x] = graph[y][x] - graph[y][x]/5 * cnt;
			}
			
			//먼지 확산시키기
			bfs();
			
			//공기청정기 돌리기
			clean();
			
			mList = new ArrayList<>(); // 변한 맵에 먼지들을 다시 넣어줘야한다.
			for(int r=0; r<R; r++) {
				for(int c=0; c<C; c++) {
					if(graph[r][c] > 0)
						mList.add(new Point(r, c, graph[r][c]));
				}
			}

		}// 초
		
		print();
	}

	static class Point{
		int y, x, weight;
		Point(int y, int x, int weight){
			this.y = y;
			this.x = x;
			this.weight = weight;
		}
	}
	
	static void bfs() {
		while(!q.isEmpty()) {
			Point point = q.poll();
			graph[point.y][point.x] += point.weight;
		}
	}
	
	static void clean() {
		for(int i=0; i<aList.size(); i++) {
			int y = aList.get(i).y;
			int x = aList.get(i).x + 1;
			int dir = 0;
			int len = 3;
			int tmp = graph[y][x];
			graph[y][x] = 0;
			if(i==1) {
				dir = 4;
				len = 7;
			}
			
			while(true) {
				if(y == aList.get(i).y && x == aList.get(i).x) {
					graph[aList.get(i).y][aList.get(i).x] = -1;
					break;
				}
				if(dir > len) break;
				
				int yy = y + ay[dir];
				int xx = x + ax[dir];
				if(yy>=0 && xx>=0 && yy<R && xx<C) {
					int btmp = graph[yy][xx];
					graph[yy][xx] = tmp;
					tmp = btmp;
					y = yy;
					x = xx;
				}else {
					dir++;
				}
			}
		
		}
	}
	
	static void print() {
		for(int r=0; r<R; r++) {
			for(int c=0; c<C; c++) {
				if(graph[r][c] > 0) {
					result += graph[r][c];
				}
			}
		}
		System.out.println(result);
	}
}

미세먼지가 확산되는 부분만 신경 써주면 그 외는 쉽게 작성할 수 있었던 문제였습니다.
우선 미세먼지 좌표를 큐에 담아준 후에 bfs() 함수로 한 번에 처리해주면 됩니다. 확산되기 전에 미세먼지의 양이 더해져서 변경이 되면 안 되기 때문에 위처럼 작성했습니다.
확산도 되었고 공기청정기로 배열을 돌려주었다면 미세먼지를 담아두었던 mList를 갱신해주면 됩니다.

[알고리즘] 백준16954 움직이는 미로 탈출 - 자바

YunHyeok — Fri, 25 Feb 2022 00:38:02 +0900

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

16954번: 움직이는 미로 탈출

욱제는 학교 숙제로 크기가 8×8인 체스판에서 탈출하는 게임을 만들었다. 체스판의 모든 칸은 빈 칸 또는 벽 중 하나이다. 욱제의 캐릭터는 가장 왼쪽 아랫 칸에 있고, 이 캐릭터는 가장 오른쪽

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class BOJ_16954_움직이는미로탈출 {
	static ArrayList<char[]> list;
	static Queue<Point> q = new LinkedList<>();
	static int[] dy = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
	static int[] dx = {-1, 0, 1, -1, 0, 1, -1, 0, 1};
	static int N = 8;
	static boolean[][] visited;
	
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		list = new ArrayList<>();
		
		for(int i=0; i<N; i++) {
			list.add(br.readLine().toCharArray()); //맵을 계속 바꿔줘야해서 ArrayList로 선언
		}
		
		System.out.println(bfs());
	}
	
	static int bfs() {
		q.offer(new Point(N-1, 0));
		
		while(!q.isEmpty()) {
			visited = new boolean[N][N]; // 맵이 계속 바뀌니까 그때마다 초기화를 해줘야 함..
			
			int size = q.size(); // 무조건! 해줘야 함 for문안에서 poll을 하면 size가 변경이 되니까
			for(int s=0; s<size; s++) {
				Point point = q.poll();
				
				if(list.get(point.y)[point.x] == '#') continue; // 벽을 만나면 큐에서 다음 좌표를 부르기
				if(point.y == 0 && point.x == N-1) return 1; // 목적지에 도달했다면
				
				for(int d=0; d<9; d++) {
					int y = point.y + dy[d];
					int x = point.x + dx[d];
					if(y>=0 && x>=0 && y<N && x<N) {
						if(list.get(y)[x] == '.' && !visited[y][x]) {
							visited[y][x] = true;
							q.offer(new Point(y, x));
						}
					}
				}
			}
			
			list.remove(N-1); // 맨 아래에 행 삭제
			list.add(0, new char[] {'.', '.', '.', '.', '.', '.', '.', '.'}); //맨 위에 행 추가
			
		}
		return 0;
	}
	
	static class Point{
		int y, x;
		Point(int y, int x){
			this.y = y;
			this.x = x;
		}
	}
	

}

정말 정말 신경 쓸게 많은 문제였다. 심지어 예전에 풀어본 문제인데 또 막혀서 쩔쩔맸다.

list = new ArrayList<>();
		
for(int i=0; i<N; i++) {
	list.add(br.readLine().toCharArray()); //맵을 계속 바꿔줘야해서 ArrayList로 선언
}

먼저, 이 문제에서는 평소와 다르게 입력을 받았다. ArrayList에 char형 배열을 받도록 했는데 이유는 좌표가 이동하고 난 뒤에 벽이 내려와야 한다. 그래서 큐에 이동 가능한 좌표를 다 넣어줬다면 배열을 수정하기 위해 arraylist를 활용했다.

static int bfs() {
    q.offer(new Point(N-1, 0));

    while(!q.isEmpty()) {
        visited = new boolean[N][N]; // 맵이 계속 바뀌니까 그때마다 초기화를 해줘야 함..

        int size = q.size(); // 무조건! 해줘야 함 for문안에서 poll을 하면 size가 변경이 되니까
        for(int s=0; s<size; s++) {
            Point point = q.poll();

            if(list.get(point.y)[point.x] == '#') continue; // 벽을 만나면 큐에서 다음 좌표를 부르기
            if(point.y == 0 && point.x == N-1) return 1; // 목적지에 도달했다면

            for(int d=0; d<9; d++) {
                int y = point.y + dy[d];
                int x = point.x + dx[d];
                if(y>=0 && x>=0 && y<N && x<N) {
                    if(list.get(y)[x] == '.' && !visited[y][x]) {
                        visited[y][x] = true;
                        q.offer(new Point(y, x));
                    }
                }
            }
        }

        list.remove(N-1); // 맨 아래에 행 삭제
        list.add(0, new char[] {'.', '.', '.', '.', '.', '.', '.', '.'}); //맨 위에 행 추가

    }
    return 0;
}

bfs함수 안 반복문에서 중요했던 건 두 가지이다.

1. size = q.size() 를 설정한 후 큐에 담긴 좌표를 처리하는 것이다.
쉽게 말하면 벽이 떨어지기 전 맵에서 이동 가능한 좌표를 큐에 넣어준다. 그리고 모든 벽이 1칸씩 떨어진 바뀐 맵에서 이전에 큐에 넣어줬던 좌표들을 꺼내서 일괄 처리해주기 위함이다.

2. visted = new boolean[N][N] 를 계속 while문이 다시 시작할 때마다 초기화해주는데 어떻게 보면 당연하다. 이동거리는 제자리를 포함해서 9곳을 갈 수 있고 왔던 곳을 다시 가야 벽을 피할 수 있는 상황이 있을 것이다. (문제에는 해당 예제 입력이 없음!)

[알고리즘] 정올 1681 해밀턴 순환회로 - 자바

YunHyeok — Thu, 24 Feb 2022 21:49:52 +0900

http://jungol.co.kr/bbs/board.php?bo_table=pbank&code=1681

JUNGOL

www.jungol.co.kr

[풀이 코드]

package day0224;

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

public class JUNGOL_1681_해밀턴순환회로 {
	static int N;
	static boolean[] visited;
	static int[][] array;
	static int min = Integer.MAX_VALUE;
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		
		N = Integer.parseInt(br.readLine());
		
		visited = new boolean[N];
		array = new int[N][N];
		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j=0; j<N; j++) {
				array[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		
		visited[0] = true; // 첫번째 출발지점은 박아두고 시작하기! 
		dfs(0, 0);
		System.out.println(min);
	}
	
	static void dfs(int start, int distSum) {
		if(distSum > min) // 기존 min값보다 크다면 아래 조건문에 들어갈 필요가 없지
			return;
		
		if(visitCheck()) { 
			if(array[start][0] != 0) { // 다 방문하고 집에 올때도 이동비용이 0인 경우가 있네..
				distSum += array[start][0];
				min = Math.min(min, distSum);
			}
			return;
		}
		
		
		for(int i=0; i<N; i++) {
			if(!visited[i] && array[start][i] != 0) { //이동을 못하는 경우(0일때)는 제외해야지..문제 좀 읽자
				visited[i] = true;
				dfs(i, distSum + array[start][i]);
				visited[i] = false;
			}
		}
	}
	
	static boolean visitCheck() { // visited 탐색
		for(int i=0; i<N; i++) {
			if(!visited[i])
				return false;
		}
		return true;
	}
}

백준의 외판원 순회 2 문제와 거의? 똑같은 문제라서 복습도 되고 좋았던 문제
메인에서 dfs를 시작하기 전에 꼭 visited[0]을 해서 첫 번째 출발지점을 고정시킨 채로 시작해야 한다. 입력 예시의 N이 5개라면 처음 출발지점을 빼고 4개로 순열을 돌려야 했다.
예를 들면 {1, 2, 3, 4, 5}의 집합에서 1은 고정한채로 {2,3,4,5}, {2,3,5,4}, {2,4,3,5}... 이런 식으로!
또 이 문제를 풀 때 놓치기 쉬운 부분이 이동을 못하는 경우(0)가 있다. 이 부분은 조건문 통해 걸러주기!
if(distSum < min) 이 없으면 마지막 테스트 케이스를 시간제한 때문에 통과 못한다! 기존의 갱신된 min값 보다 작은 합은 사전에 return 시켜버리면 된다.

[알고리즘] 백준15686 치킨배달 - 자바

YunHyeok — Wed, 23 Feb 2022 23:54:21 +0900

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

15686번: 치킨 배달

크기가 N×N인 도시가 있다. 도시는 1×1크기의 칸으로 나누어져 있다. 도시의 각 칸은 빈 칸, 치킨집, 집 중 하나이다. 도시의 칸은 (r, c)와 같은 형태로 나타내고, r행 c열 또는 위에서부터 r번째 칸

www.acmicpc.net

[풀이 코드]

package day0223;

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

public class BOJ_15686_치킨배달 {
	static int N, M;
	static int result = Integer.MAX_VALUE;
	static class Point {
		int y, x;

		Point(int y, int x) {
			this.y = y;
			this.x = x;
		}
	}

	static List<Point> home = new ArrayList<>();
	static List<Point> chicken = new ArrayList<>();
	static boolean[] visited;

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

		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());
		
		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			
			for (int j = 0; j < N; j++) {
				int num = Integer.parseInt(st.nextToken());
				if (num == 1) {
					home.add(new Point(i, j));
				} else if (num == 2) {
					chicken.add(new Point(i, j));
				}
			}
		} // 집과 치킨집 따로 리스트에 담기 종료
		
		visited = new boolean[chicken.size()];
		dfs(0, 0);
		System.out.println(result);
	}

	static void dfs(int idx, int cnt) {
		if (idx == chicken.size()) { // 문제 좀 잘 읽자 진짜 개짜증나네
			if (cnt == M) { // 다풀고 뭐하는거야
				int dist = 0;
				for (int i = 0; i < home.size(); i++) {
					int htoc = Integer.MAX_VALUE;
					for (int j = 0; j <chicken.size(); j++) {
						if (visited[j]) {
							int hc = Math.abs(home.get(i).x - chicken.get(j).x)
									+ Math.abs(home.get(i).y - chicken.get(j).y);
							htoc = Math.min(htoc, hc);
						}
					}
					dist += htoc;
				} //거리비교for문
				result = Math.min(result, dist);
			} //cnt 조건
			return;
		}
		
		visited[idx] = true;
		dfs(idx + 1, cnt + 1);
		visited[idx] = false;
		dfs(idx + 1, cnt);
	}
	
}

문제의 예제 입력을 보고 DFS, BFS 탐색 문제겠지 싶었다... 하지만 조합 문제였고 로직은 그렇게 어렵지 않았다.
기저 조건을 설정해주는 부분에서 자꾸 헤매었는데 이건 문제를 제대로 안 읽어서 시간만 엄청 버렸다..!
이 문제의 포인트는 Point클래스를 활용해서 정점 관리를 해준 것인데 사실 그냥 new int [] {i, j} 이런 식으로 해도 된다. 하지만 자바니까 연습 중이다.
또 그래프로 입력을 받지만 ArrayList에 집과 치킨집을 따로 담아준다. 그리고 입력으로 주어지는 그래프에서 치킨집의 개수와 M은 다르다. 이걸 한참 후에 발견한 나는 틀려 마땅했다.

[알고리즘] 백준 2110 공유기 설치 - 자바

YunHyeok — Fri, 18 Feb 2022 23:29:29 +0900

공유기 설치 풀이노트

스터디때 발표를 하기 위해 정리했던 내용을 그대로 올려본다. 발표때마다 느끼지만 왤케 더듬지..

문제 이해하기

가장 인접한 두 공유기 사이의 거리를 최대

→ "공유기 3개를 설치하는데 공유기 사이 거리를 크게”

정렬 된 집 좌표 : 1_2__4___ 8_ 9

1_ 2_______ 9 1 7 → 가장 인접한 두 공유기의 거리는 7이 아닌 1

1___ 4____ 8 3 4 → 가장 인접한 두 공유기의 거리는 4가 아닌 3

정렬하기

house = new int[N];
        for(int i=0; i<N; i++) {
            house[i] = sc.nextInt(); 
        }
        Arrays.sort(house); // 이분 탐색하려면 무조건~

기준점 정하기

// '거리' 가 기준!!!
        int start = 1; //최소로 이동할 수 있는 거리는 1이겠지
        int end = house[N-1] - house[0]; //최대로 이동할 수 있는 거리는 8!

이분탐색시작

while(start <= end) { 
            int houseCnt =0;
            int mid = (start + end) /2; // 그럼 중간 값부터 탐색을 시작 
            **int installed = house[0]; // #1. 무조건 처음 집부터 해야함!**
            houseCnt++; 

            for(int i=1; i<house.length; i++) {
                **if(mid + installed <= house[i])** {//#2. 중간값 + 공유기설치한집의 좌표 보다 다음 집의 좌표가 크다면
                    installed = house[i]; 
                    houseCnt++;
                }
            }

            if(houseCnt < C) { // 공유기를 다 설치 못했다. end 갱신해서 다시
                end = mid-1; 
            }else { // 공유기 설치는 다했다. 그래도 중간값 올려서 start가 end보다 커질때까지 탐색해보기
                start = mid+1; 
                result = mid; // 일단, 답을 담아두자
            }

}

부분설명

int houseCnt =0;
            int mid = (start + end) /2; // 그럼 중간 값부터 탐색을 시작 
            **int installed = house[0]; // #1. 무조건 처음 집부터 해야함!**
            houseCnt++; // 공유기 한대 설치했으니까

1 2 4 → 1

1 2 8 → 1

1 2 9 → 1

1 4 8 → 3

1 4 9 → 3

1 8 9 → 1

2 4 8 → 2

2 4 9 → 2

2 8 9 → 1

4 8 9 → 1

모든 경우의 수를 나열해봤을 때 처음 시작은 무조건 1로 시작해야 답이 나온다. 2부터 시작하면 최댓값이 안나오는건 당연한 것 같다.
이렇게 나열해보니 조합으로 풀어볼 수 있지 않을까 싶어 코드를 작성해봤다.

조합으로도 풀 수 있을까?

import java.util.Arrays;
import java.util.Scanner;

public class BOJ_2110_공유기설치2 {
    static int N, C, result;
    static int[] array;
    static int max = Integer.MIN_VALUE;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt(); // 집
        C = sc.nextInt(); // 공유기 수

        array = new int[N];
        for(int i=0; i<N; i++) {
            array[i] = sc.nextInt(); 
        }
        Arrays.sort(array); // 이분 탐색하려면 무조건~

        dfs(0, 0, "");
        System.out.println(max);
    }
    static void dfs(int idx, int cnt, String str) {
        if(cnt == C) {
//            System.out.println(str);
            int arrayMin = Integer.MAX_VALUE;
            for(int i=0; i<str.length()-1; i++) {
                int a = Math.abs(str.charAt(i) - str.charAt(i+1));
                arrayMin = Math.min(arrayMin, a);
            }
            max = Math.max(max, arrayMin);

            return;
        }
        if(idx>=N)
            return;

        dfs(idx+1, cnt+1, str + array[idx]);
        dfs(idx+1, cnt, str);
    }
}

답은 메모리초과가 되었다. 만약 이 문제를 보고 누군가는 조합이라고 생각되어 문제를 풀 수도 있을 것 같다.

그런 경우는 어떻게 시간복잡도를 생각해서 문제에 접근해야할지 스터디원에게 질문을 했었는데

문제 조건에 입력의 개수는 적은데 주어지는 수가 많은 경우 이분탐색을 의심해보기
구글에 조합계산기를 검색 후 직접 검색하보면서 시간복잡도를 따져보기

아직 시간복잡도를 계산하고 그 문제를 어떻게 풀어야할지는 아직은 감이 부족한 것 같아 앞으로 만나는 문제마다 고민을 해봐야 겠다.

#2. 반복문 설명

for(int i=1; i<house.length; i++) {
                **if(mid + installed <= house[i])** {//#2. 중간값 + 공유기설치한집의 좌표 보다 다음 집의 좌표가 크다면
                    installed = house[i]; 
                    houseCnt++;
                }
            }

중간값 + 공유기설치한집의 좌표 보다 다음 집의 좌표가 크다면 installed값을 해당 좌표로 변경해주고 공유기를 설치했으니 hoseCnt를 올려준다.

#3. 마지막 조건문 설명

if(houseCnt < C) { // 공유기를 다 설치 못했다. end 갱신해서 다시
                end = mid-1; 
            }else { // 공유기 설치는 다했다. 그래도 중간값 올려서 start가 end보다 커질때까지 탐색해보기
                start = mid+1; 
                result = mid; // 일단, 답을 담아두자
            }

중간값의 변화를 출력해보면 아래와 같다.

총 반복문은 3번을 돌며 mid값은 4 -> 2 -> 3 순으로 변경되며 탐색을 한다.

[알고리즘] 백준3109 빵집 - 자바

YunHyeok — Thu, 17 Feb 2022 17:05:43 +0900

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

3109번: 빵집

유명한 제빵사 김원웅은 빵집을 운영하고 있다. 원웅이의 빵집은 글로벌 재정 위기를 피해가지 못했고, 결국 심각한 재정 위기에 빠졌다. 원웅이는 지출을 줄이고자 여기저기 지출을 살펴보던

www.acmicpc.net

[풀이 코드]

package day0217;

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

public class BOJ_3109_빵집 {
	static int R, C, cnt;
	static char[][] graph;
	static boolean[][] visited;
	static int[] dy = {-1, 0, 1};
	static int[] dx = {1, 1, 1};
	static boolean flag; // 스택에 쌓여있는 재귀들을 처리해주기 위함
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		R = Integer.parseInt(st.nextToken());
		C = Integer.parseInt(st.nextToken());
		
		graph = new char[R][C];
		visited = new boolean[R][C];
		for(int r=0; r<R; r++) {
			String str = br.readLine();
			for(int c=0; c<C; c++) {
				graph[r][c] = str.charAt(c);
			}
		}//그래프 담기
		
		for(int i=0; i<R; i++) {
			flag = false; // 스택에 쌓여있는 재귀처리를 위한 변수
			dfs(i, 0);
		}
		
		System.out.println(cnt);
	}
	
	static void dfs(int y, int x) {
		if(x==C-1) { // 끝에 도달했다면
			flag = true; // true로 변경하고 쌓였있던 재귀함수들 다 return시키기
			cnt++; 
			return;
		}
		
		for(int d=0; d<3; d++) {//오른쪽위, 오른쪽, 오른쪽아래 순서
			int yy = y + dy[d];
			int xx = x + dx[d];
			if(yy>=0 && xx>=0 && yy<R && xx<C) { //범위초과하지 않았다면
				if(!visited[yy][xx] && graph[yy][xx] == '.') { // 방문한적 없고 이동가능한 경우라면
					visited[yy][xx] = true; // 방문처리
					dfs(yy, xx); // 이동
					if(flag) return; // 쌓여있던 스택을 처리해주기 위함
				}
			}
		}//for종료
	}
	
}

스택에 쌓여있는 재귀를 처리해주는 게 중요했던 문제였다. 처음에는 그냥 끝에 닿았으면 return 하거나 다음 for문이 실행 안되게끔 break를 걸면 되지 않을까 생각했었다.
메인 문에서 for문을 통해 출발지점 순서대로 dfs문을 실행시키기 전에 flag변수를 false로 초기화하고 시작한다.
그림과 같이 스택에는 dfs(1,3)가 dfs(0, 4)를 방문하고 dfs(1,4), dfs(2,4)를 방문하려고 하겠지만 이미 (0, 4)에서 파이프 하나를 생성했기 때문에 dfs(1, 4), dfs(2, 4)를 방문하면 안 됐다.
- 이 부분에서 막혔고 이를 처리하기 위해서 flag를 변수를 두어 (0, 4)에 도달했다면 true를 저장하고 쌓여있던 dfs(1, 3)에게 true면 return 시키도록 했다. 그럼 dfs(1, 4), dfs(2,4)를 방문하지 않고 연쇄적으로 스택에 쌓여있던 재귀 함수들은 종료될 것이다.
위 그림이 예제의 확실한 정답인지 모르겠지만 빨간색은 연결되면 안 되는 파이프이고 파란색이 파이프가 연결된 선이다.

[알고리즘] 백준2630 색종이만들기 - 자바

YunHyeok — Thu, 17 Feb 2022 09:35:31 +0900

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

2630번: 색종이 만들기

첫째 줄에는 전체 종이의 한 변의 길이 N이 주어져 있다. N은 2, 4, 8, 16, 32, 64, 128 중 하나이다. 색종이의 각 가로줄의 정사각형칸들의 색이 윗줄부터 차례로 둘째 줄부터 마지막 줄까지 주어진다.

www.acmicpc.net

[풀이 코드]

package day0217;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class BOJ_2630_색종이만들기 {
	static int N, wCnt, bCnt;
	static int[][] array;
	static int[] color = new int[2];
	
	public static void main(String[] args) throws IOException{
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		N = Integer.parseInt(br.readLine());
		
		array = new int[N][N];
		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j=0; j<N; j++) {
				array[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		
		dfs(0, 0, N, N);
		for(int c : color) {
			System.out.println(c);
		}
	}
	
	static void dfs(int si, int sj, int ei, int ej) {
		boolean flag = true;
		int tmp = array[si][sj];
		for(int i=si; i<ei; i++) {
			for(int j=sj; j<ej; j++) {
				if(tmp != array[i][j]) flag = false; 
			}
		}
		if(flag) {
			color[tmp]++;
		}else {
			if(ei-si==1) {
				if(array[si][sj]==0) color[0]++;
				if(array[si][sj]==1) color[1]++;
				return;
			}
			
			int mi = (si+ei)/2;
			int mj = (sj+ej)/2;
			
			dfs(si, sj, mi, mj);
			dfs(si, mj, mi, ej);
			dfs(mi, sj, ei, mj);
			dfs(mi, mj, ei, ej);
		}
		
		
	}
}

쿼드 트리를 풀었다면 쉽게 쉽게 풀 문제! 쿼드트리 코드랑 크게 다르지 않다~!

[알고리즘] 백준1992 쿼드트리 - 자바

YunHyeok — Thu, 17 Feb 2022 02:03:01 +0900

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

1992번: 쿼드트리

첫째 줄에는 영상의 크기를 나타내는 숫자 N 이 주어진다. N 은 언제나 2의 제곱수로 주어지며, 1 ≤ N ≤ 64의 범위를 가진다. 두 번째 줄부터는 길이 N의 문자열이 N개 들어온다. 각 문자열은 0 또

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
	static int N;
	static int[][] array;
	static StringBuilder sb = new StringBuilder();
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		N = Integer.parseInt(br.readLine());
		array = new int[N][N];
		for(int i=0; i< N; i++) {
			String str = br.readLine();
			for(int j=0; j<N; j++) {
				array[i][j] = str.charAt(j)-'0';
			}
		}//배열담기
		
		dfs(0, 0, N, N);
		System.out.println(sb);
		
	}
	// 범위를 줄여나가면서 재귀! 
	// 8x8 -> 4x4(왼쪽위) 4x4(오른쪽위) 4x4(왼쪽아래) 4x4(오른쪽아래)
	// 4x4 -> 2x2(왼쪽위) 2x2(오른쪽위) 2x2(왼쪽아래) 2x2(오른쪽아래)
	// 2x2 -> 1x1(왼쪽위) 1x1(오른쪽위) 1x1(왼쪽아래) 1x1(오른쪽아래) <= 한칸부터 append 시작!
	
	static void dfs(int si, int sj, int ei, int ej) {
		//주어진 si,sj(시작인덱스)부터 ei,ej(끝인덱스)까지 압축이 가능한지 탐색 
		boolean flag = true;
		int tmp = array[si][sj];
		for(int i=si; i<ei; i++) {
			for(int j=sj; j<ej; j++) {
				if(tmp != array[i][j]) flag = false; 
			}
		}
		
		if(flag) {//압축 가능 
			sb.append(tmp);
		}else { //압축 불가능
			if(ei-si == 1) {//더 이상 쪼개질 수 없는 1x1칸의 경우 append해준다.
				if(array[si][sj] == 0) sb.append(0);
				else if(array[si][sj] == 1) sb.append(1);
				return;
			}
			
			int mi = (si+ei)/2; // y축 중간값 
			int mj = (sj+ej)/2; // x축 중간값
			
			sb.append('('); //시작 괄호 붙이기
			dfs(si, sj, mi, mj);
			dfs(si, mj, mi, ej);
			dfs(mi, sj, ei, mj);
			dfs(mi, mj, ei, ej);
			sb.append(')'); // 끝 괄호 붙이기
		}
		
	}

}

코테볼떈 갤탭못쓰는데 어쩌지

Z문제를 풀어서 그런지 어떻게 풀어야 할지는 감이 잡혔던 분할 정복 문제였다.
풀이 로직
1. dfs함수의 매개변수로는 입력받은 NxN배열의 시작 인덱스와 끝인덱스를 넣어준다.

2. dfs함수 입장하자마자 시작인덱스와 끝 인덱스까지 압축을 할 수 있는지 이중 for문을 돌아준다.
- 압축할 수 있는 경우 StringBuilder에 해당 압축 가능했던 수를 넣어준다. (코드에서는 array [si][sj])
- 압축할 수 없는 경우라면 else문을 통해 다시 재귀를 돌 준비를 한다.

3. mi, mj는 영역을 분할하기 위함이다. 8x8배열을 4x4(왼쪽 위) 4x4(오른쪽 위) 4x4(왼쪽 아래) 4x4(오른쪽 아래) 배열로 나눈다.

4. 나눈 영역을 다시 재귀를 돌아주며 압축이 불가능하고 ei-si가 1인 경우 즉, 더 이상 쪼개질 수 없는 1x1칸의 경우라면 하나씩 StringBuilder에 append 해주면 된다.

어제 새벽까지 Z문제 때문에 고생했는데 오늘 보답받은 기분... 오늘은 맘 편히 자야겠다~!

[알고리즘] SWEA 요리사 - 자바

YunHyeok — Wed, 16 Feb 2022 20:57:48 +0900

[풀이 코드]

package day0214;

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

public class SWEA_요리사 {
	static int TC;
	static int N;
	static int[][] array;
	static int min = Integer.MAX_VALUE;
	static boolean[] visited;
	
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		
		TC = stoi(br.readLine());
		for(int tc=1; tc<=TC; tc++) {
			N = stoi(br.readLine());
			array = new int[N][N];
			
			for(int i=0; i<N; i++) {
				st = new StringTokenizer(br.readLine());
				for(int j=0; j<N; j++) {
					array[i][j] = stoi(st.nextToken());
				}
			}
			min = Integer.MAX_VALUE;
			visited = new boolean[N];
			dfs(0, 0);
			System.out.printf("#%d %d \n",tc, min);
		}
	}
	
	
	static void dfs(int idx, int cnt) {
		if(cnt == N/2) {
			int ans = diff(); // ans : 두 요리의 차이
			min = Math.min(min, ans); // 제일 적은 두 요리의 차이 리턴
			return;
		}
		if(idx>=N)
			return;
		
		visited[idx]=true;
		dfs(idx+1, cnt+1);
		visited[idx]=false;
		dfs(idx+1, cnt);
					
	}
	
	static int diff() {
		int aSum =0; // a요리
		int bSum =0; // b요리
		
		for(int i=0;i<N-1;i++) { // 나눠진 식재료를 가지고 a요리, b요리 만들기
            for(int j=i+1;j<N;j++) {
                if(visited[i] && visited[j]) aSum+=array[i][j]+array[j][i]; 
                else if(!visited[i] && !visited[j]) bSum+=array[i][j]+array[j][i];
            }
        }

		return Math.abs(aSum - bSum); // 두 요리의 차이
	}
	
	static int stoi(String s) {
		return Integer.parseInt(s);
	}
}

로직은 맞았으나 예제 입력 8번부터 10번까지 답이 이상하게 나왔다. 도대체 뭐가 문제인 건지 헤매다가 기존에는 재귀 함수를 아래와 같이 작성했다.
diff() 함수에서는 나누어진 식재료를 가지고 이중 for문을 돌면서 요리를 만드는 과정이다. 이 과정을 생각하는 것 또한 오래 걸렸다. 애초에 방문 배열을 썼으면 쉽게 풀렸을걸..

[이전 코드]

static void dfs(int idx, int cnt, String str) {
		if(cnt == N/2) {
			int ans = diff(str); // ans : 두 요리의 차이
			min = Math.min(min, ans); // 제일 적은 두 요리의 차이 리턴
			return;
		}
		if(idx>=N)
			return;
		
		dfs(idx+1, cnt+1, str+idx);
		dfs(idx+1, cnt, str);
	}
    
static int diff() {
    int aSum =0; // a요리
    int bSum =0; // b요리

    boolean[] visited = new boolean[N];
    for(int i=0; i<str.length(); i++){
        visited[str.charAt(i)-'0'] = true; 
    }
        
    for(int i=0;i<N-1;i++) { // 나눠진 식재료를 가지고 a요리, b요리 만들기
        for(int j=i+1;j<N;j++) {
            if(visited[i] && visited[j]) aSum+=array[i][j]+array[j][i]; 
            else if(!visited[i] && !visited[j]) bSum+=array[i][j]+array[j][i];
        }
    }

    return Math.abs(aSum - bSum); // 두 요리의 차이
}

애초에 dfs(0, 0, "")로 시작해서 idx값을 str에 누적해주는 식으로 했다. 아직까지는 위의 코드의 문제점을 찾지 못했고 추측되는 이유는 str에 들어가지 못한 idx값이 있을 것이라는 것과 String객체를 계속 전달하면서 생길 수 있는 문제가 있는 것..?
아무튼 이것 때문에 시간 다 날렸다... 간단하게 풀려고 하다가 오히려 시간이 더 걸린 문제ㅜ

[알고리즘] 백준16935 배열돌리기3 - 자바

YunHyeok — Sun, 13 Feb 2022 18:08:49 +0900

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

16935번: 배열 돌리기 3

크기가 N×M인 배열이 있을 때, 배열에 연산을 R번 적용하려고 한다. 연산은 총 6가지가 있다. 1번 연산은 배열을 상하 반전시키는 연산이다. 1 6 2 9 8 4 → 4 2 9 3 1 8 7 2 6 9 8 2 → 9 2 3 6 1 5 1 8 3 4 2 9 →

www.acmicpc.net

[풀이 흔적]

끄적끄적

[풀이 코드]

package graphtraversal;

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

public class BOJ_16935_배열돌리기3 {
	static int N, M, R, K;
	static int[][] graph;
	static int[][] upGraph;

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());
		R = Integer.parseInt(st.nextToken());

		graph = new int[N][M];
		upGraph = new int[N][M];
		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j = 0; j < M; j++) {
				graph[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		
		st = new StringTokenizer(br.readLine());
		
		for (int rr = 0; rr < R; rr++) {
			K = Integer.parseInt(st.nextToken());
			
			if (K == 1) { // 상하반전
				for(int c=0; c<graph[0].length; c++) {
					for(int r1=0, r2=graph.length -1; r1<r2; r1++, r2--) {
						int temp = graph[r1][c];
						graph[r1][c] = graph[r2][c];
						graph[r2][c] = temp;
					}
				}
			
			} else if (K == 2) { // 좌우반전
				for(int r=0; r<graph.length; r++) {
					for(int c1=0, c2=graph[0].length-1; c1<c2; c1++,c2--) {
						int temp = graph[r][c1];
						graph[r][c1] = graph[r][c2];
						graph[r][c2] = temp;
					}
				}
			} else if (K == 3) { // 오른쪽 90도
				int[][] result = new int[graph[0].length][graph.length];

				for (int i = 0; i < graph.length; i++) {
					for (int j = 0; j < graph[0].length; j++) {
						result[j][graph.length - 1 - i] = graph[i][j];
					}
				}
				graph = result;

			} else if (K == 4) { // 왼쪽 90도
				int[][] result = new int[graph[0].length][graph.length];

				for (int i = 0; i < graph.length; i++) {
					for (int j = 0; j < graph[0].length; j++) {
						result[graph[0].length - 1 - j][i] = graph[i][j];
					}
				}
				graph = result;

			} else if (K == 5) { // 그룹나누고 오른쪽 방향으로
				int[][] result = new int[graph.length][graph[0].length];
				int r = graph.length; // 3,4 실행시 r,c가 달라지니까 무조건..
				int c = graph[0].length;
				
				// 1 -> 2
				for (int i = 0; i < r / 2; i++) {
					for (int j = 0; j < c / 2; j++) {
						result[i][(c / 2) + j] = graph[i][j];
					}
				}
				// 2 -> 3
				for (int i = 0; i < r / 2; i++) {
					for (int j = c / 2; j < c; j++) {
						result[(r / 2) + i][j] = graph[i][j];
					}
				}
				// 3 -> 4
				for (int i = r / 2; i < r; i++) {
					for (int j = c / 2; j < c; j++) {
						result[i][j - (c / 2)] = graph[i][j];
					}
				}
				// 4 -> 1
				for (int i = r / 2; i < r; i++) {
					for (int j = 0; j < c / 2; j++) {
						result[i - (r / 2)][j] = graph[i][j];
					}
				}

				graph = result;

			} else if(K==6) { // 그룹나누고 왼쪽 방향으로
				int[][] result = new int[graph.length][graph[0].length];
				int r = graph.length; // 3,4 실행시 r,c가 달라지니까 무조건..
				int c = graph[0].length;
				
				// 1 -> 4
				for (int i = 0; i < r / 2; i++) {
					for (int j = 0; j < c / 2; j++) {
						result[(r/2)+i][j] = graph[i][j];
					}
				}
				// 4 -> 3
				for (int i = r/2; i<r; i++) {
					for (int j = 0; j<c/2; j++) {
						result[i][(c/2)+j] = graph[i][j];
					}
				}
				// 3 -> 2
				for (int i = r/2; i<r; i++) {
					for (int j = c/2; j<c; j++) {
						result[i-(r/2)][j] = graph[i][j];
					}
				}
				// 2 -> 1
				for (int i =0; i < r/2; i++) {
					for (int j = c/2; j < c; j++) {
						result[i][j-(c/2)] = graph[i][j];
					}
				}

				graph = result;
			}
		}
		print();

	}

	static void print() {
		for (int i = 0; i < graph.length; i++) {
			for (int j = 0; j < graph[i].length; j++) {
				System.out.print(graph[i][j] + " ");
			}
			System.out.println();
		}
	}
}

진짜 머리 아팠던 배열 돌리기 3 문제.. 상하반전과 좌우반전은 원래 아래와 같은 코드를 썼다가 블로그의 다른 풀이를 참고해서 위 코드처럼 변경했다.

if (K == 1) { // 상하반전
				int r = graph.length;
				int c = graph[0].length;
				for (int i = r - 1; i >= 0; i--) {
					for (int j = 0; j < c; j++) {
						upGraph[(r - 1) - i][j] = graph[i][j];
					}
				}
				for (int i = 0; i < graph.length; i++)
					System.arraycopy(upGraph[i], 0, graph[i], 0, upGraph[i].length);
			
			} else if (K == 2) { // 좌우반전
				int r = graph.length;
				int c = graph[0].length;
				for (int i = 0; i < r; i++) {
					for (int j = c - 1; j >= 0; j--) {
						upGraph[i][(c - 1) - j] = graph[i][j];
					}
				}
				for (int i = 0; i < graph.length; i++)
					System.arraycopy(upGraph[i], 0, graph[i], 0, upGraph[i].length);

확실히 어렵게 푸는데 재능이 있는 것 같다.
그리고 계속 런타임에러(인덱스초과)가 떴는데 이유는 좌우로 90도 돌리기를 하면 N과 M(가로, 세로) 값이 바뀌게 된다. 이 부분을 생각 안 해줬다가 크게 당했다.. 5,6 연산을 할 때는 반드시 현재 변경된 2차원 배열의 N과 M을 잘 생각해야 한다.
스위치문 써볼걸

[알고리즘] 백준16927 배열돌리기2 - 자바

YunHyeok — Sat, 12 Feb 2022 01:53:36 +0900

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

16927번: 배열 돌리기 2

크기가 N×M인 배열이 있을 때, 배열을 돌려보려고 한다. 배열은 다음과 같이 반시계 방향으로 돌려야 한다. A[1][1] ← A[1][2] ← A[1][3] ← A[1][4] ← A[1][5] ↓ ↑ A[2][1] A[2][2] ← A[2][3] ← A[2][4] A[2][5]

www.acmicpc.net

[풀이 코드]

package day0211;

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

public class BOJ_16927_배열돌리기2 {
	static int N, M, R;
	static int[] dy = {1, 0, -1, 0}; // 하우상좌
	static int[] dx = {0, 1, 0, -1};
	static int[][] graph;
	static boolean[][] visited;

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		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());
		R = Integer.parseInt(st.nextToken());

		graph = new int[N][M];

		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j = 0; j < M; j++) {
				graph[i][j] = Integer.parseInt(st.nextToken());
			}
		} // 배열 담기
		
		
		// 1씩 전진하는게 아닌 입력받은 R만큼 전진시켜야한다.
		// n번째 테두리마다 다른 수로 전진을 해야하는데
		// 예제2를 예를 들면 첫번째 테두리는 한번에 7칸씩이동을, 두번째 안쪽테두리는 1칸씩 이동만 한다.
		//첫번쨰의 반복문 2*5 + 2*4 -4 = 14칸(겉테두리)
		//두번째의 반복문 2*3 + 2*2 -4 = 6칸(속테두리)
		int n=N, m=M;
		for(int i=0; i<Math.min(N, M)/2; i++) {
			rotate(i, 2*n + 2*m -4);
			n-=2;
			m-=2;
		}
		
		
		for (int i = 0; i < N; i++) { 
			for (int j = 0; j < M; j++) {
				sb.append(graph[i][j] + " ");
			}
			sb.append("\n");
		} // 배열출력
		System.out.println(sb);
	}
	
	static void rotate(int start, int len) {
		//rLen은 총 몇바퀴 돌아야되는지 예제입력2를 예를 들면 7, 1이 나온다. 
		// 즉, 첫번째 겉 테두리는 7번 회전을, 두번째 속 테두리는 1번만 회전하면 된다.
		int rLen = R%len; 

		for (int j = 0; j < rLen; j++) {// 사각형 내에서 몇번을 돌지
			int y = start;
			int x = start;
			int idx = 0;
			int pre = graph[start][start];
			int tmp = 0;
			
			while (idx < 4) {
				int yy = y + dy[idx];
				int xx = x + dx[idx];
				if (yy >= start && yy < N - start && xx >= start && xx < M - start) {
					tmp = graph[yy][xx];
					graph[yy][xx] = pre;
					pre = tmp;
					y = yy;
					x = xx;
				} else idx++;
			}
			
		}

	}
}

배열 돌리기 2는 주어지는 R값이 훨씬 커서 불필요한 회전을 줄여야 한다. 여기서 불필요한 회전이란 한 바퀴를 돌아 제자리로 찾아가는 것을 말한다.
어떻게 풀어야할지 막막해서 결국 답을 보고 이해했는데 역시 알고리즘은 수학 머리가 있으면 유리하다는 걸 다시 한번 느꼈다. rotate 함수의 매개변수에 2*n + 2*m -4 수식과 n과m을 2씩 빼주는 이유는 주석에 달아놨다. (수학 수학 수학)
rotate함수 안에서 입력받은 '회전 수 R'을 각 반복문에 해당하는 '테두리의 칸 수'로 나눈 나머지를 구하는데 이는 해당 반복문에서 얼마나 회전을 해야 할지 구하기 위함이다.
배열 돌리기 문제를 풀어보니 정말 좋은 문제 같다.. 주말에 한 번씩 다시 봐야겠다!

[알고리즘] 백준16926 배열돌리기1 - 자바

YunHyeok — Fri, 11 Feb 2022 16:25:53 +0900

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

16926번: 배열 돌리기 1

www.acmicpc.net

[재귀 풀이 코드]

package day0211;

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

public class BOJ_16926_배열돌리기 {
	static int N, M, R, tmp, idx, depth;
	static int[] dy = {1, 0, -1, 0};
	static int[] dx = {0, 1, 0, -1};
	static int[][] graph;
	static boolean[][] visited; 
	
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());
		R = Integer.parseInt(st.nextToken());
		
		graph = new int[N][M];
		
		
		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j=0; j<M; j++) {
				graph[i][j] = Integer.parseInt(st.nextToken());
			}
		} // 배열 담기
		
		
		for(int r=0; r<R; r++) {//회전시작
			visited = new boolean[N][M];
		
			for(int i=0; i< Math.min(N, M)/2; i++){
				tmp = graph[depth][depth];
				dfs(depth, depth);
				idx = 0; // 하 우 상 좌
				depth++;
			}
			depth = 0;
			
		}// 회전종료
		
		for(int i=0; i<N; i++) {
			for(int j=0; j<M; j++) {
				System.out.print(graph[i][j] + " ");
			}
			System.out.println();
		}// 배열출력
		
	}
	static void dfs(int y, int x) {
		int pre = tmp; // 이전 값 저장
		
		while(idx<4) {
			int yy = y + dy[idx];
			int xx = x + dx[idx];
			
			if(yy>=0 && yy<N && xx>=0 && xx<M && !visited[yy][xx]) {
				tmp = graph[yy][xx];
				graph[yy][xx] = pre;
				visited[yy][xx] = true;
				dfs(yy, xx);
			}else {//만약, 범위내통과x 방문체크x
				idx++;
			}
		}
		
	}
}

풀이 흔적

그래프만 보면 BFS만 애용했기에.. 큰 맘먹고 DFS로 도전해보았지만 그냥 반복문으로 해결할 수 있는 문제라는 것..
tmp, idx, depth변수는 순서대로 tmp는 이전 배열의 값을 담는 목적, idx는 델타 배열인 dy, dx의 인덱스를 위해 설정했다. 재귀로 했기에 범위가 벗어나면 idx를 +1 해준다. 여기서 dy, dx 배열은 순서가 무조건 반시계 방향인 하, 우, 상, 좌 순으로 선언해야 한다.
재귀를 들어가기 전 회전이 시작되는 for문에서는 Math.min(N, M)/2를 통해 회전이 배열 안에서 총 몇 번 도는지 구했다. 처음에는 이중 for문을 써서 방문을 하지 않은 경우 돌게끔 해서 수정을 했지만 속도 차이는 크게 차이가 없었다.
dfs함수는 이전 값을 저장하는 것과 범위가 벗어나면 idx++ 해주는 부분이 핵심인 것 같다.

[반복문 풀이 코드]

package day0211;

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

public class BOJ_16927_배열돌리기2 {
	static int N, M, R;
//	static int[] dy = {0, 1, 0, -1}; // 우하좌상
//	static int[] dx = {1, 0, -1, 0};
	
	static int[] dy = {1, 0, -1, 0}; // 하우상좌
	static int[] dx = {0, 1, 0, -1};
	static int[][] graph;
	static boolean[][] visited;

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());
		R = Integer.parseInt(st.nextToken());

		graph = new int[N][M];

		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j = 0; j < M; j++) {
				graph[i][j] = Integer.parseInt(st.nextToken());
			}
		} // 배열 담기

		for (int r = 0; r < R; r++) {// 회전시작
			for (int j = 0; j < Math.min(N, M) / 2; j++) {// 사각형 내에서 몇번을 돌지
				int y = j;
				int x = j;

				int idx = 0;
				int pre = graph[y][x];
				int tmp = 0;
				while (idx < 4) {
					int yy = y + dy[idx];
					int xx = x + dx[idx];
					if (yy >= j && yy < N - j && xx >= j && xx < M - j) {
						tmp = graph[yy][xx];
						graph[yy][xx] = pre;
						pre = tmp;
						y = yy;
						x = xx;
					} else
						idx++;
				}
				
			}
		} // 회전종료

		for (int i = 0; i < N; i++) {
			for (int j = 0; j < M; j++) {
				System.out.print(graph[i][j] + " ");
			}
			System.out.println();
		} // 배열출력

	}
}

[성능 차이]

1540ms가 나온건 반복문 2184ms가 나온건 재귀다. 속도차이는 꽤?? 나는건가 모르겠다. 아직 볼 줄 몰라서.. 그래도 메모리나 속도적인 부분은 반복문이 훨씬 수치가 적게 나왔다.

[알고리즘] 백준 10971 외판원순회 - 자바

YunHyeok — Thu, 10 Feb 2022 01:45:54 +0900

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

10971번: 외판원 순회 2

첫째 줄에 도시의 수 N이 주어진다. (2 ≤ N ≤ 10) 다음 N개의 줄에는 비용 행렬이 주어진다. 각 행렬의 성분은 1,000,000 이하의 양의 정수이며, 갈 수 없는 경우는 0이 주어진다. W[i][j]는 도시 i에서 j

www.acmicpc.net

[풀이 코드]

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

public class BOJ_10971_외판원순회2 {
	static int N;
	static int[][] array;
	static boolean[] visited;
	static long min = Integer.MAX_VALUE; // 각 행렬의 성분은 1,000,000이하의 양의 정수
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		
		N = Integer.parseInt(br.readLine());
		array = new int[N][N];
		
		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j=0; j<N; j++) {
				array[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		
		for(int i=0; i<N; i++) {
			visited = new boolean[N];
			visited[i] = true;
			dfs(i, i, 0);
		}
		
		System.out.println(min);
		
	}
	static void dfs(int start, int end, int sum) {
		if(visitCheck()) { 
			if(array[start][end] != 0) {
				sum += array[start][end];
				min = Math.min(min, sum);
			}
			return;
		}
		
		for(int i=0; i<N; i++) {
			if(array[start][i] != 0 && !visited[i]) {
				visited[i] = true;
				dfs(i, end, sum + array[start][i]);
				visited[i] = false;
			}
		}
	}
	
	static boolean visitCheck() { // visited 탐색
		for(int i=0; i<N; i++) {
			if(!visited[i])
				return false;
		}
		return true;
	}

}

설계? 구상을 꼼꼼히 해서 코딩하는데 시간이 오래 걸리진 않았다.. 어느 정도 필기를 하고 푸는 건 좋지만 좀 간략히 쓰는 연습을 해야겠다.
각 행렬의 성분은 1,000,000 이하의 양의 정수 라는 문장을 보고 min값을 1000000을 줬는데 이 부분이 문제였던 것 같다. 뭐가 문제인지 몰라서 계속 헤매다가 블로그를 참고했다... 다 풀었는데ㅜ

쉬운 게 없다~

[코드 수정]

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

public class BOJ_10971_외판원순회2_다른풀이 {
	private static int N; // 도시의 수
	private static int[][] map; // 경로
	private static boolean[] isVisited; // 도시 방문 여부
	private static int answer = Integer.MAX_VALUE;

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		N = Integer.parseInt(br.readLine());
		
		map = new int[N][N];
		isVisited = new boolean[N];
		
		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j = 0; j < N; j++) {
				map[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		for (int i = 0; i < N; i++) {
			isVisited[i] = true;
			dfs(0, i, i, 0);
		}
		System.out.println(answer);
	}

	private static void dfs(int depth, int start, int prev, int cost) { // 깊이, 첫시작도시, 이전탐색도시, 총비용,																						// 도시 방문여부
		if (depth == N - 1) {
			if (map[prev][start] != 0) {
				answer = Math.min(answer, cost + map[prev][start]); // 다시 시작점으로 돌아오는 경우 플러스
			}
			return;
		}
		for (int i = 0; i < N; i++) {
			if (!isVisited[i] && map[prev][i] != 0) {
				isVisited[i] = true;
				dfs(depth + 1, start, i, cost + map[prev][i]);
				isVisited[i] = false;
			}
		}
	}
}

친구가 풀었던 풀이를 참고했다. dfs함수 재귀문안에 매개변수를 추가했을 뿐인데 이렇게 간단하다니..
그리고 이전 코드에서는 visited방문배열을 dfs함수안에 들어갈때마다 모든 도시가 방문처리가 되었는지 체크를 해줬는데 그럴 필요가 없었다. 어차피 depth가 N-1개가 된다면 모두 true가 되었을테니까.. 이 생각을 왜 못했지

[프로그래머스] LEVEL2 타겟넘버 - 자바

YunHyeok — Wed, 9 Feb 2022 23:05:12 +0900

https://programmers.co.kr/learn/courses/30/lessons/43165

코딩테스트 연습 - 타겟 넘버

n개의 음이 아닌 정수들이 있습니다. 이 정수들을 순서를 바꾸지 않고 적절히 더하거나 빼서 타겟 넘버를 만들려고 합니다. 예를 들어 [1, 1, 1, 1, 1]로 숫자 3을 만들려면 다음 다섯 방법을 쓸 수

programmers.co.kr

[DFS 풀이 - 재귀]

// 재귀풀이
class Solution {
    static int cnt=0;
    public int solution(int[] numbers, int target) {
        dfs(0, 0, numbers, target);
        return cnt;
    }
    
    static void dfs(int idx, int sum, int[] numbers, int target){
        if(idx == numbers.length){
            if(sum == target) cnt++;
            return;
        }

        dfs(idx+1, sum + numbers[idx], numbers, target);
        dfs(idx+1, sum - numbers[idx], numbers, target);
    }
}

[BFS 풀이 - 큐]

// bfs풀이
import java.util.*;
class Solution {
    static Queue<int[]> q = new LinkedList<>();
    public int solution(int[] numbers, int target) {
        int answer = 0;
        q.offer(new int[] {numbers[0], 0}); // '+' 로 시작
        q.offer(new int[] {-1 * numbers[0], 0}); // '-' 로 시작
        
        while(!q.isEmpty()){
            int num = q.peek()[0];
            int idx = q.peek()[1];
            q.poll();
            idx += 1;
            
            if(idx < numbers.length){ 
                q.offer(new int[] {num + numbers[idx], idx});
                q.offer(new int[] {num + (-1 * numbers[idx]), idx});
            }
            
            if(idx == numbers.length){
                if(num == target) answer++;
            }
        }
        
        return answer;
    }
}

DFS, BFS로 풀어보았고 탐색 문제를 연습하기 좋은 문제였다.

[알고리즘] 백준1182 부분수열의 합 - 자바

YunHyeok — Wed, 9 Feb 2022 21:43:30 +0900

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

1182번: 부분수열의 합

첫째 줄에 정수의 개수를 나타내는 N과 정수 S가 주어진다. (1 ≤ N ≤ 20, |S| ≤ 1,000,000) 둘째 줄에 N개의 정수가 빈 칸을 사이에 두고 주어진다. 주어지는 정수의 절댓값은 100,000을 넘지 않는다.

www.acmicpc.net

[풀이 코드]

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

public class BOJ_1182_부분수열의합 {
	static int N;
	static int M;
	static int[] array;
	static boolean[] visited;
	static int result = 0;
	
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		
		st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());
		
		array = new int[N];
		visited = new boolean[N];
		st = new StringTokenizer(br.readLine());
		for(int i=0; i<N; i++) {
			array[i] = Integer.parseInt(st.nextToken());
		}

		dfs(0, 0, 0);
		System.out.println(result);
	}
	
	static void dfs(int idx, int sum, int cnt) {
		if(idx == N ) { 
			if(cnt > 0 && sum == M) { //cnt변수는 주어진 부분수열의 합(M)이 '0'인 경우 공집합을 제외시켜주기 위함
				result++;
			}
			return;
		}

		dfs(idx+1, sum + array[idx], cnt+1);
		dfs(idx+1, sum, cnt);
	}
}

cnt변수가 필요한 이유는 합이 '0'이 주어졌을 때 공집합인 경우를 제외시켜주기 위함!

[알고리즘] 백준2304 창고다각형 - 자바

YunHyeok — Wed, 9 Feb 2022 14:52:34 +0900

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

2304번: 창고 다각형

첫 줄에는 기둥의 개수를 나타내는 정수 N이 주어진다. N은 1 이상 1,000 이하이다. 그 다음 N 개의 줄에는 각 줄에 각 기둥의 왼쪽 면의 위치를 나타내는 정수 L과 높이를 나타내는 정수 H가 한 개의

www.acmicpc.net

[풀이 코드]

package day0209;

// 세상에서 제일 어렵게 풀기
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;


public class 백준2304_창고 {
	static int[][] array;
	public static void main(String[] args) throws IOException{
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		
		int N = Integer.parseInt(br.readLine());
		array = new int[N][2];
		int sum = 0;
		int maxIndex = 0;
		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine());
			int x = Integer.parseInt(st.nextToken()); 
			int y = Integer.parseInt(st.nextToken());
			if(sum < y) {
				sum = Math.max(sum, y);
				maxIndex = x;
			}
			array[i][0] = x;
			array[i][1] = y;
		}

		// 이차원 배열 정렬하기
		Arrays.sort(array, new Comparator<int[]>() {
			@Override
			public int compare(int[] arg0, int[] arg1) {
				if(arg0 == arg1) {
					return arg0[1] - arg1[1];
				}else {
					return arg0[0] - arg1[0];
				}
			}
			
		});
		
		//왼쪽부터
		int temp = 0;
		int idx = 0;
		for(int i=0; i<maxIndex; i++) { 
			int xi = array[idx][0];
			if (i != xi) {
				sum += temp;
				continue;
			}
			
			if (array[idx][1] > temp) { //이전 height보다 높다면 temp 변경해주기
				temp = array[idx][1];
				idx++;
				sum += temp;
			}else { // 이전 height인 temp가 높다면 temp유지하기
				idx++;
				sum += temp;
			}
		}
		
		//오른쪽부터
		temp = 0;
		idx = N-1; //15
		for(int i=array[idx][0]; i>maxIndex; i--) {
			int xi = array[idx][0];
			if(i != xi) {
				sum += temp;
				continue;
			}
			
			if(array[idx][1] > temp) {
				temp = array[idx][1];
				idx--;
				sum += temp;
				continue;
			}else {
				idx--;
				sum += temp;
				continue;
			}
			
			
		}
		
		System.out.println(sum);
		
	}

}

제일 높은기둥을 찾아서 그 기둥의 index와 height를 2차원 배열에 정렬해주면서 따로 변수에 담았다. maxIndex에 담긴 높은기둥의 인덱스를 기준으로 왼쪽, 오른쪽 방향으로 for문을 돌려주려고 생각했다.
파이썬에서는 이차원배열 정렬을 람다식으로 정말 간단하게 할 수 있어서 당연히 쉽게 될 줄 알았지만.. 자바는 달랐다. comparator를 import 해서 compare메서드를 오버라이딩해줘야 했다.
정렬된 2차원 배열을 돌면서 왼쪽 방향으로 maxIndex까지 0 + 0 + 4 + 4 + 8 + 8 + 8 + 8이 담기도록 했고, 오른쪽 방향으로는 8 + 8 + 8 + 8 + 8 + 8 + 8 이 담기도록 했다. 제일 높은 10은 2차원 배열을 담을 때 미리 더해놨다.

[SSAFYcial] #01. SSAFY 7기 입학식

YunHyeok — Tue, 8 Feb 2022 11:11:49 +0900

개미의 개열시미 프로그래밍

안녕하세요. SSAFYcial 7기 기자단 조윤혁입니다!

저의 2월 첫 기사는 SSAFY의 시작을 알리는 입학식에 대한 이야기입니다.

2022년 1월 18일 화요일

SSAFY Lucky! 7기 교육생들을 환영하는 비대면 입학식이 있었습니다.

현장에는 일부 교육생들이 참석하여

온-오프라인을 병행하여 진행되었습니다!

SSAFY 7기 입학식

입학식 전에는!

사전학습을 통해 SSAFY 수업에 대한 기본을 다지고

Start Camp를 통해 임시반에서 팀원들과 친해질 수 있는 활동까지 하고 나니

입과 후에도 잘 헤쳐나갈 수 있겠다는 자신감이 생겼습니다!!

입학식 현장

비대면 입학식이라 큰 기대를 안 하고 있었지만..

현장에는 마치 실제 교육생이 있는 것 같은 분위기였습니다ㅎㅎ

저걸 손수 하나하나 제작하셨을 SSAFY관계자분들의 노력을 생각하니

너무나 감동이었습니다ㅎㅎ

~~제가 없는 게 조금 아쉽~~

입학식 환영사

SSAFY 7기의 환영사에는 정말 많은 분들이 오셨습니다!

우리나라에 영향력 있는 분들께서 교육생들에게

환영과 격려의 말씀을 해주시니

SSAFY 7기에 입과한 제 자신이 자랑스럽고

열심히 해야겠다는 마음이 커졌습니다.

선배님 인터뷰

SSAFY를 통해 카카오, 삼성전자에 입사하신

선배님들의 말씀을 들을 수 있었던 시간이었습니다.

면접에 대한 팁으로

"면접관이랑 대화하는 느낌을 주는 것이 좋다."

"기술면접에서 피상적인 답변보다는 깊게 이해하고 있다는 느낌 주기"

이렇게 선배님들의 경험이 담긴 조언을 들으며

저의 부족한 부분을 다시 한번 생각해볼 수 있었습니다!

마지막 기념촬영

입학식을 마치고, 입학식에 참여했던 모든 분들께서

기념촬영을 하고 마쳤습니다!

재밌고 유익하고 특별했던 SSAFY 7기의 입학식!

SSAFY에 대한 애싸심이 솟구쳤던 날이었습니다ㅎㅎ

이 글을 보고 있는 분들

SSAFY 8기 지원 고민하지 않기!

[프로그래머스] 2020 카카오 인턴십/키패드 누르기(자바 풀이)

YunHyeok — Sun, 6 Feb 2022 02:01:09 +0900

[자바 풀이]

import java.util.*;
import java.io.*;
class Solution {
    static int[][] graph = {{1,2,3}, {4,5,6}, {7,8,9}, {-1, 0, -2}};
    static int[][] visited;
    static Queue<int[]> q;
    static int[] dy = {-1, 1, 0, 0};
    static int[] dx = {0, 0, -1, 1};

    public String solution(int[] numbers, String hand) {
        StringBuilder sb = new StringBuilder(numbers.length);
        List<String> result = new ArrayList<>(); 
        int curL = -1;
        int curR = -2;

        for(int i=0; i<numbers.length; i++){
            if(numbers[i] == 1 || numbers[i] == 4 || numbers[i] == 7){ // 1, 4, 7 이면 현재 왼손의 위치로 저장
                curL = numbers[i];
                sb.append("L");
            }else if(numbers[i] == 3 || numbers[i] == 6 || numbers[i] == 9){ // 3, 6, 9 이면 현재 오른손의 위치로 저장
                curR = numbers[i];
                sb.append("R");
            }else{ // 2, 5, 8, 0 이 눌린 경우
                int leftCnt = bfs(curL, numbers[i]);
                int rightCnt = bfs(curR, numbers[i]);
                if(leftCnt < rightCnt){ // 왼손이 더 가깝다면 현재 왼손의 위치로 저장
                    curL = numbers[i];
                    sb.append("L");
                }else if(leftCnt > rightCnt){ // 오른손이 더 가깝다면 현재 오른손의 위치로 저장
                    curR = numbers[i];
                    sb.append("R");
                }else{ // 동일하면 hand변수가 왼손인지, 오른손이지 판별
                    if(hand.equals("left")){ 
                        curL = numbers[i];
                        sb.append("L");
                    }else{
                        curR = numbers[i];
                        sb.append("R");
                    }
                }
            }
        }

        return sb.toString();
    }
    static int bfs(int start, int end){
        visited = new int[4][3];
        int cnt = 0;
        q = new LinkedList<>();

        // 이중for문을 통해 입력받은 start변수(왼손 또는 오른손의 현재 위치)가 키패드에 어느 좌표에 있는지
        for(int i=0; i<4; i++){
            for(int j=0; j<3; j++){
                if(graph[i][j] == start){
                    q.offer(new int[] {i, j});
                    visited[i][j] = 1;
                } 
            }
        }
        
        while(!q.isEmpty()){
            int y = q.peek()[0];
            int x = q.peek()[1];
            q.poll();
            
            if(graph[y][x] == end){
                cnt = visited[y][x];
                break;
            }

            for(int l=0; l<4; l++){
                int yy = y + dy[l];
                int xx = x + dx[l];
                if(yy>=0 && yy <4 && xx>=0 && xx <3){
                    if(visited[yy][xx] == 0){
                        q.offer(new int[] {yy, xx});
                        visited[yy][xx] = visited[y][x] + 1;
                    }
                }
            }
        }
        return cnt-1;
    }

}

이 문제를 보고 탐색으로 풀어야겠다고 바로 생각이 든 건 아니었고 조건문만으로도 풀 수 있을 것 같았다. 하지만 도저히 생각이 안나서 BFS로 도전했던 문제

BFS를 활용해서 문제를 풀기로 정하고 보니 키패드에 대한 이차원배열을 선언해줘야 했었다. 그에 따른 방문 visited배열도 생성했다. 또 이동 상하좌우만 된다고 문제에 나와있기에 dy, dx 델타 배열도 선언했다.
curL, curR은 현재 왼손과 오른손의 위치를 저장해 줄 변수이고 BFS탐색을 위해서 선언했다.
눌러야 하는 번호가 담긴 배열 numbers에서 순서대로 번호를 뽑아 1, 4, 7이면 무조건 curL(현재 왼손의 위치)에 저장하고 3, 6, 9는 curR(현재 오른손의 위치)에 저장했다.
번호가 2, 5, 8, 0중 하나일 경우에는 현재 손의 위치와 그 번호의 거리를 계산하는 bfs(start, end)함수를 통해 거리를 return 받는다. 그럼 leftCnt는 현재 위치한 왼손에서 눌러야 하는 번호까지의 거리가 저장된다. rightCnt 도 마찬가지
거리가 저장된 leftCnt와 RightCnt를 비교해서 더 짧은 거리가 계산된 손에 눌러야 하는 번호를 저장한다. 이때 거리가 동일한 경우도 있는데 동일하면 입력받은 hand를 판별하고 그에 맞게 저장한다.

[프로그래머스] 로또의 최고 순위와 최저 순위(자바 풀이)

YunHyeok — Sat, 5 Feb 2022 21:11:28 +0900

[나의 풀이]

import java.util.*;
class Solution {
    public int[] solution(int[] lottos, int[] win_nums) {
        int zeroCnt = 0;
        int equalCnt = 0;
        
        for(int i=0; i<6; i++){
            if(lottos[i] == 0) zeroCnt+=1; // 0 카운트
            for(int j=0; j<6; j++){
                if(lottos[i] == win_nums[j]) equalCnt += 1; // 두 로또 비교 후 같은 경우
            }
        }
        
        int max = 7 - (equalCnt + zeroCnt);
        int min = 7 - equalCnt;
        if(max==7) max = 6;
        if(min==7) min = 6;
  
        return new int[] {max, min};
    }
}

// 첫 풀이
//         int[] ans = new int[2];
//         ans[0] = equalCnt + zeroCnt;
//         ans[1] = equalCnt;
        
//         int[] result = new int[2];
//         for(int i=0; i<2; i++){
//             if(ans[i] == 6){
//                 result[i] = 1;     
//             }else if(ans[i] == 5){
//                 result[i] = 2;
//             }else if(ans[i] == 4){
//                 result[i] = 3;
//             }else if(ans[i] == 3){
//                 result[i] = 4;
//             }else if(ans[i] == 2){
//                 result[i] = 5;
//             }else{
//                 result[i] = 6;
//             }
//         }
        //System.out.println(Arrays.toString(result));

lottos배열과 win_nums를 이중 for문으로 비교 후에 같은 것을 카운팅 해서 equalCnt에 저장했고 lottos에 있는 0만 카운팅 해서 zeroCnt변수에 저장했다.
처음에는 반복문과 여러개의 조건문을 써서 최고 순위와 최저 순위를 리스트에 저장했는데 이 방법은 비효율적이다.
다음으로 생각해낸 풀이는 7에서 두 배열 비교후 같은 수와 0을 카운팅 한 수를 빼서 최고 순위와 최저 순위를 기록하는 것인데 if(min==7) min=6; 부분만 작성하면 될 줄 알았더니 오답이 나왔다. 생각해보니 lottos배열에 0은 하나도 없지만 다 틀렸을 경우도 생각해줘야 해서 if(max==7) max=6;을 추가해주었더니 답이 나왔다.

[알고리즘] 백준7576 토마토 - 자바

YunHyeok — Fri, 4 Feb 2022 01:25:30 +0900

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

7576번: 토마토

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N이 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M,N ≤ 1,000 이다. 둘째 줄부터는 하나의 상자에 저장된 토마토

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class BOJ_7576_토마토 {
	static int[] dy = {-1, 1, 0, 0};
	static int[] dx = {0, 0, -1, 1};
	static int M; // 가로
	static int N; // 세로
	static int[][] graph;
	static Queue<int[]> q = new LinkedList<>();;
	
	static void bfs() {
		
		while(!q.isEmpty()) {
			int y = q.peek()[0];
			int x = q.peek()[1];
			q.poll();
			
			for(int l=0; l<4; l++) {
				int yy = y + dy[l];
				int xx = x + dx[l];
				if(yy >= 0 && yy < N && xx >= 0 && xx <M) {
					if(graph[yy][xx] == 0) {
						graph[yy][xx] = graph[y][x] + 1;
						q.offer(new int[] {yy, xx});
					}
				}
			}
			
		}
	}
	
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		M = Integer.parseInt(st.nextToken());
		N = Integer.parseInt(st.nextToken());
		
		graph = new int[N][M];

		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j=0; j<M; j++) {
				graph[i][j] = Integer.parseInt(st.nextToken());
			}
		}//for문 종료
		
		for(int i=0; i<N; i++) {
			for(int j=0; j<M; j++) {
				if(graph[i][j] == 1) {
					q.offer(new int[] {i, j});
				}
			}
		}//for문 종료
		
		bfs(); //탐색
		
		int max = 0;
		boolean flag = false; // 0 찾기
		for(int i=0; i<N; i++) {
			for(int j=0; j<M; j++) {
				if(graph[i][j] == 0) {
					flag = true; // 0이 하나라도 있다면
				}else {
					max = Math.max(max, graph[i][j]-1);
				}
			}
		}
		if(flag) {
			System.out.println(-1);
		}else {
			if(max > 0) {
				System.out.println(max);
			}else {
				System.out.println(0);
			}
		}
		
	}

}

이 문제는 출력 조건이 은근히 까다로웠다. 어찌어찌 답은 나왔는데 효율적인 건 잘 모르겠다.
이 문제에서 중요하다고 생각되는 건 먼저 큐에 담을 토마토를 찾는 것이다. 예제 입력 중에 익은 토마토가 양 끝단에 있는 경우가 있는데 큐에 하나만 넣고 탐색을 한다면 당연히 오답이 나온다. 먼저, 익은 토마토를 찾고 그 즉시 큐에 넣는 것이 핵심이었다.
vistied배열은 필요 없었다. 늘 필요할 것 같아서 무의식적으로 만들었지만 이미 graph에 갱신을 해주면서 탐색을 해서 굳이 선언할 필요가 없었다.

[알고리즘] SWEA 달팽이 숫자 - 자바

YunHyeok — Thu, 3 Feb 2022 20:52:03 +0900

[전체 풀이 코드]

import java.util.Arrays;
import java.util.Scanner;

public class 달팽이숫자 {
	static int[] dy = {0, 1, 0, -1};
	static int[] dx = {1, 0, -1, 0};
	static int[][] graph;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int T;
		T=sc.nextInt();

		for(int test_case = 1; test_case <= T; test_case++){
			int N = sc.nextInt();
			int y = 0; // 세로
			int x = -1; // 가로
			int num = 0; // 넣을 숫자 ++ 할것
			int cntN = N; // 달팽이
			int move = 0;
			
			graph = new int[N][N];
			while(num < N * N) {
				for(int i =0; i<cntN; i++) {
					y = y + dy[move];
					x = x + dx[move];
					graph[y][x] = ++num;
				}
				move = (move+1) % 4; //move 0으로 초기화 했으니까 1더하기, 4로 나눈 나머지 활용 : while문 4바퀴돌면 다시 원래 0으로 돌아가야 되니까
				if(move%2 == 1) { //나눠질떄마다 1을 빼준다.
					cntN-=1;
				}
			}
			System.out.println("#"+test_case);
			for(int i=0; i<N; i++) {
				for(int j=0; j<N; j++) {
					System.out.print(graph[i][j] + " ");
				}
				System.out.println();
			}
		}
	}

}

예전에 cosPro를 준비하면서 풀어봤던 문제라서 풀이를 떠올리는데 큰 어려움은 없었지만 헷갈리는 부분을 다시 짚었다.

move = (move+1) % 4; //move 0으로 초기화 했으니까 1더하기, 4로 나눈 나머지 활용 : while문 4바퀴돌면 다시 원래 0으로 돌아가야 되니까
if(move%2 == 1) { //나눠질떄마다 1을 빼준다.
	cntN-=1;
}

위 부분이 제일 핵심이 되는 부분이다.
move = (move+1) % 4 : while문 종료 조건이 만족할 때까지 사각형 모양으로 돌아야 하기에 지정해준 dy, dx 배열에 맞게 move에는 0, 1, 2, 3 외에 다른 숫자가 와서는 안된다.
이어서 if문은 가로 움직임대로 오른쪽, 왼쪽 방향 시에 cntN을 -1해 주어야 한다. 규칙을 보았을 때 move를 2로 나눈 나머지가 1일 때 즉, move가 홀수일 때 cntN에 -1을 해야 한다.

[알고리즘] 백준2573 빙산 - 자바

YunHyeok — Thu, 3 Feb 2022 00:07:22 +0900

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

2573번: 빙산

첫 줄에는 이차원 배열의 행의 개수와 열의 개수를 나타내는 두 정수 N과 M이 한 개의 빈칸을 사이에 두고 주어진다. N과 M은 3 이상 300 이하이다. 그 다음 N개의 줄에는 각 줄마다 배열의 각 행을

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Boj2573_빙산 {
	static int[][] graph;
	static boolean[][] visited;
	static int N;
	static int M;
	static int[] dy = {-1, 1, 0, 0};
	static int[] dx = {0, 0, -1, 1};
	
	
	static void bfs(int i, int j) {
		visited[i][j] = true;
		Queue<int[]> q = new LinkedList<>();
		q.offer(new int[] {i, j});
		while(!q.isEmpty()) {
			int y = q.peek()[0];
			int x = q.peek()[1];
			q.poll();
			for(int l=0; l<4; l++) {
				int yy = y + dy[l];
				int xx = x + dx[l];
				if(yy>=0 && yy<N && xx >=0 && xx<M) {
					if(graph[yy][xx] > 0 && !visited[yy][xx]){
						q.offer(new int[] {yy, xx});
						visited[yy][xx] = true;
					}
				}
			}
		}
		
	}
	
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());
		graph = new int[N][M]; // 빙산
		
		int yearCnt = 0; // 년
		
		// 빙산 입력받기
		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine(), " ");
			for(int j=0; j<M; j++) {
				graph[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		

		boolean flag = true; //빙산이 다 녹을 때까지 분리되지 않은 경우를 위한 플래그
		while(flag) {
			int cnt = 0;
			visited = new boolean[N][M];
			flag = false; // 이중for문을 돌고 빙산이 다 녹았다면 false가 유지, 반복문을 돌다가 하나라도 빙산이 있다면 true
			for (int i=0; i<N; i++) {
				for(int j=0; j<M; j++) {
					if(graph[i][j] > 0 && !visited[i][j]) {
						flag=true;
						bfs(i, j);
						cnt++;
					}
				}
			}
			
			// 빙산이 두덩어리 이상으로 나눠진 경우
			if(cnt >= 2) {
				System.out.println(yearCnt);
				break;
			}
			
			// 빙산 녹이기
			int[][] updateGraph = new int[N][M]; // 업데이트 될 빙산
			for(int i=0; i<N; i++) {
				for(int j=0; j<M; j++) {
					if(graph[i][j] > 0) {
						int zeroCnt = 0; // 주변 빈공간
						for(int l=0; l<4; l++) {
							int yy = dy[l] + i;
							int xx = dx[l] + j;
							if(graph[yy][xx] == 0) zeroCnt+=1;
						}
						int update = graph[i][j] - zeroCnt; // 음수일 경우에는 '0'으로 맞춰주기 
						if(update <= 0) update = 0;
						updateGraph[i][j] = update;
					}
				}
			}
			yearCnt+=1; //녹이고 난 뒤에 1년 추가
			graph = updateGraph.clone(); 
		}//while 종료

		if(!flag) System.out.println(0);
		
		
	}
}

코드를 효율적?으로 작성한 건지는 잘 모르겠지만.. 문제를 이해하고 바로 코딩을 하는 데에는 큰 어려움이 없었던 문제였다.
먼저, while문을 통해 빙산이 두 덩어리로 나눠질 때까지 빙산 덩어리가 몇 개인지 탐색하는 것과 녹이기를 반복했다. (주의할 점은 빙산이 다 녹을 때까지 분리되지 않는 경우를 생각해서 flag를 두었다.)
빙산을 녹일 때마다 yearCnt라는 변수에 +1 씩 해주었고 빙산이 나눠진 것을 카운팅 해주는 cnt변수가 2 이상인 경우에는 yearCnt 출력 후 break를 통해 반복문을 종료했다.
마지막으로 빙산이 다 녹을 때까지 분리되지 않은 경우를 위해 초기화했던 flag변수가 false가 되어 반복문이 종료된 경우에는 0을 출력해준다.

[알고리즘] 백준2667 단지 번호 붙이기 - 자바

YunHyeok — Thu, 27 Jan 2022 02:08:00 +0900

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

2667번: 단지번호붙이기

<그림 1>과 같이 정사각형 모양의 지도가 있다. 1은 집이 있는 곳을, 0은 집이 없는 곳을 나타낸다. 철수는 이 지도를 가지고 연결된 집의 모임인 단지를 정의하고, 단지에 번호를 붙이려 한다. 여

www.acmicpc.net

[풀이 코드]

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {
	static int N;
	static int[][] graph;
	static boolean[][] visited;
	static int hCnt = 0;
	static int[] dy = {-1, 1, 0, 0};
	static int[] dx = {0, 0, -1, 1};
	static ArrayList<Integer> cntList;
	
	static int bfs(int i, int j) {
		Queue<int[]> q = new LinkedList<>();
		q.offer(new int[] {i, j});
		int cnt = 1;
		visited[i][j] = true;
		
		while(!q.isEmpty()) {
			int y = q.peek()[0];
			int x = q.peek()[1];
			q.poll();
			
			for(int l=0; l<4; l++) {
				int yy = dy[l] + y;
				int xx = dx[l] + x;
				if(yy >= 0 && yy < N && xx >= 0 && xx <N) {
					if(!visited[yy][xx] && graph[yy][xx] == 1) {
						cnt++;
						q.offer(new int[] {yy, xx});
						visited[yy][xx] = true;
					}
				}
			}
		}
		return cnt;
	}
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		graph = new int[N][N];
		visited = new boolean[N][N];
		
		String str;
		for(int i=0; i<N; i++) {
			str = sc.next();
			for(int j=0; j<N; j++) {
				graph[i][j] = str.charAt(j) - '0';
			}
		}
		
		cntList = new ArrayList<>();
		for(int i=0; i<N; i++) {
			for(int j=0; j<N; j++) {
				if(graph[i][j] == 1 && !visited[i][j]) {
					cntList.add(bfs(i,j));
				}
			}
		}
		
		System.out.println(cntList.size());
		Collections.sort(cntList);
		for(int cnt : cntList) {
			System.out.println(cnt);
		}
	}

}

- 1일 1 커밋 다짐한 지 하루 만에 실패.. 파이썬으로 풀어본 문제라 풀이는 빨리 생각이 났지만 역시나 입력받는 부분에서 좀 막혔다. 그리고 큐 offer, peek, poll 왜 이렇게 생각이 안 나는지ㅜ 파이썬이 그립다..

[SSAFY 7기] SSAFY기자단(SSAFYcial) 대전지역 선정

YunHyeok — Sun, 23 Jan 2022 15:57:40 +0900

#SSAFYcial(SSAFY + Official)

이번에 SSAFY 7기의 교육생을 대표해서 대내외적으로 콘텐츠를 제작하여 SSAFY를 홍보하는 기자단(SSAFYcial)을 선발한다는 공지가 올라왔습니다. 또 운 좋게 선발이 되어 글을 쓰게 되었습니다.

#SSAFYcial 지원자격

SSAFY에 대한 애정이 많고 자긍심이 높은 교육생
영상, 편집, 사진, 글쓰기를 좋아하고 기획력이 좋은 교육생
SNS활동을 자주 하거나 좋아하는 교육생
* 대학생 기자단/블로거 경험자 우대

지원자격은 위와 같았습니다. SNS라고 해서 대중적인 인스타를 잘 안 해서 걱정했지만 "블로거 경험자 우대" 이 문장을 보고 바로 지원..!

#SSAFYcial 지원한 이유

원래 블로그를 꾸준히 해왔기도 했고 SSAFY에 대한 애정을 블로그에 올릴 생각을 하니 재밌을 것 같았습니다. 게다가 월 2회 이상의 기사 작성 시 현금화가 가능한 월 5만마일리지 적립을 해준다고 합니다:)
SSAFY에서의 코딩 교육 외에도 여러 사람들과 인연을 쌓고 싶었습니다:) 지금 같이 교육을 받고 있는 교육생뿐만 아니라 SSAFY의 선후배 기수를 자연스럽게 만나 교류할 수 있다고 생각했습니다.

#SSAFYcial 지원 준비물

지원 준비물로는 자기소개, SNS 링크, 각오(300자) 세가지가 있었습니다.

자기소개카드

자기소개 카드
자기소개는 어떤 형식이든 상관이 없었고 부담을 안 가져도 된다고 하셨습니다:)
저는 미리캔버스를 활용해서 소개 카드를 한 장 만들었습니다. ~~사진이 너무 사기긴하지만 합격을 위해 양심을 한번 팔았습니다ㅎㅎ~~
블로그 링크
현재 티스토리 블로그를 첨부했습니다!!
각오(300자)
간략하게 요약하자면, 편입한 학교에서는 적응을 위해 평일엔 공부에 전념했고 주말엔 야간근무를 해서 대외활동을 많이 하지 못한 아쉬움을 솔직하게 표현했습니다. 어쩌면 마지막이 될지 모르는 SSAFY와 같은 교육과정에서 코딩 교육뿐만 아니라 대외적으로도 경험을 쌓고 싶다는 말을 담았습니다:)

SSAFY에 합격한 것 부터 시작해서 SSAFYcial까지 선발되어 정말 감사한 마음입니다.

초심 잃지 않고 열심히 해보겠습니다:)

[알고리즘] 백준1543 문서검색 - 자바

YunHyeok — Sat, 22 Jan 2022 20:05:22 +0900

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

1543번: 문서 검색

세준이는 영어로만 이루어진 어떤 문서를 검색하는 함수를 만들려고 한다. 이 함수는 어떤 단어가 총 몇 번 등장하는지 세려고 한다. 그러나, 세준이의 함수는 중복되어 세는 것은 빼고 세야 한

www.acmicpc.net

자바 익숙해지기 2주 차.. 월요일 시험을 위해 쉬운 거여도 한번 풀어보기!

[풀이 코드]

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		String str = sc.nextLine();
		String s = sc.nextLine();
		
		int cnt = 0;
		
		for(int i=0; i <= str.length()-s.length(); i++) {
			if(str.substring(i, i+s.length()).equals(s)) {
				cnt++;
				i+=s.length()-1;
			}
		}

		System.out.println(cnt);
	}

}

[알고리즘] 백준2178 미로탈출 - 자바

YunHyeok — Fri, 21 Jan 2022 02:07:44 +0900

한번 풀어본 문제지만 자바에 익숙해지기 위해 다시 풀어본다. 싸피에 입과 후 알고리즘은 자바 수업으로 하기 때문에 이렇게라도 대비를 해본다.

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

2178번: 미로 탐색

첫째 줄에 두 정수 N, M(2 ≤ N, M ≤ 100)이 주어진다. 다음 N개의 줄에는 M개의 정수로 미로가 주어진다. 각각의 수들은 붙어서 입력으로 주어진다.

www.acmicpc.net

[풀이 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Boj_2178_미로탈출 {
	static int[][] graph;
	static boolean[][] check;
	static int[] dy = { -1, 1, 0, 0 };
	static int[] dx = { 0, 0, -1, 1 };
	static int M;
	static int N;

	static void bfs() {
		Queue<int[]> q = new LinkedList<>();
		q.offer(new int[] { 0, 0 });
		check[0][0] = true;

		while (!q.isEmpty()) {
			int y = q.peek()[0];
			int x = q.peek()[1];
			q.poll();
			for (int l = 0; l < 4; l++) {
				int yy = y + dy[l];
				int xx = x + dx[l];
				if (yy >= 0 && yy < N && xx >= 0 && xx < M) {
					if (!check[yy][xx] && graph[yy][xx] == 1) {
						graph[yy][xx] = graph[y][x] + 1;
						check[y][x] = true;
						q.offer(new int[] { yy, xx });
					}
				}
			} // for문 종료
		} // while문 종료

	}// bfs 종료

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(bf.readLine());
		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());

		graph = new int[N][M];
		check = new boolean[N][M];

		for (int i = 0; i < N; i++) {
			String line = bf.readLine();
			for (int j = 0; j < M; j++) {
				graph[i][j] = line.charAt(j) - '0';
			}
		}

		bfs();
		System.out.println(graph[N - 1][M - 1]);

	}

}

파이썬 문법에 익숙해져서 그런지 큐를 생성하는 부분부터 헷갈렸다.. 심지어 BufferedReader로 입력받는 것도 아직 버벅거리는 것 같다.
문제를 풀이해보자면, bfs로 해결하려 했다. 큐에 배열인덱스 {0, 0}을 넣고 상하좌우를 탐색하면서 이동할 때마다 입력받은 graph자체에 +1씩 해주며 움직였다.

개미의 개열시미 프로그래밍

[MSSQL] WITH(NOLOCK) , ISNULL

WITH(NOLOCK)

IS NULL

2022 현대오토에버 상반기 신입 대규모 채용 합격 후기(코딩테스트/1차면접/2차면접)

1.서류 준비 (지원 직무 : ICT 어플리케이션 개발 및 운영)

2. 코딩테스트

3. 1차 면접 (직무 면접)

4. 2차 면접 (임원 면접)

[슬기로운 SSAFY생활 - 5화] SSAFY 7기 스터디에 대해 알아보기

교육생 인터뷰

[SSAFYcial] #05. SSAFY 7기 대전캠퍼스 박동섭 교육프로님 인터뷰

프로님 자기소개

프로님과 인터뷰

2022년 상반기 회고 & 7월 목표

[상반기 회고 및 목표 설정하기]

[슬기로운 SSAFY생활 - 4화] SSAFY7기 1학기 관통프로젝트 최우수자 인터뷰

최우수자 자기소개

최우수자 인터뷰

[SSAFYcial] #04. SSAFY 7기 전공반 양유진 교수님과의 인터뷰

교수님의 자기소개

교수님 TMI

교수님과의 인터뷰

[슬기로운 SSAFY생활 - 3화] SSAFY의 자치회 알아보기

[SSAFYcial] #03. SSAFY 人들의 대축제! 'MeetUp'

[알고리즘] 백준16236 아기상어 - 자바

[풀이 코드]

[풀이 로직]

[알고리즘] 백준14890 경사로 - 자바

[풀이 코드]

[풀이 로직]

[알고리즘] 백준20056 마법사 상어와 파이어볼 - 자바

[풀이 코드]

[이 문제를 풀면서 부족하다고 느낀 점]

[풀이 로직]

[알고리즘] 백준16234 인구 인동 - 자바

[슬기로운 SSAFY생활 - 2화] SSAFY 7기 싸피데이 알아보기

[알고리즘] 백준11727 2xn 타일링2 - 자바

[알고리즘] 백준11726 2xn 타일링 - 자바

[SSAFYcial] #02. SSAFY만의 알고리즘 게임 평가! '일타싸피'

간단한 소개

Rule

Interview

[알고리즘]백준2234 성곽 - 자바

[프로그래머스] LEVEL2 전력망을 둘로 나누기 - 자바

[풀이 코드]

[알고리즘] 백준14500 테트로미노 - 자바

[풀이 코드]

[짧게 정리하는 CSS] 자식결합자 이해하기

자식 결합자 ( > )

오류가 났던 부분

[짧게 정리하는 CSS] 4가지 포지셔닝

CSS 포지셔닝이란?

포지셔닝의 4가지 종류

[슬기로운 SSAFY생활 - 1화] SSAFY 7기 합격 꿀팁 인터뷰

[알고리즘] 백준3190 뱀 - 자바

[풀이 코드]

[알고리즘] 백준17144 미세먼지 안녕! - 자바

[풀이 코드]

[알고리즘] 백준16954 움직이는 미로 탈출 - 자바

[풀이 코드]

[알고리즘] 정올 1681 해밀턴 순환회로 - 자바

[풀이 코드]

[알고리즘] 백준15686 치킨배달 - 자바

[풀이 코드]

[알고리즘] 백준 2110 공유기 설치 - 자바

공유기 설치 풀이노트

정렬하기

기준점 정하기

이분탐색시작

부분설명

조합으로도 풀 수 있을까?

#2. 반복문 설명

#3. 마지막 조건문 설명

[알고리즘] 백준3109 빵집 - 자바

[풀이 코드]

[알고리즘] 백준2630 색종이만들기 - 자바

[풀이 코드]

[알고리즘] 백준1992 쿼드트리 - 자바

[풀이 코드]