개발하는 사막여우

Superman

에릭 Kim — Fri, 11 Jul 2025 19:30:24 +0900

개인적으로 영화보는 걸 너무 좋아하는데, 그냥 보고 넘기기에는 계속 뭔가 아쉽다고 생각했었다. + 봤던 영환데 기억이 잘 나지 않는 경우도 있고, N회차 관람하는 영화의 경우 이전과는 어떻게 다른 느낌을 받았는지도 알고싶었다.

그래서 지금부터라도 블로그에 나만의 후기를 간단하게나마 남겨보려고 한다 !

다른 사람을 위한 무언가가 아니니까 그냥 부담없이 쓰련다 ㅎ

- 슈퍼맨

- 2025.7.9 개봉

- 2025.7.11 관람

이번에 본 영화는 '슈퍼맨(Superman)' !

보통 개봉 당일날 챙겨보려고 하는데, 이번엔 하루 뒤에 갔다 ^^

이전에도 슈퍼맨 영화는 꽤 있었다. "맨 오브 스틸", "슈퍼맨 리턴즈", "저스티스 리그" 등등...

괜찮은 영화들도 있었지만 그렇게 인상 깊지는 않았다. 그냥 킬링타임용 ? 그래도 뭔가 우아 슈퍼맨,,과 같은 동경, 타격감, 권선징악 등의 요소가 좋긴 했다.

근데 이번엔 "제임스 건"이 메가폰을 잡기도 했고 캐스팅도 바뀌고 트레일러도 재밌어 보여서 적지 않은 기대를 가지고 보러갔다 !

(참고로 가오갤, 어벤져스 시리즈는 정말 재밌게 봤고 좋아한다 ^0^)

난 항상 영화를 볼 때 인간이 중심이 아닌 영화들, 로봇이나 공룡, 외계인이 주를 이루는 플롯에는 휴먼이 나오는 걸 좀 최소화했으면 싶었다.

이야기 전개 상 필수불가결 한건 인정. 그럼에도 가족, 연인 등의 감성을 섞어서 짬뽕을 만드려는 시도와 함께 몰입이 깨지는 경우가 많았기 때문이다.(이러면 꼭 산으로 가더라) 근데 이번 영화는 딱히 그런 부분은 없었다 !

물론 슈퍼맨이 인간같은 외계인? 이기 때문에 아예 없을 순 없겠지만 서사의 중심이 슈퍼맨 흐름으로 갔기에 몰입이 전혀 깨지지 않았다

특별히, 등장한 저스티스 갱(메타 휴먼들의 집합)도 인상 깊었다. "그린랜턴, 호크걸, 미스터 트레픽" 이렇게 세명이 한 팀인데 DC 코믹스는 잘 몰라서 그린랜턴밖에 모르겠더라.

슈퍼맨이 메인인데 다른 메타휴먼들이 나와도 돼..? 괜찮겠어..?라는 마음이 있기도 했지만

이들의 등장이 몰입을 해치지 않았고 오히려 다양한 활약을 보면서 세계관이 확장되어 갈 수 있겠구나 싶었다. (호크걸은 메타휴먼이 맞는가 싶기도 했다. 뾰족한 뿔 달린 망치로 괴성 지르면서 활약하는 데 후후,, ㅎㅋ)

빌런으로 등장한 "렉스 루터"도 정말 인상깊었다 !

악에 받쳐하는 순간들이 있었는데, 연기도 전혀 어색하지 않았고 오히려 슈퍼맨에 대한 시기, 질투를 잘 드러냈다고 생각한다.

슈퍼맨을 철저히 연구해서 행동 패턴을 알아내고, 그에 맞춰 대응하는 방식도 훌륭했다.

렉스 루터와 한 팀인 "울트라맨", "엔지니어"도 같이 나오는데, 빌런 치고는 음 ~ 영 별로였다.

울트라맨은 이름도 웃기고 대사도 없어서 왜 나와찌..? 싶었고 엔지니어는 나노 로봇을 통해 몸을 자유자재로 변형시킬 수 있는데, 딱히 임팩트는 없어따,,

결론적으론 슈퍼맨이 다 물리치고 지구를 지켜낸다. 역시 히어로물이다.

슈퍼맨이 지면 어떨까? 동심 다 깨지는건가? 좀 애매한 위치에 있는 영웅이신 거 같다.

여튼 이번 영화에 대한 에릭 Kim(아주 무명의 공신력 제로)의 평가는 8 / 10이다.

2시간이라는 러닝타임이지만 지루하지 않게 봤던 거 같고 액션이랑 음향도 빵빵했던 거 같다 !

억지 유머도 많지 않아서 몰입감 있게 봤던 거 같고 내가 평가할 수는 없겠지만 배우분들의 연기 또한 좋았다고 생각한다.

아쉬웠던 부분은 슈퍼맨 영화들의 빌런들보다 하위호환이었던 빌런을 상대로 슈퍼맨은 왜 고전하는가 ㅠㅠ

그냥 시~~~원하게 "잘 패다갑니다 ~" 느낌으로 이겨줬으면 좋겠다

첨이라 두서없이 쓴 거 같은데 좀 오글거리긴 합니다요 ^^;; + 진짜 하나하나 다 쓰면 엄~~~청 길게 쓰겠구나 싶다 !!

But, However,Nevertheless 나에 대한 기록을 꾸준히 남기고 싶다 :]

[대한항공] 전문인력 (신입/경력) 채용 후기

에릭 Kim — Tue, 25 Mar 2025 17:00:08 +0900

대한항공 전문인력 부문(IT)에 관심 있으신 분들에게 조금이나마 도움이 됐으면 하는 바람으로 작성해봅니다 :)

서류접수는 24.11.12 ~ 24.11.26까지 진행됐었습니다.

종합직 신입사원 / 전문인력 / 항공우주 전문인력 이렇게 나눠서 뽑는 방식이었고,

저는 IT 개발 직무로 지원을 했기 때문에 전문인력 분야로 지원했습니다.

전형 절차는 다음과 같았습니다.

서류전형

서류 결과는 합격이었습니다.

서류 결과 나오기까지 한달 남짓 걸렸고 적부까지는 아닌데 대부분 붙는다는 카더라..?

1차 면접

1차 면접은 대한항공 역검 사이트에 들어가서 비대면으로 봤습니다

총 소요시간은 20 ~ 30분 내외로 빨리 끝났습니다.

재응답의 기회는 한번 있었고, 사용하지 않으면 20분정도로도 끝낼 수 있었습니다.

저는 CS관련 질문을 2개 받았습니다. 직무에 따라 조금씩 다르겠지만 뭐 인성 비슷한 질문도 있다고 하고, 전혀 예상하지 못한 질문이었다고들 하더라구요

CS라는건 예상했기에 정처기 미리미리 공부해뒀으면 어렵지 않게 답할 수 있는 수준이긴 했는데 질문을 받고 너무 당황하지만 않으면 어렵지 않게 답할 수 있을 것이라고 생각합니다.

질문

1. 정적 코드 분석 도구와 코드 포멧터에 대해서 설명해주세요.

- eslint와 prettier기반으로 설명했습니다.

2. layerd Architecture에 설명해주세요

- 3 tier랑 4 tier의 차이점을 비교하면서 설명했습니다.

결과

감사히도 합격이었습니다.

2차면접

2차 면접은 대한항공 인재개발원에서 영어 면접 + PT 면접 진행했습니다.

전 오전 8:30 타임이었고, 대기 시간 없이 빠르게 진행됐습니다.

딱히 준비를 한 내용은 없었고, 영어 면접은 어느정도 자신있었기에 자기소개 정도만 준비했고, PT면접은 대한항공이나 항공사 관련된 기사나 내용을 찾아보며 준비했습니다.

영어면접

1. 자기소개 X

2. 인재개발원 올 때 어떻게 왔냐

3. 전공 선택 이유 + 해당 전공으로 어떻게 기여할 수 있을지

+ 꼬리질문 간단한 것들..

10분 내외로 빠르게 진행됐습니다.

면접관은 한국인이 아닌 외국인 임직원분이셨던 거 같고 나름 반응도 잘해주십니다.

영어 면접을 끝내고 대기하고 있으면 PT 면접 조를 불러주십니다.

지원자 5, 면접관 3 다대다였습니다.

PT면접

1. 클라우드 관련된 내용. 설계 어떻게 할지 물어본듯? (잘 기억은 안납니다ㅎ)

2. 장애 발생 시, 어떤 프로세스로 대응할건지

주제를 주고 30분정도 생각할 시간을 줍니다. 저는 장애 대응에 관해 준비했고, 개발을 하면서 사용했던 실시간 에러 모니터링 도구인 sentry를 사례로 설명했습니다.

자기소개 + PT 발표 + 질문의 순서가 이어졌고 각 사람에게 많은 양의 질문이 돌아가진 않습니다. 보통 2 ~ 3개 정도였습니다.

결과

감사하게도 합격이었습니다.

3차면접

대한항공 본사에서 진행됐습니다. 김포공항에서 버스타면 바로 앞까지 도착할 수 있습니다.

본사에는막 못들어가기에 다같이 모여서 들어갑니다.

너무 빨리 마시고 10 ~ 20분정도 여유를 두고 가시는 걸 추천드립니다.

면접 + 인성검사 순서로 진행됐고 면접관 2, 지원자 5 다대다였습니다.

면접

1. 자기소개 X

2. 대한항공에 기여할 수 있는 부분에 대한 질문

3. 대한항공의 서비스를 이용하면서 느꼈던 점들(좋았던 점, 불편했던 점)

+ 꼬리질문들..

인성검사

진짜 할말이 많은데.. 너무 비효율적이라고 생각했습니다. 질문이 500개 넘게 있는데 일일이 수기로 OMR 체크해야 합니다. 손도 아프고 집중력도 떨어지더라고요.. 그냥 레전드였습니다.

최종결과

아쉽지만 불합격했습니다.

시원섭섭한 마음이 있긴 했지만 좋은 경험을 했다고 생각합니다.

전체 타임라인

서류 접수: 24.11.12 ~ 24.12.26

서류 결과: 24.12.26

1차 면접: 24.12.30 ~ 24.12.31

1차 결과: 25.1.17

2차 면접: 25.1.22

2차 결과: 25.2.7

3차 면접: 25.2.21

3차 결과: 25.3.10

궁금하신 내용있으시면 제가 아는 선에서 답변드리겠습니다 :)

[SOOP] 2025 신입 공개채용 후기

에릭 Kim — Thu, 27 Feb 2025 13:59:19 +0900

SOOP에 입사하고 싶으신 분들에게 도움이 되었으면 하는 바람에서 후기를 작성해봅니다 :)

2025년 시작부터 SOOP의 신입 공개채용이 있었습니다 !

SOOP은 아프리카TV에서 상호를 바꾼 라이브 스트리밍 플랫폼인데요, 많은 분들이 한번쯤은 들어보셨을 기업이라고 생각합니다 :)

모집 분야는 엄청 다양하게 있었습니다. 그중에서도 저는 "글로벌 P2P 클라이언트 개발" 직무로 지원했어요.

저는 프론트엔드 개발을 주로 했었고, 싸피하면서 WebRTC를 활용한 실시간 화상 회의 서비스를 구현한 경험이 있었기 때문에 나한테 딱 맞는 분야다 ! 라고 생각했던 거 같아요

서류 결과

서류 합/불 결과를 받은 건 2월 4일이었습니다. 체감상 금방 결과가 나왔던 거 같아요 !

해당 메일에는 사전테스트, 1차 면접에 관한 내용들이 있구요, 친절하게 안내해줍니다 :)

사전테스트

직무마다 사전테스트가 있기도 하고, 또 다양한 형식으로 있다고 하더라구요 !

제가 지원한 직무는 HackerRank에서 온라인 코딩테스트를 진행했습니다.

저도 HackerRank라는 PS 사이트를 처음 사용해봐서 첨엔 많이 낯설더라구요.

일단 내용이 다 영어로 되어 있다는 걸 확인하셔야 하고, 적절히 번역하셔서 푸시면 됩니다 !

+ 화면 녹화나 캠을 키라는 말은 따로 없었어요. 그런 부분은 받으신 메일에 잘 확인해보시면 될 거 같습니다 :)

저는 총 5문제가 나왔어요

RestAPI 1, SQL 1, 알고리즘 3 !!

난이도와는 별개로 생각보다 재밌었던 거 같아요 ! (난이도는 제 기준 좀 어려웠던 거 같았어요. 테케를 전부 통과하는 경우가 잘 없더라구요ㅠ)

150분 동안 진행했는데, 시간 진짜 순삭입니다 !

1차 면접

면접관 4(실무진 3, 인사팀 1), 지원자 2의 다대다 대면면접이었습니다. 다른 시간대는 지원자가 3명씩도 들어가더라구요

장소는 판교였고 서류 합격을 확인하고, 1차 면접까지의 기간은 대략 1주일 내외였어요 !

저는 사실 이번에 첫 서비스 기업 직무면접이었는데, 진짜 레젼드로 빡셌던 거 같아요 ㅎㅎ

그전에는 제조업 위주로 지원했어서 직무면접이 평이했다고 생각하는데 확실히 서비스 기업은 다르더라구요 !

면접 시간은 50분 정도였고 SOOP에 대한 관심, 직무에 대한 CS 및 이해도, 네트워크 CS에 관한 내용(제 직무 기준) 등을 많이 공부하고 가시면 도움이 되실 거 같아요 ! (꼬리 질문 많이 하십니다 ^^)

1차 면접이 끝나고 난 직후에 들었던 생각은 "아 ~ 떨어졌구나 ~ 좋은 경험이었다" 였어요.

면접하면서 "죄송합니다 잘 모르겠습니다' 를 꽤 했던 거 같았거든요.

결과

감사하게도 합격이었습니다 :)

Play 전형

1차 면접을 합격하고 나면, 메일로 Play 전형과 2차 면접에 관한 내용을 함께 알려주십니다 !

Play 전형에 대해 잘 모르시는 분들도 계실텐데

"Play 전형은 SOOP 플랫폼을 활용해 실제 방송을 진행하며 스트리머/서비스 경험을 해보는 전형입니다. 선발 여부와 관계없이 100% 참여만 하면 되며, Play를 해보는 것에 의의를 둡니다." 니까 부담을 가지진 않으셔도 될 거 같아요 :)

저는 뭐할까 고민 많이 했는데 아무래도 제가 잘 아는 내용을 하면 좋을 거 같아서 "다시보고 싶은 듀오 축구선수 이상형 월드컵 64강"을 진행했습니다 !

개인적으로 하고싶기도 했고 재밌을 거 같더라구요 ! 실제로 방송하면서 임직원분들이 들어오셔서 채팅도 해주시고 호응도 해주시니까 진짜 방송인이 된 것만같은 기분..?

여튼 30분 순삭이고 스트리머 데뷔전 재밌게 했습니다 :)

2차 면접

2차면접도 다대다 대면면접으로 진행했습니다 !

장소는 그대로 판교였고, 합격 메일을 받고 난 후 제 경우엔 정확히 1주일 뒤였습니다

면접은 2대2로 진행했어요 ! 면접관으로는 본부장님이랑 인사팀장님이 들어오셨는데, 너무 편하게 해주셔서 감사하더라구요

저희 앞 팀은 지원자가 4였는데, 이것도 시간대마다 조금씩은 상이한 거 같아요 !

면접은 약 40분 정도 진행했습니다 !

인성에 관한 질문 먼저 주시고, 직무와 관련해서 SOOP에 얼마나 관심과 이해도가 있는지를 확인하시는 거 같아요.

사실 면접가기 전에 이미 보셨던 분들 말로는 좀 빡세다 ?고 해서 긴장 많이 했는데 제 타임에는 생각보다 괜찮았던 거 같아요.

SOOP을 많이 사용해보면서 서비스에 대해 이해하시고, 직무에 대해 진지하게 고민해보셨다면 충분히 대답할만한 질문들이었던 거 같아요 !

면접 끝나고 나서는 진짜 후련했던 거 같아요 !!

이거 보시는 분들도 잘준비하셔서 정말 후회 없이 임하셨으면 좋겠습니다 :)

최종결과

최종결과는 불합이었습니다

엄청 욕심이 있었던 건 아니었지만 그것과는 별개로 조금 아쉽긴 하더라구요 !

그래도 전형을 후회없이 진행했기에 좋은 경험이 되었다고 생각합니다 :)

면접질문이나 궁금한 부분들은 비밀댓글로 물어보시면 제가 아는 선에서 알려드릴게요 :)

[백준 알고리즘] 17270번: 연예인은 힘들어 (JAVA)

에릭 Kim — Tue, 14 Jan 2025 16:22:45 +0900

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

코드

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

public class prac {
	public static int V, M, INF;
	public static int[] min_dis;
	public static ArrayList<ArrayList<Node>> arr = new ArrayList<ArrayList<Node>>();

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

		st = new StringTokenizer(br.readLine());
		V = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());

		INF = 1000 * 10000 + 1;

		for (int i = 0; i < V + 1; i++) {
			arr.add(new ArrayList<>());
		}

		for (int i = 0; i < M; i++) {
			st = new StringTokenizer(br.readLine());
			int a = Integer.parseInt(st.nextToken());
			int b = Integer.parseInt(st.nextToken());
			int c = Integer.parseInt(st.nextToken());

			arr.get(a).add(new Node(b, c));
			arr.get(b).add(new Node(a, c));
		}

		st = new StringTokenizer(br.readLine());
		int J = Integer.parseInt(st.nextToken());
		int S = Integer.parseInt(st.nextToken());

		int[] first = dijkstra(J);
		int[] second = dijkstra(S);

		PriorityQueue<Pos> positionQueue = new PriorityQueue<Pos>();
		int min_v = Integer.MAX_VALUE;

		for (int i = 1; i <= V; i++) {
			if (i == J || i == S)
				continue;
			min_v = Math.min(min_v, first[i] + second[i]);
		}

		// 최솟값이 안되는건 애초에 다 걸러져야 함. 
		// 조건 순서대로 답을 구해줘야 함.
		for (int i = 1; i <= V; i++) {
			if (i == J || i == S)
				continue;
			if (first[i] + second[i] > min_v)
				continue;
			if (first[i] > second[i])
				continue;
			positionQueue.offer(new Pos(first[i], i));
		}

		if (positionQueue.isEmpty())
			System.out.println(-1);
		else
			System.out.println(positionQueue.peek().num);

	}

	public static int[] dijkstra(int start) {
		PriorityQueue<Node> pq = new PriorityQueue<Node>((o1, o2) -> o1.cost - o2.cost);
		min_dis = new int[V + 1];
		Arrays.fill(min_dis, INF);
		min_dis[start] = 0;
		pq.offer(new Node(start, 0));

		while (!pq.isEmpty()) {
			Node cur = pq.poll();

			if (min_dis[cur.node] < cur.cost)
				continue;

			for (Node next : arr.get(cur.node)) {
				if (min_dis[next.node] > cur.cost + next.cost) {
					min_dis[next.node] = cur.cost + next.cost;
					pq.offer(new Node(next.node, cur.cost + next.cost));
				}
			}
		}
		return min_dis;
	}
}

class Node {
	int node;
	int cost;

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

class Pos implements Comparable<Pos> {
	int time;
	int num;

	public Pos(int time, int num) {
		this.time = time;
		this.num = num;
	}

	@Override
	public int compareTo(Pos o) {
		if (this.time == o.time) {
			return this.num - o.num;
		}
		return this.time - o.time;
	}
}

풀이

분명히 제대로 구현한거 같은데 "틀렸습니다"를 8%에서 받으셨으리라 생각합니다. 저도 그랬습니다 !
그 이유는 문제에 주어진 조건을 하나하나 따져가며 답을 추려나가야 하기 때문입니다.
제 원래 코드는 다음과 같았습니다

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

public class Main {
	public static int V, M, INF;
	public static int[] min_dis;
	public static ArrayList<ArrayList<Node>> arr = new ArrayList<ArrayList<Node>>();

	public static void main(String[] args) throws Exception {

		int[] first = dijkstra(J);
		int[] second = dijkstra(S);
		PriorityQueue<Pos> positionQueue = new PriorityQueue<Pos>();

		for (int i = 1; i <= V; i++) {
			if (first[i] == INF || second[i] == INF || i == J || i == S || first[i] > second[i])
				continue;
			positionQueue.offer(new Pos(first[i] + second[i], first[i], i));
		}

		if (positionQueue.isEmpty())
			System.out.println(-1);
		else
			System.out.println(positionQueue.peek().num);
	}
}

class Pos implements Comparable<Pos> {
	int sum;
	int time;
	int num;

	public Pos(int sum, int time, int num) {
		this.sum = sum;
		this.time = time;
		this.num = num;
	}

	@Override
	public int compareTo(Pos o) {
		if (this.sum == o.sum) {
			if (this.time == o.time) {
				return this.num - o.num;
			}
			return this.time - o.time;
		}
		return this.sum - o.sum;
	}
}

이처럼 OR 연산자를 사용해 한번에 선택될 수 있는 값들을 구해주고, 우선순위 큐에 넣어서 정렬한 뒤, peek값을 출력하려고 했습니다.
하지만 문제에서는 조건의 순서에 따라 애초에 최단거리의 합이 최소가 되지 않는 값들은 다 제거해준 뒤, 다음 조건으로 넘어가야합니다.
이 부분만 잘 고려하시면 문제는 다익스트라를 사용하여 쉽게 해결하실 수 있으리라 생각합니다.

반례

[백준 알고리즘] 1966번: 프린터 큐 (JAVA)

에릭 Kim — Sat, 11 Jan 2025 19:12:13 +0900

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

코드

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

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

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

		while (t-- > 0) {
			st = new StringTokenizer(br.readLine());
			int n = Integer.parseInt(st.nextToken());
			int m = Integer.parseInt(st.nextToken());

			Queue<Node> q = new ArrayDeque<Node>(); //(우선순위, 인덱스)로 저장
			PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder()); 
            // (우선순위 내림차순 저장)

			st = new StringTokenizer(br.readLine());
			for (int i = 0; i < n; i++) {
				int p = Integer.parseInt(st.nextToken());
				q.offer(new Node(p, i));
				pq.offer(p);
			}

			int cnt = 0;

			while (!q.isEmpty()) {
				Node cur = q.poll();

				if (cur.priority == pq.peek()) { // 큐에서 뽑은 값이 가장 우선순위가 높음 == 출력 가능
					pq.poll();
					cnt++; // 몇번째로 출력되는지 순서 체크
					if (cur.idx == m) { // 문제에서 주어진 요건에 부합하는지 확인
						sb.append(cnt);
						break;
					}
				}
				q.offer(cur);
			}
			sb.append("\n");
		}
		System.out.println(sb);
	}
}

class Node {
	int priority;
	int idx;
	public Node(int priority, int idx) {
		this.priority = priority;
		this.idx = idx;
	}
}

풀이

문제 자체의 난이도가 그렇게 높지는 않고, 정답률도 꽤나 높습니다. 하지만 해당 문제를 포스팅하는 이유는 간단해 보이는 문제치고는 조금의 생각이 더 필요했다고 느꼈기 때문이고(제 기준), 자주 등장하는 유형이라고 생각했습니다 !
자료구조를 쓰긴 해야하는데, 어떤 걸 써야할지 꽤 고민했습니다. 하나의 자료구조로 쉽게 해결할 수 있다고 생각했지만 오산이었구요, 큐랑 우선순위 큐를 적절히 활용해야 합니다 !
해설은 코드의 주석을 보시면 쉽게 이해하실 거 같습니다 :)

[React] Props vs State

에릭 Kim — Wed, 8 Jan 2025 10:14:34 +0900

Props (Properties)

1. 정의

함수를 통해 전달되는 인자와 같은 성격
부모 컴포넌트로부터 자녀 컴포넌트로 전달되는 읽기 전용 데이터
부모에서 자식으로 데이터를 넘겨, 외관을 커스터마이징 해줌 (ex Form은 color라는 props를 button으로 보내, button을 커스터마이징)

2. 특징

읽기 전용 (Read-Only)
- 자식 컴포넌트는 props를 변경할 수 없음
재사용성
- props를 사용하면 여러 컴포넌트를 재사용 가능
함수 전달
- 부모에서 자식으로 함수를 전달하여 특정 이벤트 처리 가능
데이터 흐름
- 단방향 흐름 (부모 -> 자식)

State

1. 정의

컴포넌트의 메모리와 같은 성격
컴포넌트 내부에서 관리하는 동적인 데이터
컴포넌트가 몇몇 정보를 계속 따라갈 수 있게 해주고 변화하면서 상호작용을 만들어냄

2. 특징

동적 데이터
- 사용자 입력, 네트워크 응답, 타이머 등 동적으로 변하는 데이터를 저장
변경 가능
- state는 setState() 함수나, useState() 훅을 통해 업데이트 가능

Props vs State 비교

구분	*Props*	*State*
*소유권*	부모 컴포넌트가 관리	컴포넌트 자체가 관리
*변경 여부*	읽기 전용 (Read-Only)	변경 가능 (Mutable)
*업데이트 방식*	부모 컴포넌트에서만 변경 가능	setState나 useState로 변경
용도	부모 -> 자식 데이터 전달	컴포넌트 내부 데이터 관리
*리랜더링*	props 변경 시 랜더링	state 변경 시 랜더링
*초기값 설정*	부모 컴포넌트에서 설정	컴포넌트 내부에서 설정

예시

function ParentComponent() {
  const [count, setCount] = useState(0);

  return (
    <div>
      <h1>Parent Count: {count}</h1>
      <ChildComponent count={count} onIncrement={() => setCount(count + 1)} />
    </div>
  );
}

function ChildComponent({ count, onIncrement }) {
  return (
    <div>
      <h2>Child Count: {count}</h2>
      <button onClick={onIncrement}>Increment from Child</button>
    </div>
  );
}

// 부모 컴포넌트에서 count라는 state 생성
// 부모 컴포넌트 -> 자식 컴포넌트 count 변수를 props로 전달
// 부모 컴포넌트에서 setCount의 값이 변경되면, 자식 컴포넌트에서도 변경됨

[백준 알고리즘] 17836번: 공주님을 구해라! (JAVA)

에릭 Kim — Thu, 2 Jan 2025 17:45:39 +0900

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

코드

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

public class Main {
	public static int n, m, t;
	public static int[][] maps;
	public static boolean[][][] visited;
	public static int[] dx = { 0, 1, 0, -1 };
	public static int[] dy = { 1, 0, -1, 0 };

	public static void main(String[] args) throws Exception {
		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());
		t = Integer.parseInt(st.nextToken());

		maps = new int[n][m];
		visited = new boolean[n][m][2];

		for (int i = 0; i < n; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j = 0; j < m; j++) {
				maps[i][j] = Integer.parseInt(st.nextToken());
			}
		}

		int answer = bfs();

		if (answer == 0 || answer > t)
			System.out.println("Fail");
		else
			System.out.println(answer);
	}

	public static int bfs() {
		Queue<Node> q = new ArrayDeque<Node>();
		visited[0][0][0] = true;
		q.offer(new Node(0, 0, 0, false));

		while (!q.isEmpty()) {
			Node cur = q.poll();

			if (cur.x == n - 1 && cur.y == m - 1)
				return cur.time;

			for (int i = 0; i < 4; i++) {
				int nx = cur.x + dx[i];
				int ny = cur.y + dy[i];

				if (check(nx, ny)) {
					// 검이 없는 경우
					if (!cur.sword) {
						if (!visited[nx][ny][0]) {
							if (maps[nx][ny] == 2) {
								visited[nx][ny][1] = true;
								q.offer(new Node(nx, ny, cur.time + 1, true));
							} else if (maps[nx][ny] == 0) {
								visited[nx][ny][0] = true;
								q.offer(new Node(nx, ny, cur.time + 1, cur.sword));
							}
						}
					}

					// 검 있을 때
					else {
						if (!visited[nx][ny][1]) {
							visited[nx][ny][1] = true;
							q.offer(new Node(nx, ny, cur.time + 1, cur.sword));
						}
					}
				}
			}
		}
		return 0;
	}

	public static boolean check(int x, int y) {
		if (0 <= x && x < n && 0 <= y && y < m)
			return true;
		else
			return false;
	}
}

class Node {
	int x;
	int y;
	int time;
	boolean sword;

	public Node(int x, int y, int time, boolean sword) {
		this.x = x;
		this.y = y;
		this.time = time;
		this.sword = sword;
	}
}

풀이

가장 중요한 부분은 visited 배열로 방문을 체크할 때 검이 있을 경우, 없을 경우를 따로 처리해줘야 한다는 점입니다.
만약 여느때와 같이 2차원 배열로 visited를 처리했을 경우에 검을 가지고 갈 수 있는 길을 다시 가지 못하는 경우가 발생할 수 있습니다. 그 이유는 이미 검이 없을 때 해당 격자를 지나왔고, visited에 true로 체크를 해준다면 검이 생겼을 때 다시 그 길로 돌아갈 수 없기 때문입니다. 하지만 다시 돌아갔을 때, 공주님에게로 가는 가장 빠른 길을 찾을 수도 있겠지요 !

[백준 알고리즘] 2468번: 안전 영역 (JAVA)

에릭 Kim — Mon, 2 Dec 2024 13:06:22 +0900

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

틀린 접근법 (69%)

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

public class prac {
    public static int[][] arr;
    public static boolean[][] visited;
    public static int n;
    public static int[] dx = {0,1,0,-1};
    public static int[] dy = {1,0,-1,0};
    public static HashSet<Integer> hs = new HashSet<>();

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

        n = Integer.parseInt(br.readLine());

        arr = new int[n][n];
        int max_v = 0;

        for (int i=0; i<n; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j=0; j<n; j++) {
                int k = Integer.parseInt(st.nextToken());
                arr[i][j] = k;
                hs.add(k);
            }
        }

        ArrayList<Integer> nums = new ArrayList<>(hs);

        for (int t=0; t<nums.size(); t++) {
            int h = nums.get(t);
            int cnt = 0;
            visited = new boolean[n][n];
            for (int i=0; i<n; i++) {
                for (int j=0; j<n; j++) {
                    if (!visited[i][j] && arr[i][j] > h) {
                        visited[i][j] = true;
                        bfs(i,j,h);
                        cnt++;
                    }  
                }
            }
            max_v = Math.max(max_v,cnt);
        }
        System.out.println(max_v);
    }

    public static void bfs(int x, int y,int h) {
        Queue<Node> q = new ArrayDeque<Node>();
        q.add(new Node(x,y));

        while (!q.isEmpty()) {
            Node cur = q.poll();

            for (int i=0; i<4; i++) {
                int nx = cur.x + dx[i];
                int ny = cur.y + dy[i];

                if (check(nx,ny) && !visited[nx][ny]) {
                    if (arr[nx][ny] > h) {
                        q.add(new Node(nx,ny));
                        visited[nx][ny] = true;
                    }
                }
            }
        }
    }

    public static boolean check(int x, int y) {
        if (0 <= x && x < n && 0 <= y && y < n) return true;
        else return false;
    }
}

class Node{
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

해당 코드가 오답을 받았던 이유는 "강수량이 될 수 있는 범위를 모두 고려해주지 않음 + 문제를 제대로 읽지 않음" 입니다 !

문제에서 강수량이 될 수 있는 수가 정확히 나와있지는 않습니다. 저는 높이가 1이상 100이하라고 명시해줘서 당연히 강수량도 1부터 100까지의 수인줄 알았습니다. 하지만 비가 아예 안오는 경우도 있기 때문에 0부터 연속된 모든 수를 고려해야 합니다. (오답의 원인1)

하나 더 실수한 부분은 문제에서 주어진 높이만이 강수량이 될 수 있는게 아니라 강수량은 0부터 max_h 사이의 연속된 수 모두가 될 수 있다는 부분입니다. 만약 가장 높은 높이가 10일 경우, 강수량이 될 수 있는 수는 0부터 10까지입니다. 그렇기에 11가지 경우를 모두 확인해야 합니다 ! (오답의 원인2)

저는 바보같이 주어진 높이만 가능한 줄 알고 set으로 중복을 제거 하고 리스트로 바꿔서 인덱스별로 접근했습니다 ㅠ

수정된 코드

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

public class prac {
    public static int[][] arr;
    public static boolean[][] visited;
    public static int n;
    public static int[] dx = {0,1,0,-1};
    public static int[] dy = {1,0,-1,0};

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

        n = Integer.parseInt(br.readLine());

        arr = new int[n][n];
        int max_v = 0;
        int max_h = 0;

        for (int i=0; i<n; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j=0; j<n; j++) {
                int k = Integer.parseInt(st.nextToken());
                arr[i][j] = k;
                max_h = Math.max(max_h, k);
            }
        }

        for (int t=0; t<=max_h; t++) {
            int cnt = 0;
            visited = new boolean[n][n];
            for (int i=0; i<n; i++) {
                for (int j=0; j<n; j++) {
                    if (!visited[i][j] && arr[i][j] > t) {
                        visited[i][j] = true;
                        bfs(i,j,t);
                        cnt++;
                    }
                }
            }
            max_v = Math.max(max_v,cnt);
        }
        System.out.println(max_v);
    }

    public static void bfs(int x, int y,int h) {
        Queue<Node> q = new ArrayDeque<Node>();
        q.add(new Node(x,y));


        while (!q.isEmpty()) {
            Node cur = q.poll();

            for (int i=0; i<4; i++) {
                int nx = cur.x + dx[i];
                int ny = cur.y + dy[i];

                if (check(nx,ny) && !visited[nx][ny]) {
                    if (arr[nx][ny] > h) {
                        q.add(new Node(nx,ny));
                        visited[nx][ny] = true;
                    }
                }
            }
        }
    }

    public static boolean check(int x, int y) {
        if (0 <= x && x < n && 0 <= y && y < n) return true;
        else return false;
    }
}

class Node{
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

난이도는 실버1이지만 그래프 문제에서 꽤 괜찮은 문제였다고 생각합니다 ! 함정에 빠지지 않도록 항상 신경써야될 거 같습니다 !!

[SSAFY] 싸피 자율 프로젝트 후기 !!!

에릭 Kim — Mon, 2 Dec 2024 11:41:20 +0900

싸피 자율 프로젝트가 끝난지도 어느덧 2주가 지났다.. 후기 이런 거 쓰는 편은 아닌데 조금이나마 도움이 됐으면 좋겠다는 마음으로 작성해봅니다 !!

좀 더 오피셜한 정보를 알고싶으면 싸피셜에서 운영하는 블로그나 인스타 ? 포스팅 보면 좋을듯 ㅎㅎ

1. 자율 프로젝트란 ?

자율프로젝트는 프로젝트 시작 전 비전공자, 전공자 비율의 할당 없이 자유롭게 6인의 팀을 꾸릴 수 있었어요. 그래서 이전에 일정 비율만큼의 비전공자나 전공자가 필요했던 공통, 특화 프로젝트와는 달리 아무런 제약 없이 자신이 원하는 팀원과 함께 프로젝트를 진행할 수 있다는 게 넘 좋았던 점이었습니다. 또 개발에 필요한 교보재도 신청만 하면 싸피 사무국에서 빵빵하게 지원해줍니다 ! 팀당 60만원이었던거 같아요 :)

또한 자율 프로젝트에는 3가지 도메인 중 하나를 선택할 수 있슴다 !

자율 주제
기업연계
오픈소스

이 주제에 맞춰서 마음이 맞는 사람끼리 팀빌딩을 하더라구요 ?? 다들 장단점이 존재하는 거 같아요. 저희 팀은 자율 주제로 진행했어요 :)

(자율 프로젝트 반 1등으로 선정됐을 때 상금에 관한 정보가 거의 없던데 !! 제 기수의 경우엔 1등 - 40만원, 2등- 20만원이었습니다)

2. 팀선정

저는 특화 프로젝트때 같이 했던 팀원들 + 1명의 NF(뉴페이스) 백엔드랑 팀을 이뤘어요. 기존의 팀원들과 같이 했던 이유는 다들 실력이 출중했고, 업무적으로도 잘 맞았기에 또 해도 좋을 거 같다고 생각했었습니다 킼

팀원을 선택하는 게 진짜진짜진짜 중요한 거 같아요. 자율 프로젝트는 주어진 일정이 다른 프로젝트보다 짧기 때문에 팀빌딩의 시간이 거의 없기 때문이죠ㅠ

그리고 프로젝트가 끝나기 전에 미리미리 컨텍하는 분위기니까 플젝 끝나고 하시면 늦습니다 ! 참고 하세융 :)

3. 아이디어 기획

저희 팀은 아이디어 기획 단계에서 조금 전략적으로 아이템을 선정하려고 했어요. 이건 제 뇌피셜이긴 한데 "사회공헌쪽으로 주제를 선정 + 이쁜인터페이스 + 오 좀 잘했네 ?? 하는 기능" 이정도 조합이면 충분히 수상 노려볼만 한 거 같아요. 저희 팀도 이왕 하는 거 열심히 해서 수상하면 베스트라고 생각했기에 주제 선정도 전략적으로 진행했지요

서비스의 타겟층을 5~7세의 어린아이로 잡은 뒤, 아이들의 속마음을 대화를 통해 이끌어내고, 부모님께 데이터 시각화로 보여주자 ! 라는 주제로 가지고 시작하였습니다. 아주 전략적이죠 ? 구현만 제대로 하면 충분히 매력적인 아이템이라고 생각했어요 !

이후엔 어떻게 구현할지에 대해 꽤 많은 시간을 썼던 거 같은데 첨에 나온건 웹앱 기반의 서비스였어요. 요새 아이들이 테블릿을 많이 사용한다나? 전 주변에 어린 아이들이 없어서 잘 몰랐는데 생각보다 엄청 잘쓴다고 함 ! (시작하는 시기가 많이 빨라지긴 했나봄,,) 여튼 그래서 웹앱이 어떤가 고민했는데 아무리 생각해도 다른 팀들과의 차별성을 주기 힘들다고 생각했습니다ㅠ

그리고 개인적으로는 싸피 2학기 내내 웹앱 프론트엔드만 했기 때문에 이번엔 조금 다른 분야를 도전해보고 싶었어요 ! 다른 팀원들도 비슷한 생각이었던 거 같았구요 :)

그래서 결론적으로 !! IoT를 하게 됐어요. 패기로웠지만 사실 막막했는데, 팀에 IoT를 제대로 해본 인원이 한명밖에 없었기 때문에 어떻게 풀어나가야 할까 고민을 많이했습니다 ! 그치만 저희 서비스가 IoT를 엄청 빡빡하게 구현하는 느낌이 아니라서 충분히 해낼 수 있다는 마인드로 다음과 같이 역할 분담을 진행했어요

FE : 1명같은 2명

BE : 2명

IoT : 1명같은 2명

Infra : 1명

데이터분석 : 1명

여덟명 같죠? 6명에서 한건 맞는데 메인이 서버나 프론트가 아니다보니 도와줄 수 있는 부분은 서로서로 도와가면서 역할 분담도 유동적으로 진행했어요.

저는 FE에서 데이터 시각화할 때 사용하는 차트 구현하고 캘린더 커스터마이징 정도 헀구요, IoT에서는 Server-Client 사이에 Mqtt 통신하는 부분 구현했습니다 !

4. 서비스 개발

저희가 갑작스럽게 웹앱에서 IoT로 바꾸다보니 1차 교보재 신청 기간을 놓치게 되었어요ㅠ 그래서 개발에 계속 딜레이가 생겼는데 아무래도 하드웨어 기기가 없다보니 제대로 테스트가 안되더라구요 ! 그 부분이 제일 아쉬웠습니다ㅠ

여기서 스노우볼이 좀 굴러갔는데 저희 팀원들이 사비를 꽤 썼습니다 ! 리튬 배터리도 주문하고 마이크, 잿슨나노(산 건 아님 ㅎ), 충전기 등등 당장 필요한 것들을 사는데 지출이 좀 있었습니다. 그래도 결과가 좋았으니 정상참작 가능했던 거 같아요 킼

열심히 개발 기간을 거쳐서 만들어진 우리 팀의 "토키(Talkie)" 서비스 !!

저는 부울경 지역이었는데, 아무래도 삼성전기가 보안사업장이다보니 인형을 밖으로 들고나오지도 못헀고, 계속 카메라도 붙이고 있어야 해서 실물 사진은 거의 없었습니다ㅠ

자세한 내용은 제 깃헙 참고하시면 도움되실듯 !! ㅎㅎ

https://github.com/busangangster/talkie

GitHub - busangangster/talkie

Contribute to busangangster/talkie development by creating an account on GitHub.

github.com

5. 성과 및 느낀점

저희팀은 본선 발표회에 진출할 수 있었고, 비록 결선에는 가지 못했지만 반 1등을 할 수 있었습니다 :) 결과가 좋았으니 길게 말할 건 없으나 개인적으로는 조금 아쉽기도 했습니다. 자율 프로젝트라 함은 내가 이때까지 배우고 사용했던 기술들을 총망라해서 할 수 있는 가장 최고의 결과물을 도출해야하는데, 과연 이번 프로젝트에 내 모든 것을 쏟아부었을까? 하는 생각이 가장 먼저 떠올랐던 거 같습니다.

물론 취업 시즌이랑도 겹치고, 각자의 우선순위가 다르기 때문에 팀으로서 모두의 의견을 하나로 만들기는 힘들겠지만 조금의 시간이라도 내서 각자의 목표와 방향성을 공유하는 시간을 꼭 가지셨으면 좋겠네요 !! 다들 파이팅입니다 :)

[백준 알고리즘] 20046번: Road Reconstruction (JAVA)

에릭 Kim — Sun, 6 Oct 2024 22:35:43 +0900

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

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

public class Main {
    static int m, n;
    static int INF = 1000 * 1000 + 1;
    static int[][] arr;
    static int[] dx = {-1, 0, 1, 0};
    static int[] dy = {0, -1, 0, 1};
    static int[][] min_dis;

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

        st = new StringTokenizer(br.readLine());
        m = Integer.parseInt(st.nextToken());
        n = Integer.parseInt(st.nextToken());

        arr = new int[m][n];

        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < n; j++) {
                arr[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        if (arr[0][0] == -1 || arr[m-1][n-1] == -1) {
            System.out.println(-1);
            return;
        }
        int ans = dijkstra(0, 0);
        System.out.println(ans);
    }

    public static int dijkstra(int x, int y) {
        min_dis = new int[m][n];
        for (int i = 0; i < m; i++) {
            Arrays.fill(min_dis[i], INF);
        }
        PriorityQueue<Pos> pq = new PriorityQueue<>((o1, o2) -> Integer.compare(o1.cost, o2.cost));
        min_dis[x][y] = (arr[x][y] == 0 ) ? 0 : arr[x][y];
        pq.offer(new Pos(x, y, min_dis[x][y]));

        while (!pq.isEmpty()) {
            Pos cur = pq.poll();

            if (cur.x == m - 1 && cur.y == n - 1) return min_dis[cur.x][cur.y];

            if (min_dis[cur.x][cur.y] < cur.cost) continue;

            for (int i = 0; i < 4; i++) {
                int xx = cur.x + dx[i];
                int yy = cur.y + dy[i];
                if (0 <= xx && xx < m && 0 <= yy && yy < n && arr[xx][yy] != -1) {
                    int cost = arr[xx][yy]  + cur.cost;
                    if (min_dis[xx][yy] > cost) {
                        min_dis[xx][yy] = cost;
                        pq.offer(new Pos(xx, yy, cost));
                    }
                }
            }
        }
        return -1;
    }
}

class Pos {
    int x;
    int y;
    int cost;

    public Pos(int x, int y, int cost) {
        this.x = x;
        this.y = y;
        this.cost = cost;
    }
}

풀이

문제를 풀면서 주의해야 할 부분은 시작점인 0,0을 무조건 0으로 초기화하면 안된다는 것입니다 ! 시작 지점이 막혀있을 수도 있으며 (-1), 시작 지점에 도로가 없는 상태(1 or 2)일 수도 있기 때문에 -1일 경우 -1을 리턴하도록, 1 or 2일 경우 해당 값을 가지고 갈 수 있도록 초기화 해줘야 합니다 !
또한 해당 문제를 최단 경로를 찾는 알고리즘인 BFS로 풀이하면 안될까라는 생각을 할 수도 있지만, BFS의 경우엔 모든 구간에서 똑같은 가중치를 가지고 있어야 하기에 위 문제와 같이 가중치가 1과 2로 다른 경우 다익스트라로 풀이하여햐 합니다 !

[백준 알고리즘] 24511번: queuestack (JAVA)

에릭 Kim — Wed, 3 Jul 2024 15:36:56 +0900

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

소스코드

import java.io.*;
import java.util.*;
public class prac {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        StringBuilder sb = new StringBuilder();

        int n = Integer.parseInt(br.readLine());
        int[] queuestack = new int[n];

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            queuestack[i] = Integer.parseInt(st.nextToken()); // 해당 인덱스의 자료구조가 큐인지 스택인지 
        }

        Deque<Integer> dq = new ArrayDeque<>(); // 값을 넣고 뺼 덱 생성 

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            int k = Integer.parseInt(st.nextToken());
            if (queuestack[i] == 0) { // stack은 후입선출이라 넣었다 빼는 값이 같기 때문에 제외하고 큐만 취급
                dq.add(k);
            }
        }

        int m = Integer.parseInt(br.readLine());
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < m; i++) {
            int v = Integer.parseInt(st.nextToken());
            dq.addFirst(v);
            sb.append(dq.pollLast()).append(" ");
        }
        System.out.println(sb);
    }
}

풀이

★ 생각보다 어려웠던 문제였습니다 ! 처음엔 이중 for문을 사용해서 구현하였습니다. 그랬더니 시간 초과를 받았고, 입력 값 크기를 살펴보니 n과 m이 각각 100,000까지 들어올 수 있기 때문에 이중 for문을 사용하면 100억의 연산과정이 필요하게 됩니다 !

★ 큐는 선입선출의 구조를, 스택은 후입선출의 구조를 가지고 있습니다. 문제에서 주어진 조건을 확인해보면 stack의 경우엔 들어간 값이 바로 제거되기 때문에 굳이 고려해주지 않아도 됩니다 ! 그렇기에 queue 구조만 확인해주면 됩니다.

[Vue.js] Vue에서 컴포넌트 간에 데이터 전송하는 방식

에릭 Kim — Fri, 28 Jun 2024 12:49:10 +0900

1. Props와 Emit

setup

npm install -g @vue/cli // vue cli 설정

vue create my-vue-app // 프로젝트 생성

cd my-vue-app // 디렉토리 이동

ChildComponent.vue

<template>
  <div>
    <h2>자식 컴포넌트</h2>
    <p>부모로부터 받은 데이터: {{ data }}</p>
    <button @click="updateData">데이터 업데이트</button>
  </div>
</template>

<script>
import { defineComponent, toRefs } from 'vue';

export default defineComponent({
  name: 'ChildComponent',
  props: {
    data: {
      type: String,
      required: true
    }
  },
  emits: ['updateData'],
  setup(props, { emit }) {
    const { data } = toRefs(props);

    const updateData = () => {
      emit('updateData', '안녕하세요, 부모 컴포넌트!');
    };

    return {
      data,
      updateData
    };
  }
});
</script>

ParentComponent.vue

<template>
  <div>
    <h1>부모 컴포넌트</h1>
    <p>부모 데이터: {{ parentData }}</p>
    <ChildComponent :data="parentData" @updateData="handleUpdate" />
  </div>
</template>

<script>
import { ref } from 'vue';
import ChildComponent from './ChildComponent.vue';

export default {
  name: 'ParentComponent',
  components: {
    ChildComponent
  },
  setup() {
    const parentData = ref('안녕하세요, 자식 컴포넌트!');

    const handleUpdate = (newData) => {
      parentData.value = newData;
    };

    return {
      parentData,
      handleUpdate
    };
  }
};
</script>

2. Mitt 라이브러리

Mitt 라이브러리란?

: JavaScript와 TypeScript를 위한 매우 간단하고 작은 이벤트 발행-구독(pub/sub) 라이브러리입니다. MITT는 특히 브라우저 환경이나 Node.js 환경에서 이벤트를 간단하게 관리하기 위해 설계되었습니다. 이 라이브러리는 성능이 뛰어나고, 설치 및 사용이 매우 간편하여 많은 개발자들이 선호합니다.

setup

npm install mitt // 라이브러리 설치

eventBus.js

import mitt from 'mitt';
const emitter = mitt();
export default emitter;

ChildComponent.vue

<template>
  <div>
    <h2>자식 컴포넌트</h2>
    <p>부모로부터 받은 데이터: {{ parentData }}</p>
    <button @click="updateData">데이터 업데이트</button>
  </div>
</template>

<script>
import emitter from '../eventBus';
import { defineComponent, toRefs } from 'vue';

export default defineComponent({
  name: 'ChildComponent',
  props: {
    parentData: {
      type: String,
      required: true
    }
  },
  setup(props) {
    const { parentData: receivedData } = toRefs(props);

    const updateData = () => {
      emitter.emit('updateData', '안녕하세요, 부모 컴포넌트!');
    };

    return {
      receivedData,
      updateData
    };
  }
});
</script>

ParentComponent.vue

<template>
  <div>
    <h1>부모 컴포넌트</h1>
    <p>부모 데이터: {{ parentData }}</p>
    <ChildComponent :parentData="parentData" />
  </div>
</template>

<script>
import { ref, onMounted, onUnmounted } from 'vue';
import emitter from '../eventBus';
import ChildComponent from './ChildComponent.vue';

export default {
  name: 'ParentComponent',
  components: {
    ChildComponent
  },
  setup() {
    const parentData = ref('안녕하세요, 자식 컴포넌트!');

    const handleUpdate = (newData) => {
      parentData.value = newData;
    };

    onMounted(() => {
      emitter.on('updateData', handleUpdate);
    });

    onUnmounted(() => {
      emitter.off('updateData', handleUpdate);
    });

    return {
      parentData,
    };
  }
};
</script>

3. Vuex와 같은 상태관리 방식

setup

npm install vuex@next // vueX 설치

store 설정

import { createStore } from 'vuex';

export default createStore({
  state: {
    message: '안녕하세요, 자식 컴포넌트!'
  },
  mutations: { // 상태 변경. 동기적 방식
    setMessage(state, newMessage) {
      state.message = newMessage;
    }
  },
  actions: { // 비동기 작업을 포함한 복잡한 로직을 처리
    updateMessage({ commit }, newMessage) {
      commit('setMessage', newMessage);
    }
  },
  getters: { // 상태를 계산하거나 필터링한 결과
    message: (state) => state.message
  }
});

main.js

import { createApp } from 'vue';
import App from './App.vue';
import store from './store';

const app = createApp(App);
app.use(store);
app.mount('#app');

ChildComponent.vue

<template>
  <div>
    <h2>자식 컴포넌트</h2>
    <p>부모로부터 받은 데이터: {{ message }}</p>
    <button @click="updateData">데이터 업데이트</button>
  </div>
</template>

<script>
import { computed } from 'vue';
import { useStore } from 'vuex';

export default {
  name: 'ChildComponent',
  setup() {
    const store = useStore();
    const message = computed(() => store.getters.message);

    const updateData = () => {
      store.dispatch('updateMessage', '안녕하세요, 부모 컴포넌트!');
    };

    return {
      message,
      updateData
    };
  }
};
</script>

ParentComponent.vue

<template>
  <div>
    <h1>부모 컴포넌트</h1>
    <p>부모 데이터: {{ message }}</p>
    <ChildComponent />
  </div>
</template>

<script>
import { computed } from 'vue';
import { useStore } from 'vuex';
import ChildComponent from './ChildComponent.vue';

export default {
  name: 'ParentComponent',
  components: {
    ChildComponent
  },
  setup() {
    const store = useStore();
    const message = computed(() => store.getters.message);

    return {
      message
    };
  }
};
</script>

결과

Summary

props 및 emit 방식: 단방향 데이터 흐름이 명확하고, 작은 애플리케이션에 적합함. 그러나 깊이 있는 컴포넌트 구조에서는 복잡해질 수 있음.
mitt 라이브러리 방식: 컴포넌트 계층에 구애받지 않고 이벤트를 통해 데이터를 전달 가능. 그러나 네임스페이스 충돌과 이벤트 추적의 어려움이 있을 수 있음.
Vuex와 같은 상태 관리 방식: 중앙 집중식으로 상태를 관리하여 대규모 애플리케이션에 적합. 그러나 설정과 사용이 복잡하고, 학습 곡선이 있을 수 있음.

=> 자신의 프로젝트에 맞는 방식을 채택하면 됨 !!

[자료구조] 세그먼트 트리 (Segment Tree)

에릭 Kim — Fri, 23 Feb 2024 11:09:43 +0900

세그먼트 트리란 ?

배열 또는 리스트와 같은 데이터 구조를 이용하여 구간에 대한 질의를 효율적으로 처리하는 자료구조
주어진 구간에 대한 쿼리 연산을 빠르게 수행할 수 있도록 도와줌. 주로 구간 합, 최솟값 최댓값 등.
트리 구조를 사용하여 데이터를 분할하고 각 분할된 영역에 대한 요약정보를 저장. 이를 통해 트정 구간에 대한 연산을 빠르게 수행할 수 있음
트리를 구축하는 초기 비용이 크지만, 이 후 구간 질의에 대해 빠르게 답을 제공할 수 있음으로 효율적

세그먼트 트리 구조

출처: https://yongj.in/data%20structure/Segment-Tree/

시간복잡도

트리를 구축: O(N)
합, 곱 계산(쿼리 연산): O(logN)
값의 갱신(업데이트 연산): O(logN)

=> N은 배열의 크기이며, 구간에 대한 연산을 처리하는 경우 logN만큼의 시간이 들기 때문에 세그먼트 트리의 시잔복잡도는 O(logN)으로 볼 수 있습니다.

그럼 세그먼트 트리를 왜 쓰나 ?

누적합

누적합의 시간 복잡도는 배열의 길이에 비례함. 배열을 N이라고 했을 때 누적합을 구하는 시간 복잡도는 O(N)인데, 이는 배열의 각 요소를 한번씩 순회하여 누적합을 계산하기 때문입니다.
따라서 배열의 크기게 선형적으로 비례하는 시간이 소요됩니다.

동적 프로그래밍(DP)

DP의 시간복잡도는 문제의 특성과 구현 방식에 따라 달라짐. 하지만 일반적으로는 하위 문제들의 수와, 각 하위 문제를 해결하는 데 걸리는 시간에 따라 결정됨.
메모이제이션을 통해 이미 해결된 문제들을 저장하고 재활용하는 경우, 각 하위 문제를 한번씩만 계산하게 되고, 하위 문제들의 수를 N이라고 할 때, 시간 복잡도는 O(N)이 나오게 됩니다.

=> 세그먼트 트리가 훨씬 빠름

구현

1. 트리 크기 설정

// 트리 크기 설정

// 생성자 함수로 설정할 때
 public SegmentTree(int arrSize) { 
            int h = (int) Math.ceil(Math.log(arrSize) / Math.log(2)); // 트리 높이
            this.treeSize = (int) Math.pow(2,h+1); // 높이를 통해 배열 크기 구하기
            tree = new long[treeSize];
        }
        
// 약식으로 설정
tree = new long[N*4];

/*
N = 12 (데이터의 개수)
=> 세그먼트 트리의 전체 크기를 구하기 위해서는 2^k로 N보다 바로 큰 값을 만들 수 있는 k를 찾아야 함.
=> k는 4고, 2^k는 16. 16*2 => 32. 
=> 넉넉하게 N에 4를 곱해준 값으로 트리의 크기를 설정. 
*/

2. 트리 초기화

// 트리 초기화

/*
세그먼트 트리 초기화 단계
1. 트리의 루트(root) 노드부터 시작합니다.
2. 배열의 전체 구간을 표현하는 루트 노드의 구간을 계산하고 값을 할당합니다.
3. 재귀적으로 왼쪽 서브트리와 오른쪽 서브트리를 초기화합니다.
4. 각 노드의 구간을 계산하고 해당 구간에 속하는 배열 요소들의 값을 합산하여 현재 노드에 저장합니다.
5.리프(leaf) 노드까지 이 과정을 반복합니다.
*/

// tree: 원소 배열, node: 현재 노드, start: 현재 구간의 시작점, edn: 현재 구간의 끝점
public  long init(long[] tree, int node, int start, int end) {
	// 배열의 시작과 끝이 같으면 리프 노드! 
    if (start == end) return tree[node] = arr[start]; 

	// 아니면 자식 노드 합을 저장. 재귀 형식임 
    int mid = (start+end) / 2;
    return tree[node] = init(tree,node*2,start,mid) + init(tree,node*2+1,mid+1,end);
}

3. 값 갱신

// 값 갱신 

public  void update(long[] tree, int node, int start, int end, int idx, long diff) {
    if (idx < start || idx > end) return; // 범위밖에 있는 경우

	// 값이 변경되는 차이만큼 원소 갱신
    tree[node] += diff; 

    int mid = (start+end) / 2;
    if (start != end) { // 재귀로 리프 노드까지 값 변경 진핸
        update(tree,node*2,start,mid,idx,diff);
        update(tree,node*2+1,mid+1,end,idx,diff);
    }
}

4. 구간 합 연산

// 구간 합 연산

/*
구간 합 연산 단계
1. 구간이 포함하는 노드들을 찾습니다. 이는 세그먼트 트리의 특성에 따라 수행됩니다.
2. 구간이 포함하는 노드들의 값을 합하여 구간의 부분 합을 계산합니다.
3. 필요에 따라 노드들을 재귀적으로 탐색하여 구간을 더 세분화하고 각 부분 구간의 합을 계산합니다.
4. 최종적으로 모든 부분 구간의 합을 더하여 전체 구간의 합을 얻습니다.
*/

public static long sum(int node, int start, int end, int left, int right) {
	if ( left > end || right < start) return 0; // 범위를 벗어나는 경우
		
	if (left <= start && end <= right) return tree[node]; //범위를 완전히 포함하는 경우
		
    // 재귀로 지속적으로 구간 값 연산 진행
	int mid = (start+end) / 2;
	return sum(node*2,start,mid,left,right) + sum(node*2+1,mid+1,end,left,right);
}

기본 문제

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

2042번: 구간 합 구하기

첫째 줄에 수의 개수 N(1 ≤ N ≤ 1,000,000)과 M(1 ≤ M ≤ 10,000), K(1 ≤ K ≤ 10,000) 가 주어진다. M은 수의 변경이 일어나는 횟수이고, K는 구간의 합을 구하는 횟수이다. 그리고 둘째 줄부터 N+1번째 줄

www.acmicpc.net

코드

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

class Main {
    static long[] arr;
    static int a,b;
    static long c;

    public static class SegmentTree {
        long[] tree;
        int treeSize;

        public SegmentTree(int arrSize) {
            int h = (int) Math.ceil(Math.log(arrSize) / Math.log(2));
            this.treeSize = (int) Math.pow(2,h+1);
            tree = new long[treeSize];
        }

        public  long init(long[] tree, int node, int start, int end) {
            if (start == end) return tree[node] = arr[start];

            int mid = (start+end) / 2;
            return tree[node] = init(tree,node*2,start,mid) 
            		+ init(tree,node*2+1,mid+1,end);
        }

        public  void update(long[] tree, int node, int start, int end, int idx, long diff) {
            if (idx < start || idx > end) return;

            tree[node] += diff;

            int mid = (start+end) / 2;
            if (start != end) {
                update(tree,node*2,start,mid,idx,diff);
                update(tree,node*2+1,mid+1,end,idx,diff);
            }
        }

        public  long sum(long[] tree, int node, int start, int end, int left, int right) {
            if (left > end || right < start) return 0;

            if (left <= start && end <= right) {
                return tree[node];
            }

            int mid = (start+end) / 2;
            return sum(tree,node*2,start,mid,left,right) 
            		+ sum(tree,node*2+1,mid+1,end,left,right);
        }

    }

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

    int N = Integer.parseInt(st.nextToken());
    int M = Integer.parseInt(st.nextToken());
    int k = Integer.parseInt(st.nextToken());
    arr = new long[N+1];

    for (int i=1; i<=N;i++) {
        arr[i] = Long.parseLong(br.readLine());
    }

    SegmentTree sgTree = new SegmentTree(N);

    sgTree.init(sgTree.tree,1,1,N);

    for (int i=0; i< M+k;i++) {
        st = new StringTokenizer(br.readLine());
        a = Integer.parseInt(st.nextToken());
        b = Integer.parseInt(st.nextToken());
        c = Long.parseLong(st.nextToken());

        if (a == 1) { 
             sgTree.update(sgTree.tree,1,1,N,b,c-arr[b]);
             arr[b] = c; // update 연산시, 배열 arr도 함께 바꿔줘야 트리의 값을 변경할 때 반영됨
        }
        else {
            sb.append(sgTree.sum(sgTree.tree,1,1,N,b,(int) c)).append("\n");
        	}
    	}
    System.out.println(sb);
	}
}

Tips

트리의 크기는 데이터의 개수 * 4로 설정하기 !!
입력으로 초기값이 들어오지 않으면, 초기화하는 과정 필요없음 !! (init 메서드 생략)

[백준 알고리즘] 10423번: 전기가 부족해 (JAVA)

에릭 Kim — Thu, 22 Feb 2024 21:36:27 +0900

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

10423번: 전기가 부족해

첫째 줄에는 도시의 개수 N(1 ≤ N ≤ 1,000)과 설치 가능한 케이블의 수 M(1 ≤ M ≤ 100,000)개, 발전소의 개수 K(1 ≤ K ≤ N)개가 주어진다. 둘째 줄에는 발전소가 설치된 도시의 번호가 주어진다. 셋째

www.acmicpc.net

소스코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main {

static int N,M,K,ans;
    static boolean[] visited;
    static ArrayList<ArrayList<Node>> graph;
    static ArrayList<Integer> elec;
    public static void main(String[] args) throws Exception {
        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());
         K = Integer.parseInt(st.nextToken());

         elec = new ArrayList<Integer>();
         visited = new boolean[N+1];
         graph = new ArrayList<ArrayList<Node>>();

         for (int i=0; i<=N; i++) {
            graph.add(new ArrayList<>());
         }

         st = new StringTokenizer(br.readLine());
         for (int i=0; i<K; i++) {
            elec.add(Integer.parseInt(st.nextToken())); 
         }

         for (int i=0; i<M; i++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            int w = Integer.parseInt(st.nextToken());
            graph.get(u).add(new Node(v,w));
            graph.get(v).add(new Node(u,w));
         }

         Prim();
         System.out.println(ans);
    
    }

    public static void Prim() {
        PriorityQueue<Node> pq = new PriorityQueue<Node>();

        ans = 0;

        for (int i=0; i<elec.size(); i++) { // 발전소가 있는 위치를 우선순위 큐에 한번에 넣어줌
            pq.offer(new Node(elec.get(i),0));
        }

        while (!pq.isEmpty()) {
            Node cur = pq.poll();

            if (visited[cur.x]) continue;

            visited[cur.x] = true;
            ans += cur.weight;

            for (Node next: graph.get(cur.x)) {
                if (!visited[next.x] && check(next.x)) {
                    pq.offer(new Node(next.x, next.weight));
                }
            }
        }
    }

    public static boolean check(int x) {
        if (elec.contains(x)) return false;
        return true;
    }
}

class Node implements Comparable<Node>{
    int x;
    int weight;
    public Node(int x, int weight) {
        this.x = x;
        this.weight = weight;
    }
    @Override
    public int compareTo(Node o) {
        return this.weight - o.weight;
    }
}

풀이

★ 문제 유형은 최소 신장 트리이고, 간선의 수가 정점의 수보다 많기 때문에 저는 "프림" 알고리즘을 사용해 문제를 해결하였습니다.

★ 전체적인 틀은 프림 알고리즘의 기본 구조와 크게 다르지 않습니다. 전 두가지를 고려해줬습니다.

1. 발전소의 위치를 한번에 우선순위 큐에 넣은 뒤, prim 알고리즘을 수행한다.

2. 발전소가 있는 정점이면 따로 방문하지 않는다.

사실 1번은 이전에 비슷한 유형의 문제를 풀어본 경험이 없다면 아이디어가 쉽게 떠오르지 않았을 거라고 생각하기도 했습니다 ! (하지만 정답률이 꽤 높군요 ㅎㅎ)

[백준 알고리즘] 1268번: 임시 반장 정하기 (JAVA)

에릭 Kim — Wed, 14 Feb 2024 09:33:47 +0900

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

1268번: 임시 반장 정하기

오민식 선생님은 올해 형택초등학교 6학년 1반 담임을 맡게 되었다. 오민식 선생님은 우선 임시로 반장을 정하고 학생들이 서로 친숙해진 후에 정식으로 선거를 통해 반장을 선출하려고 한다.

www.acmicpc.net

소스코드

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

public class Main {
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();
		StringTokenizer st;
		
		int N = Integer.parseInt(br.readLine());
		int[][] arr = new int[N][5];
		
		for (int i = 0; i< N; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j=0; j< 5; j++) {
				arr[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		int max_v = Integer.MIN_VALUE;
		int ans = 0;
		for (int i=0; i<N; i++) {
			int cnt = 0;
			for (int j=0; j<N;j++) {
				if (i == j) continue;
				else {
					for (int k=0; k<5; k++) {
						if (arr[i][k] == arr[j][k]) {
							cnt++;
							break;
						}
					}
				}
			}
			if (cnt > max_v) {
				max_v = cnt;
				ans = i+1;
			}
		}
        
		sb.append(ans);
		System.out.println(sb);
		
	}
}

풀이

★ 연산횟수를 어림잡아봤을 때, 3중 반복문으로도 충분히 풀 수 있을 거 같았습니다 ! 학생별로 각 학년마다 몇반이었는지를 다른 모든 학생들과 비교해줬습니다. 이 때 주의해야 할 부분은 한번이라도 같은 반이었던 사람이 가장 많은 학생을 임시반장으로 선정한다는 것입니다. 저는 이 부분을 고려하지 않아서 맞왜틀을 2번 시전했습니당 :)

★ 위 조건은 한 학생이 다른 사람과 여러 학년에 걸쳐서 같은 반이 되었더라도, 한번만 카운트해줘야 한다는 것입니다 ! 그렇기에 반복문을 돌면서 break문으로 빠져나와줬습니다.

[백준 알고리즘] 7570번: 줄 세우기 (JAVA)

에릭 Kim — Tue, 13 Feb 2024 21:12:48 +0900

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

7570번: 줄 세우기

입력은 2 개의 줄로 이루어져 있다. 첫 줄에는 어린이 수를 나타내는 정수가 주어진다. 둘째 줄에는 처음에 줄서있는 어린이들의 번호가 차례대로 주어진다. 주어진 번호들 사이에는 공백이 하

www.acmicpc.net

소스코드

package Baekjoon.DP;
import java.io.*;
import java.util.*;

class P7570 {
    public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();
		StringTokenizer st;
		
		// 뽑은 수를 맨 뒤와 앞으로만 이동시킬 수 있기 때문에, 증가하는 부분수열은 연속적이어야 함 !
		// 그게 아니라 아무데나 집어넣을 수 있으면 연속적이지 않아도 됨. 
		int N = Integer.parseInt(br.readLine());
		int[] dp = new int[N+1];

		st = new StringTokenizer(br.readLine());
		for (int i=0; i<N;i++) {
			int k = Integer.parseInt(st.nextToken());
			dp[k] = dp[k-1]+1;
		}

        sb.append(N-Arrays.stream(dp).max().getAsInt());
        System.out.println(sb);
        
	}
}

풀이

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

2631번: 줄세우기

KOI 어린이집에는 N명의 아이들이 있다. 오늘은 소풍을 가는 날이다. 선생님은 1번부터 N번까지 번호가 적혀있는 번호표를 아이들의 가슴에 붙여주었다. 선생님은 아이들을 효과적으로 보호하기

www.acmicpc.net

★ 위 문제와 비슷한 유형의 문제이지만 이동하는 학생이 아무데나 갈 수 있는 것이 아니라, 줄의 맨 앞과 뒤로만 이동할 수 있다는 점이 차이입니다. 이는 곧 증가하는 부분 수열이지만, 연속적인 수를 가져야 한다는 의미입니다 !

예시로, 5 2 4 1 3이 주어진 경우, 2와 3은 움직이지 않고 5, 4, 1만 맨 앞, 뒤로 보내면서 조건을 만족하는 수열을 만들 수 있습니다 ! 이때 dp의 인덱스는 0번부터 시작하는 것이 아니라, 수열의 값이 dp의 인덱스가 됩니다. 그렇기에 자기 자신의 바로 전 dp의 값이 +1을 한 값이 자신의 dp 값이 됩니다 !

[백준 알고리즘] 2631번: 줄세우기 (JAVA)

에릭 Kim — Tue, 13 Feb 2024 20:58:34 +0900

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

2631번: 줄세우기

www.acmicpc.net

소스코드

package Baekjoon.DP;
import java.io.*;
import java.util.*;

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

        int N = Integer.parseInt(br.readLine());
        int[] arr = new int[N];
        int[] dp = new int[N];

        for (int i=0; i<N; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }

        for (int i=0; i<N; i++) {
            dp[i] = 1;
            for (int j=0; j<i; j++) {
                if (arr[i] > arr[j]) {
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
            }
        }

        sb.append(N - Arrays.stream(dp).max().getAsInt());
        System.out.println(sb);
        
    }
}

풀이

★ 일반적인 LIS(Longest Increasing Subsequence, 최장 증가 수열)을 활용하는 문제입니다. 문제에서 주어진 수열을 가지고 예시를 들어보면, 3 7 5 2 6 1 4 이라는 값 중, 최장 증가 수열은 3, 5, 6인 것을 알 수 있습니다. 그럼 3, 5, 6은 고정되어 있고, 나머지 수인 7,2,1,4만 움직여서 주어진 수열을 오름차순 정렬할 수 있습니다.

★ 최종적으로는 LIS 중 가장 긴 값을 찾아주고, 전체 값인 N에서 LIS를 빼준 값을 출력해주면 됩니다:)

[백준 알고리즘] 10999번: 구간 합 구하기 2 (JAVA)

에릭 Kim — Tue, 6 Feb 2024 22:45:21 +0900

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

10999번: 구간 합 구하기 2

www.acmicpc.net

소스코드

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

class Main {
    static long[] tree,lazy,arr;
    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());
        int K = Integer.parseInt(st.nextToken());

        arr = new long[N+1];
        tree = new long[N*4];
        lazy = new long[N*4];

        for (int i=1; i<= N;i++) {
            arr[i] = Long.parseLong(br.readLine());
        }

        init(1, 1, N);

        for (int i=0; i<M+K;i++) {
            st = new StringTokenizer(br.readLine());
            int cmd = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            int c = Integer.parseInt(st.nextToken());
            if (cmd == 1) {
                long d = Long.parseLong(st.nextToken());
                update(1, 1, N, b, c, d);
                
            }
            else {
                if (b<=c) {
                    sb.append(sum(1, 1, N, b, c)).append("\n");
                }
                else {
                    sb.append(sum(1, 1, N, c, b)).append("\n");
                }

            }
        }
        System.out.println(sb);
    }    

    public static long init(int node, int start, int end) {
        if (start == end) return tree[node] = arr[start];		
		
		int mid = (start + end) / 2;
		return tree[node] = init(node*2,start,mid) + init(node*2+1,mid+1,end);
    }

    public static void wait(int node, int start, int end) {
        if (lazy[node] != 0) {
            if (start != end) {
                lazy[node*2] += lazy[node];
                lazy[node*2+1] += lazy[node];
            }
            tree[node] += lazy[node] *(end-start+1);
            lazy[node] = 0;
        }
    }

    public static void update(int node, int start, int end, int left, int right, long value) {
        wait(node,start,end);
        if (left > end || right < start) return;

        if (left <= start && end <= right) {
            lazy[node] = value;
            wait(node, start, end);
            return;
        }

        int mid = (start + end) / 2;
        update(node*2, start, mid, left, right, value);
        update(node*2+1, mid+1, end, left, right, value);
        tree[node] = tree[node*2]+tree[node*2+1];
    }

    public static long sum(int node, int start, int end, int left, int right) {
        wait(node, start, end);
        if (left > end || right < start) return 0;

        if (left <= start && end <= right) return tree[node];

        int mid = (start + end) / 2;
        return sum(node*2, start, mid, left, right) 
        	+ sum(node*2+1, mid+1, end, left, right);
    }
}

[알고리즘] BFS - 너비 우선 탐색 (JAVA)

에릭 Kim — Sun, 4 Feb 2024 17:35:04 +0900

BFS란

루트 노드 (혹은 시작 노드)에서 시작하여 인접한 노드를 먼저 방문하는 알고리즘입니다. 즉 DFS와 같이 깊이를 먼저 탐색하는 것이 아니라 자신 주변을 넓게 탐색하여 너비 우선 탐색이라고 불립니다.
BFS로 최단경로를 찾을 수 있는 이유는 한 정점에서 연결되는 모든 길을 "한번씩" 탐색하기 때문입니다. 특정 노드와 연결된 노드 사이의 길이는 1이기 때문에 같은 방식으로 모든 노드 사이의 거리를 구할 수 있기 때문입니다. 하지만 가중치가 있는 그래프의 경우 BFS를 사용할 수 없습니다 !

출처: 나무위키

BFS의 특징

그래프 탐색 시, 어떤 노드를 방문했는지 여부를 반드시 검사해야 합니다. 검사하지 않았을 경우, 무한루프에 빠질 수 있습니다.
BFS 알고리즘은 일반적으로 선입선출(FIFO)의 특징을 가지는 큐 자료구조를 사용합니다.
보통은 가중치가 없는 그래프에서 최단 경로를 찾거나, 임의의 경로를 찾고자 할 때 사용합니다

Queue 구현 시, LinkedList ? or ArrayDeque ?

ArrayDeque는 Queue의 서브 인터페이스인 Deque의 구현체, LinkedList는 List와 Quque의 구현체 !

- 연산 성능

ArrayDeque과 LinkedList 모두 원소의 삽입/삭제 연산은 O(1)로 뛰어납니다. 하지만 원소를 조회하는 속도에서 차이가 나는데, LinkedList의 경우 O(n)의 시간복잡도를 가지지만 ArrayDeque의 경우엔 O(1)의 성능을 가집니다. 그 이유는 LinkedList에서는 순차접근만 가능하기 때문입니다.

- 메모리

LinkedList의 경우에는 next, prev와 같은 참조자 또한 저장해줘야 하기 때문에 추가적인 메모리를 할당해야 합니다. 그렇기에 ArrayDeque보다 추가적인 공간이 더 필요할 수 밖에 없는 구조입니다.

BFS 예시

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

2178번: 미로 탐색

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

www.acmicpc.net

소스코드

package Baekjoon.BFS;
import java.util.*;
import java.io.*;

class P2178 {
    static int[][] arr;
    static int[] dx = {1,0,-1,0};
    static int[] dy = {0,-1,0,1};
    static int N,M;
    static boolean[][] visited;
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        arr = new int[N][M];

        for (int i=0;i< N;i++) {
            String s = br.readLine();
            for (int j=0;j<M;j++) {
                arr[i][j] = s.charAt(j)- '0';
            }
        }

        visited = new boolean[N][M];
        visited[0][0] = true;
        BFS(0,0);
        sb.append(arr[N-1][M-1]);
        System.out.println(sb);

    }   
    
    public static void BFS(int x, int y) {
        Queue<Node> q = new ArrayDeque<>();
        q.add(new Node (x,y));

        while (!q.isEmpty()) {
            Node cur = q.poll();

            for (int i=0; i<4;i++) {
                int nx = cur.x + dx[i];
                int ny = cur.y + dy[i];

                if (nx >= 0 && nx < N && ny >= 0 && ny < M) { // 범위 안에 있으면서
                    if (!visited[nx][ny] && arr[nx][ny] != 0) { // 아직 방문 X, 0이 아닌경우
                        visited[nx][ny] = true;
                        arr[nx][ny] = arr[cur.x][cur.y] + 1;
                        q.add(new Node(nx,ny));
                    }
                }
            }
        }
    }
}

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

[백준 알고리즘] 11505번: 구간 곱 구하기 (JAVA)

에릭 Kim — Fri, 2 Feb 2024 09:27:05 +0900

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

11505번: 구간 곱 구하기

첫째 줄에 수의 개수 N(1 ≤ N ≤ 1,000,000)과 M(1 ≤ M ≤ 10,000), K(1 ≤ K ≤ 10,000) 가 주어진다. M은 수의 변경이 일어나는 횟수이고, K는 구간의 곱을 구하는 횟수이다. 그리고 둘째 줄부터 N+1번째 줄

www.acmicpc.net

소스코드

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

class Main {
    static long[] arr;
    static int a,b,c;
    static final int MOD = 1000000007;

    public static class SegmentTree {
        long[] tree;
        int treeSize;

        public SegmentTree(int arrSize) {
            int h = (int) Math.ceil(Math.log(arrSize) / Math.log(2));
            treeSize = (int) Math.pow(2,h+1);
            tree = new long[treeSize];
        }

        public long init(long[] tree, int node, int start, int end) {
            if (start == end) return tree[node] = arr[start];

            int mid = (start+end) / 2;
            return tree[node] = init(tree,node*2,start,mid) 
            				* init(tree,node*2+1,mid+1,end) % MOD;
        }

        public long update(long[] tree, int node, int start, int end, int idx, int value) {
            if (idx < start || idx > end) return tree[node];
 
            if (start == end) return tree[node] = value;
            
            int mid = (start+end) / 2;
            return tree[node] = update(tree,node*2,start,mid,idx,value)
            				* update(tree,node*2+1,mid+1,end,idx,value) % MOD;
        }

        public long multi(long[] tree, int node, int start, int end, int left, int right) {
            if (left > end || right < start) return 1;

            if (left <= start && end <= right) return tree[node];

            int mid = (start+end)/2;
            return multi(tree, node*2, start, mid, left, right) 
            	* multi(tree, node*2+1, mid+1, end, left, right) % MOD;
        }
    }


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

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

        arr = new long[N+1];

        for (int i=1; i<=N; i++) {
            arr[i] = Long.parseLong(br.readLine()); 
        }

        SegmentTree sgTree = new SegmentTree(N);

        sgTree.init(sgTree.tree, 1, 1, N);

        for (int i=0; i<M+K; i++) {
            st = new StringTokenizer(br.readLine()," ");
            a = Integer.parseInt(st.nextToken());
            b = Integer.parseInt(st.nextToken());
            c = Integer.parseInt(st.nextToken());
            if (a == 1){
                arr[b] = c;
                sgTree.update(sgTree.tree, 1, 1, N, b, c);
            }
            else {
                sb.append(sgTree.multi(sgTree.tree, 1, 1, N, b, c)%MOD).append("\n");
            }
        }
        System.out.println(sb);
    }
}

풀이

★ 구간의 최대 곱을 구하는 방식은 최대합을 구하는 방식과는 조금 다릅니다. 구간의 합은 리프 노드부터 시작하지 않고, 위에서부터 아래로 내려가며, 값의 차이인 diff를 더해주는 방식이었습니다. 하지만 곱의 경우에는 0을 곱해주게 되면, 한번 0으로 초기화 된 값은 다시 0이 아닌 수로 바꿀 수 없기 때문에 리프 노드에서부터 밑에서 위로 읽어가며 곱셈을 수행해줘야 합니다 !

[백준 알고리즘] 2042번: 구간 합 구하기 (JAVA)

에릭 Kim — Fri, 2 Feb 2024 09:16:30 +0900

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

2042번: 구간 합 구하기

www.acmicpc.net

소스코드

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

class Main {
    static long[] arr;
    static int a,b;
    static long c;

    public static class SegmentTree {
        long[] tree;
        int treeSize;

        public SegmentTree(int arrSize) {
            int h = (int) Math.ceil(Math.log(arrSize) / Math.log(2));
            this.treeSize = (int) Math.pow(2,h+1);
            tree = new long[treeSize];
        }

        public  long init(long[] tree, int node, int start, int end) {
            if (start == end) return tree[node] = arr[start];

            int mid = (start+end) / 2;
            return tree[node] = init(tree,node*2,start,mid) 
            					+ init(tree,node*2+1,mid+1,end);
        }

        public  void update(long[] tree, int node, int start, int end, int idx, long diff) {
            if (idx < start || idx > end) return;

            tree[node] += diff;

            int mid = (start+end) / 2;
            if (start != end) {
                update(tree,node*2,start,mid,idx,diff);
                update(tree,node*2+1,mid+1,end,idx,diff);
            }
        }

        public  long sum(long[] tree, int node, int start, int end, int left, int right) {
            if (left > end || right < start) return 0;

            if (left <= start && end <= right)  return tree[node];

            int mid = (start+end) / 2;
            return sum(tree,node*2,start,mid,left,right) 
              		+ sum(tree,node*2+1,mid+1,end,left,right);
        }

    }

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

        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());
        arr = new long[N+1];

        for (int i=1; i<=N;i++) {
            arr[i] = Long.parseLong(br.readLine());
        }

        SegmentTree sgTree = new SegmentTree(N);

        sgTree.init(sgTree.tree,1,1,N);

        for (int i=0; i< M+k;i++) {
            st = new StringTokenizer(br.readLine());
            a = Integer.parseInt(st.nextToken());
            b = Integer.parseInt(st.nextToken());
            c = Long.parseLong(st.nextToken());

            if (a == 1) {
                 sgTree.update(sgTree.tree,1,1,N,b,c-arr[b]);
                 arr[b] = c;
            }
            else {
                sb.append(sgTree.sum(sgTree.tree,1,1,N,b,(int) c)).append("\n");
            }
        }
        System.out.println(sb);
    }
}

풀이

★세그먼트 트리를 사용하는 아주 기본적인 문제입니다 ! 구간의 합을 누적합이나 반복문으로 풀게 되면 시간초과가 발생하게 되고, 세그먼트 트리라는 알고리즘을 사용하여 풀어야 합니다 :)

★ 세그먼트 트리 참고

https://hongjw1938.tistory.com/20

자료구조 - 세그먼트 트리(Segment Tree)

1. 세그먼트 트리(Segment Tree, 구간 트리)란? 특정 구간 내 연산(쿼리)에 대해 빠르게 응답하기 위해 만들어진 자료구조이다. 예를 들어 크기가 N=100인 int배열 arr이 있다면 1~100의 인덱스 내 숫자들

hongjw1938.tistory.com

[백준 알고리즘] 20529번: 가장 가까운 세 사람의 심리적 거리 (JAVA)

에릭 Kim — Wed, 31 Jan 2024 21:27:48 +0900

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

20529번: 가장 가까운 세 사람의 심리적 거리

각 테스트 케이스에 대한 답을 정수 형태로 한 줄에 하나씩 출력한다.

www.acmicpc.net

소스코드

package Baekjoon.브루트포스;
import java.util.*;
import java.io.*;

class P20529 {
    static int bt;
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();
		
		int T = Integer.parseInt(br.readLine());
		for (int t = 0; t < T; t++) {
			int N = Integer.parseInt(br.readLine());
			String[] arr = new String[N];
			StringTokenizer st = new StringTokenizer(br.readLine()," ");
			int min_v = Integer.MAX_VALUE;
			
			for (int n = 0; n<N;n++) {
				arr[n] =  st.nextToken();
			}
			
			if (N > 32) { // 같은 mbti가 하나라도 3개 이상 있을 시, 답은 무조건 0임 
				sb.append(0).append("\n");
				continue;
			}
		
			else {
				for (int i=0; i<N-2;i++) {
					for (int j=i+1;j<N-1;j++) {
						for (int k=j+1; k<N; k++) {
							bt = 0;
							compare(arr[i],arr[j]);
							compare(arr[j],arr[k]);
							compare(arr[i],arr[k]);
							
							if (bt < min_v) {
								min_v = bt;
							} 
						}		
					}
				}
				sb.append(min_v).append("\n");
			}
		}	
		System.out.println(sb);
	}
	
	public static void compare(String x, String y) {
		for (int i=0; i<4;i++) {
			if (x.charAt(i) != y.charAt(i)) {
				bt += 1;
			}
		}
	}
}

풀이

★ 삼중 for문을 사용하면서 완탐으로 풀어도 되는 문제인지 긴가민가했습니다. 하지만 n이 32 초과일 경우엔 답이 0이 되고, 더이상의 반복문을 수행하지 않아도 되기에 괜찮습니다 !!

★ n이 32를 초과할 때 답이 0이 되는 이유는 다음과 같습니다. mbti는 총 2^4개로 16개가 있습니다. 입력에 같은 mbti가 2개까지만 들어온다면 이는 반복문을 통해 심리적 거리가 최소가 되는 경우를 찾아줘야 합니다. 하지만 32를 넘어가는 순간, 특정 mbti가 3개 들어왔다는 것을 알 수 있습니다. 특정 mbti가 3개일 경우 심리적 거리의 최소는 항상 0이기 때문에 답에 0을 저장하고 반복문을 빠져나와도 괜찮은 것입니다. (이는 예제 2번을 보면 더 잘 이해할 수 있습니다 ! )

[JAVA] Prioirty Queue 우선순위 큐 (자료구조)

에릭 Kim — Sun, 28 Jan 2024 18:43:33 +0900

우선순위 큐란 ?

- 일반적인 큐의 구조 FIFO(First In First Out)의 구조를 가지지만, 데이터가 들어온 순서대로 빠져나가는 것이 아니라, 우선순위를 결정하고, 우선순위에 따라 데이터가 출력되는 구조입니다 .

- 내부가 힙의 구조로 되어있기 때문에 O(nlogn)의 시간복잡도를 가지게 됩니다.

- 배열에 값을 추가하면서 따로 정렬하지 않더라도 자동으로 정렬되는 것이 장점입니다.

우선순위 큐 선언

import java.util.PriorityQueue;

PriorityQueue<> hq = new PriorityQueue<>();

우선순위에 따른 최대, 최소 힙

- 최소힙: 최솟값이 우선순위인 큐

import java.util.PriorityQueue;

PriorityQueue<> hq = new PriorityQueue<>();

- 최대힙: 최댓값이 우선순위인 큐

import java.util.PriorityQueue;
import java.util.Collections; 

PriorityQueue<> hq = new PriorityQueue<>(Collections.reverseOrder());

우선순위 큐에 데이터 삽입, 삭제, 확인

- 값을 삽입, 제거할 때 O(n)의 시간복잡도 발생.

import java.util.PriorityQueue;

PriorityQueue<> hq = new PriorityQueue<>();

// 삽입
hq.add(1); // 삽입에 성공하면 true 반환
hq.add(10);
hq.offer(100); // 삽입 실패시, 예외발생 

// 삭제
hq.poll(100); 첫번째 값을 제거하고 비어있다면 null 반환
hq.remove(10); // 값이 비어있으면, 에외 발생

// 첫번째 값 체크(반환만 하고, 제거는 X)
hq.peek();  큐가 비어있으면 null 반환
hq.element(); 예외 발생 

// 초기화
hq.clear();

우선순위 큐 동작 방식

출처: https://coding-factory.tistory.com/603

- 리스트 정렬과 우선순위 큐 중에 뭘 써야 더 성능이 좋을까 ??

Arrays.sort()의 경우에는 평균 nlogn, 최악의 경우 n^2의 시간복잡도

Collections.sort()의 경우 평균, 최악 둘다 nlogn

우선순위 큐의 경우에는 정렬된 상태에서 삽입, 삭제 연산이 일어나기 때문에 logn을 유지 !!

BOJ 추천문제
- https://www.acmicpc.net/problem/1927

1927번: 최소 힙

첫째 줄에 연산의 개수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 N개의 줄에는 연산에 대한 정보를 나타내는 정수 x가 주어진다. 만약 x가 자연수라면 배열에 x라는 값을 넣는(추가하는) 연산이고, x가 0

www.acmicpc.net

- https://www.acmicpc.net/problem/11279

11279번: 최대 힙

www.acmicpc.net

- https://www.acmicpc.net/problem/22252

22252번: 정보 상인 호석

암흑가의 권력은 주먹과 정보에서 나온다. 주먹은 한 명에게 강하고, 정보는 세계를 가지고 놀 수 있기 때문에 호석이는 세상 모든 정보를 모으는 "정보 상인"이 되고 싶다. 정보 상인은 정보를

www.acmicpc.net

[백준 알고리즘] 2338번: 긴자리 계산 (JAVA)

에릭 Kim — Thu, 25 Jan 2024 22:54:34 +0900

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

2338번: 긴자리 계산

첫째 줄에 A+B, 둘째 줄에 A-B, 셋째 줄에 A×B를 출력한다. 각각을 출력할 때, 답이 0인 경우를 제외하고는 0으로 시작하게 해서는 안 된다(1을 01로 출력하면 안 된다는 의미).

www.acmicpc.net

소스코드

import java.io.*;
import java.math.BigInteger;

class P2338 {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        // int 형, long 형보다 큰 수가 들어올 수 있는 경우 => BigInteger 
        BigInteger a = new BigInteger(br.readLine());
        BigInteger b = new BigInteger(br.readLine());

        sb.append(a.add(b)).append("\n")
          .append(a.subtract(b)).append("\n")
          .append(a.multiply(b));
        System.out.println(sb);
    }
}

풀이

★ 브론즈 5문제인데 정답률이 50프로길래 뭔가 있겠구나 싶었습니다 ! 그래서 변수의 타입을 int형이 아닌 long형으로 지정해줬습니다. 그 이유는 웬만하면 long형의 데이터 표현 범위 안에 들어오기 때문입니다 !

https://tcpschool.com/java/java_datatype_basic

★ 하지만 long 타입으로도 런타임 에러가 떴고, 다른 방식이 있나 구글링을 해보니 BigInteger라는 클래스를 활용하면 값의 무한대를 표현할 수 있다고 합니다.

★ BigInteger 클래스의 특이점은 문자열을 인자값으로 넘겨줘야 합니다. 또한 문자열이기 때문에 사칙연산이 되지 않습니다 ! 그래서 클래스에서 지원하는 add, subtract, multiply와 같은 메서드로 결과값을 구해줬습니다 :)

★ 자세한 설명은 다음 블로그를 참고하시면 좋을 거 같습니다.

https://coding-factory.tistory.com/604

[Java] 큰 숫자(정수) 다루기 BigInteger 사용법 & 예제 총정리

BigInteger를 사용해야 하는 이유 Type 범위 int -2,147,483,648 ~ 2,147,483,647 long -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 int는 메모리 크기는 4byte로 표현할 수 있는 범위는 -2,147,483,648 ~ 2,147,483,647이고 long

coding-factory.tistory.com

[백준 알고리즘] 26265번: 멘토와 멘티 (JAVA)

에릭 Kim — Thu, 25 Jan 2024 20:48:08 +0900

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

26265번: 멘토와 멘티

서울사이버대학교에는 멘토링 프로그램이 있다. 멘토링 프로그램은 한 명의 멘토(선배학습자)가 여러 명의 멘티(후배학습자)에게 대학 생활에 대한 노하우와 정보 등을 전수하는 것이다. 빅데

www.acmicpc.net

소스코드

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

class P26265 {
    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        int n = Integer.parseInt(br.readLine());

        String[][] arr = new String[n][2];

        for (int i=0;i<n;i++) {
            StringTokenizer st = new StringTokenizer(br.readLine()," ");
            arr[i][0] = st.nextToken();
            arr[i][1] = st.nextToken();
        }
        
        // 이차원 문자열 배열 정렬을 위해서는 람다식을 활용하여 compare를 재정의 해야함
        Arrays.sort(arr,new Comparator<String[]>() {
            @Override
            public int compare(String[] o1, String[] o2) {
                if (o1[0].equals(o2[0])) return o2[1].compareTo(o1[1]);
                else  return o1[0].compareTo(o2[0]);
            }   
        });
        for (String[] m: arr) {
            sb.append(m[0]+" "+m[1]).append("\n");
        }    
        System.out.println(sb);
    }
}

풀이

★ 요즘 계속 정렬문제를 풀고 있는데 자바의 정렬이 다른 언어에 비해서 꽤 까다로운 거 같습니다 ㅠㅠ

★ 2차원 문자열 배열을 정렬하기 위해선 compare 함수를 재정의 해줘야 합니다 ! 재정의 해줄 때 인자 값으로 배열을 받아주고, 해당 문제의 경우에는 멘토가 같을 경우, 멘티를 사전 순 내림차순으로 정렬해줬습니다.

[백준 알고리즘] 7662번: 이중 우선순위 큐 (JAVA)

에릭 Kim — Tue, 23 Jan 2024 17:38:32 +0900

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

7662번: 이중 우선순위 큐

입력 데이터는 표준입력을 사용한다. 입력은 T개의 테스트 데이터로 구성된다. 입력의 첫 번째 줄에는 입력 데이터의 수를 나타내는 정수 T가 주어진다. 각 테스트 데이터의 첫째 줄에는 Q에 적

www.acmicpc.net

소스코드

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

class P7662 {
  public static void main(String[] args)throws Exception{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringBuilder sb = new StringBuilder();
    int t = Integer.parseInt(br.readLine());

    for (int i=0; i<t; i++) {
        int k = Integer.parseInt(br.readLine());
        // 수가 들어갈 때마다 그 수의 개수를 세주면서, 키 값에 따라 오름차순으로 정렬하기 위해 TreeMap를 사용
        TreeMap<Integer, Integer> tm = new TreeMap<>(); 

        for (int j=0;j<k;j++) {
          StringTokenizer st = new StringTokenizer(br.readLine()," ");
          char d = st.nextToken().charAt(0);
          int v = Integer.parseInt(st.nextToken());

          if (d == 'D') { // 수를 트리에서 빼는 경우
            if (tm.isEmpty()) continue;
            else {
              if (v == 1) {
                int tmp = tm.lastKey(); // tree의 최댓값
                int cnt = tm.get(tmp);
                if (cnt == 1) tm.remove(tmp); // 해당 수의 개수가 한개면, 트리에서 삭제
                else tm.put(tmp,cnt-1); // 한개 이상이면 갯수 1 감소 
                  
              } else {
                int tmp = tm.firstKey(); // 트리의 최솟값
                int cnt = tm.get(tmp);
                if (cnt == 1) tm.remove(tmp);
                else tm.put(tmp,cnt-1);
              }
            }
          } else{ // 수를 트리에 집어 넣는경우 
              tm.put(v,tm.getOrDefault(v,0)+1);
          }
	      }
      if (tm.isEmpty()) sb.append("EMPTY").append("\n");
      else sb.append(tm.lastKey()+" "+tm.firstKey()).append("\n");
	    }
    System.out.println(sb);
  }
}

풀이

★ 문제 제목도 이중 우선순위 큐여서 우선순위 큐를 활용해 푸는 방식을 고집했던 거 같습니다 ! 첨엔 두개의 우선순위 큐를 하나는 최대힙, 하나는 최소힙으로 만들어줬습니다. 그 후 입력 받는 값에 따라 각각의 큐에서 값을 제거해줬는데, 시간 제한이 6초임에도 불구하고 계속 시간초과 + 오답을 만날 수 있었습니다 ㅠㅠ

★ 이건 뭔가 방식이 잘못되었다고 생각했고 구글링을 해보니, java의 자료구조인 TreeMap을 활용해야 했습니다. java에 입문한지 얼마 안되어서 트리맵의 존재조차 몰랐는데, 풀면서 좋은 공부가 된 거 같습니다. 또한 우선순위 큐에서 remove() 하기 위해서는 큐를 탐색한 다음에 제거해줘야 하는데, 이는 O(n)의 시간이 걸리게 됩니다. 반면 TreeMap의 경우에는 O(logn)의 시간복잡도를 가지기에 더 효율적입니다 :)

★ 자료구조를 알게 되니, 문제를 해결하는 아이디어는 비교적 쉽게 나온 거 같습니다. 트리맵은 맵의 구조를 가지고 있으며, 기본적으로 key값 기준으로 오름차순 정렬해줍니다. 이때 입력받는 값의 개수를 value로 세어주고, D가 입력으로 들어왔을 때, 최댓값 or 최솟값을 빼줘야 하는데 그 때마다 값을 빼주며, value또한 1씩 감소시켜줬습니다 !

★ 모든 과정이 끝나고 트리맵이 비어있으면 empty를, 아니면 최댓값고 최솟값을 각각 StringBuilder에 입력해줬습니다 :)

[백준 알고리즘] 14940번: 쉬운 최단거리 (JAVA)

에릭 Kim — Sat, 20 Jan 2024 23:27:47 +0900

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

14940번: 쉬운 최단거리

지도의 크기 n과 m이 주어진다. n은 세로의 크기, m은 가로의 크기다.(2 ≤ n ≤ 1000, 2 ≤ m ≤ 1000) 다음 n개의 줄에 m개의 숫자가 주어진다. 0은 갈 수 없는 땅이고 1은 갈 수 있는 땅, 2는 목표지점이

www.acmicpc.net

소스코드

package Baekjoon.BFS;
import java.util.*;
import java.io.*;

class P14940 {
	static int[] nx = {1,0,-1,0};
	static int[] ny = {0,1,0,-1};
	static int arr[][],ans[][],n,m;
	static boolean[][] visited;
	
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine()," ");
		StringBuilder sb = new StringBuilder();
		
		n = Integer.parseInt(st.nextToken());
		m = Integer.parseInt(st.nextToken());

		arr = new int[n][m]; // 지도
		visited = new boolean[n][m]; // 방문여부 확인
		ans = new int[n][m];

		int x=0,y=0; // 좌표의 값이 2일 때 해당 좌표를 찾기 위한 변수
		for (int i=0;i<n;i++) {
			st = new StringTokenizer(br.readLine()," ");
			for (int j=0;j<m;j++) {
				arr[i][j] = Integer.parseInt(st.nextToken());
				if (arr[i][j] == 2) {
					x = i;
					y = j;
				} else if (arr[i][j] == 0) {
					visited[i][j] = true; // 좌표의 값이 0이면 가지 못하는 곳이기에 방문여부를 True로 초기화
				}
			}
		}

    	BFS(x,y); 

		for (int i=0;i<n;i++) {
			for (int j=0;j<m;j++) {
				if (!visited[i][j]) {
					ans[i][j] = -1 ;
				}
				sb.append(ans[i][j]+" ");
			}
			sb.append("\n");
		}
		System.out.println(sb);
	}
  
	public static void BFS(int x,int y) {
		Queue<int []> dq = new LinkedList<>();
		dq.add(new int[] {x,y});
		visited[x][y] = true;
		
		while (!dq.isEmpty()) {
      		int[] current = dq.poll();
			
			for (int i=0;i<4;i++) {
				int xx = current[0] + nx[i];
				int yy = current[1] + ny[i];
				
				if (0<= xx && xx <n && 0<= yy && yy < m && !visited[xx][yy] && arr[xx][yy] == 1) {
					ans[xx][yy] = ans[current[0]][current[1]] + 1;
          			visited[xx][yy] = true;
          			dq.add(new int[] {xx,yy});
				}
			}
		}
	}
}

[백준 알고리즘] 22252번: 정보 상인 호석 (JAVA)

에릭 Kim — Wed, 17 Jan 2024 11:02:27 +0900

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

22252번: 정보 상인 호석

www.acmicpc.net

소스코드

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

public class Main {
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		HashMap<String,PriorityQueue<Integer>> map = new HashMap<>();
		
		int n = Integer.parseInt(br.readLine());
		long ans = 0;
		
		for (int i=0; i<n; i++) {
			StringTokenizer st = new StringTokenizer(br.readLine()," ");
            
			int info = Integer.parseInt(st.nextToken()); // 쿼리 (1 or 2)
			String name = st.nextToken(); // 고릴라 이름
			int k = Integer.parseInt(st.nextToken()); // 정보 수
            
			if (info == 1) { // 쿼리가 1로 시작할 때
            	// 최대힙 만들기
				PriorityQueue<Integer> p = new PriorityQueue<>(Collections.reverseOrder()); 
				
				for (int j=0;j<k;j++) {
					p.add(Integer.parseInt(st.nextToken()));
				}
				
				if (map.containsKey(name)) { // map에 이미 등록되어 있으면, value에 입력값 추가
					for (int a=0;a<k;a++) {
						map.get(name).add(p.poll());
					}
				} else { // 없으면 새로 만들어준 힙큐를 map에 추가
					map.put(name,p);
				}
	
			} else { // 쿼리가 2일 때
				if (!map.containsKey(name)) { // 이름이 존재하지 않으면 continue
					continue;
				} else { // 있으면 k만큼 힙큐에서 제거하고 출력 값에 더해줌 
					while (!map.get(name).isEmpty() && k >0) {
						ans += map.get(name).poll();
						k --;
					}
				}

			}
	
		}
		System.out.println(ans);	
	}
}

풀이

★ 자바로 우선순위 큐를 사용하는 법을 연습하고, 더불어 HashMap에 데이터를 추가 및 삭제하는 방식을 익히기 위해 문제를 풀어봤습니다 !

★ 문제는 그렇게 복잡하지 않습니다. 고릴라가 가지고 있는 정보의 가치가 높은 순서대로 뽑아줘야 하기 때문에 정보 배열을 우선순위 큐로 만들어줍니다. 이때 가치가 높은 순서대로 뽑아야 하기 때문에 일반적인 최소힙이 아닌, 최대힙으로 힙큐를 구성해줘야 합니다. 그 후 쿼리가 1일 경우 고릴라와 그 정보를 HashMap에 key와 value로 넣어주고 2일 경우 해당 이름을 가지고 있는 고릴라를 찾아서 정보를 제거시켜줍니다.

[백준 알고리즘] 11659번: 구간 합 구하기 4 (JAVA)

에릭 Kim — Tue, 16 Jan 2024 21:46:16 +0900

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

11659번: 구간 합 구하기 4

첫째 줄에 수의 개수 N과 합을 구해야 하는 횟수 M이 주어진다. 둘째 줄에는 N개의 수가 주어진다. 수는 1,000보다 작거나 같은 자연수이다. 셋째 줄부터 M개의 줄에는 합을 구해야 하는 구간 i와 j

www.acmicpc.net

소스코드

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

class P11659 {

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();
		StringTokenizer st = new StringTokenizer(br.readLine()," ");
		int n = Integer.parseInt(st.nextToken());
		int m = Integer.parseInt(st.nextToken());
		
		st = new StringTokenizer(br.readLine()," ");
		int[] arr = new int[n];

		for (int i=0;i<n;i++) {
			arr[i] = Integer.parseInt(st.nextToken());
		}
        int[] dp = new int[n]; // 누적합을 저장하는 배열
        dp[0] = arr[0];

        for (int i=1;i<n;i++) {
          dp[i] = dp[i-1] + arr[i]; // 누적합 저장 
        }

		for (int i=0;i<m;i++) {
			st = new StringTokenizer(br.readLine()," ");
			int k = Integer.parseInt(st.nextToken());
			int t = Integer.parseInt(st.nextToken());
			if (k==1) {
                sb.append(dp[t-1]).append("\n");
              } else {
                sb.append(dp[t-1]-dp[k-2]).append("\n");
              }
                }
		System.out.println(sb);	
	}
}

풀이

★ 입력값이 최대 100,000이 들어오고, 제한 시간이 1초이기 때문에 2중 반복문을 통해 문제에서 주어진 구간의 합을 구하게 된다면 시간초과가 발생하게 됩니다. 그렇기에 입력받은 배열의 길이만큼 누적합 배열을 만든 후, 구간의 합을 누적시키는 배열을 따로 만들어준 뒤, 해결해야 합니다 !!

[백준 알고리즘] 30974번: What's your ETA? (Python)

에릭 Kim — Thu, 11 Jan 2024 22:35:23 +0900

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

30974번: What's your ETA?

첫 번째 줄에는 버스 정류장의 개수 $N$과 임의의 두 버스 정류장 사이를 잇는 양방향 도로의 개수 $M$이 공백으로 구분되어 주어진다. $(2 ≤ N ≤ 400\,000; 1 ≤ M ≤ 1\,000\,000)$ 두 번째 줄에는 각 버

www.acmicpc.net

소스코드

import sys
import heapq as hq
import math
input = sys.stdin.readline

def dijkstra(start):
  q = []
  min_dis = [float('inf') for _ in range(n+1)]
  min_dis[start] = 0
  hq.heappush(q, (0, start))

  while q:
    cur_dis,cur_node = hq.heappop(q)

    if min_dis[cur_node] < cur_dis:
      continue

    for next_node,next_dis in graph[cur_node]:
      if prime[arr[cur_node]+arr[next_node]]:
        if min_dis[next_node] > cur_dis + next_dis:
          min_dis[next_node] = cur_dis + next_dis
          hq.heappush(q,(next_dis+cur_dis,next_node))
        
  return min_dis[n]

n,m = map(int,input().split())
arr = [0] + list(map(int,input().split()))
graph = [[] for _ in range(n+1)]
prime = [True for _ in range(10**7+1)]
        
for _ in range(m):
  u,v,w = map(int,input().split())
  graph[u].append((v,w))
  graph[v].append((u,w))
  
for i in range(2,int(math.sqrt(10**7+1))+1):
    if prime[i]:
        j = 2
        while i*j <= 10**7:
            prime[i*j] = False
            j += 1
    
k = dijkstra(1)
if k == float('inf'):
  print('Now where are you?')
else:
  print(k)

풀이

★ 문제 자체는 기본적인 다익스트라 + 소수 판별을 해주면 되는 방식이라 그렇게 어렵지 않다고 생각했지만 시간초과가 발생해서 며칠을 고민했던 문제였습니다 ! 소수 판별도 에라토스테네스 체로 해줬고, 최단 경로도 잘 찾은 거 같은데 왜 틀렸을까요 !!

★ 문제는 큐에 집어 넣는 값을 리스트로 줬기 때문이었습니다. 이전까지는 다익스트라 문제든 다른 문제든 리스트를 자주 사용하였습니다. 그리고 별 문제도 없이 통과했었습니다 ! 하지만 구글링을 해보니 튜플이 리트에 비해 더 적은 메모를 사용하고 속도도 빠르다고 합니다.

★ 결과적으론 자신이 맞다고 생각하는데도 계속해서 시간초과가 뜨는 경우, 리스트를 튜플로 바꾼 뒤 제출하는 방법도 한번 생각해보시면 좋을 거 같습니다 :))