Everyday Learning

Container With Most Water

yeoni:) — Wed, 11 Mar 2026 10:24:51 +0900

2026-03-11

오늘의 문제는 neetcode의 Container With Most Water이다

heights의 배열이 주어지면 가장 큰 면적의 물을 담길 수 있는 크기를 리턴하면 된다.

이 문제를 풀 때 고려해야 하는 것은 양쪽 height가 다르다면 작은 수가 기준이 된다.

물을 해당 컨테이너에 넣는다고 가정하면 한쪽만 높아서 되는 게 아니기 때문이다.

브루트포스 방식으로 풀면 간단하지만 시간 복잡도가 O(n^2)이 된다.

투 포인터를 사용하면 시간복잡도가 O(n)이며 효율적이게 값을 구할 수 있다.

class Solution {
    public int maxArea(int[] heights) {
        int l = 0, r = heights.length - 1;
        int max = 0;
        while(l < r){
            int wid = r - l;
            max = Math.max(max, Math.min(heights[l], heights[r]) * wid);
            if(heights[l] < heights[r]){
                l++;
            }else{
                r--;
            }
        }
        return max;
    }
}

투 포인터에서 어떤 포인터를 옮길지에 대한 기준은 어떤 포인터의 값이 작은가이다.

한쪽만 값이 높더라도 다른 값이 작으면 그 만큼 면적이 줄어들게 되어 있다.

먼저 각 포인터들을 가장 끝에 두어 width를 최대로 하고 포인터를 안으로 이동하며

가장 넓은 면적을 구한다.

3Sum

yeoni:) — Tue, 10 Mar 2026 11:29:02 +0900

2026-03-10

오늘 내가 기록할 알고리즘은 NeetCode의 Two Pointer 문제이다.

인덱스의 3가지 수의 합이 0이 되어야 하는 모든 리스트를 리턴해야 하는데, 중복되는 수가 있으면 안된다.

처음 풀이는 brute force 방식으로 문제를 해결해 보았다.

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Set<List<Integer>> list = new HashSet<>();
        Arrays.sort(nums);
        for(int i = 0; i < nums.length; i++){
            for(int j = i + 1; j < nums.length; j++){
                for(int k = j + 1; k < nums.length; k++){
                    if(nums[i] + nums[j] + nums[k] == 0){
                        List<Integer> subList = Arrays.asList(nums[i], nums[j], nums[k]);
                        list.add(subList);
                    }
                }
            }
        }
        return new ArrayList<>(list);
    }
}

리턴 형식이 List임에도 불구하고 Set을 선택한 이유는 중복되는 값을 피하기 위해서다.

제공받은 배열을 정렬함으로 인해서 우리는 중복되지 않는 값만 Set에 저장할 수 있다.

for문을 세 개 생성한 다음 루프를 돌면서 모든 경우의 수를 탐색한다.

이때에 3개 수의 합이 0이라면 해당 값을 리스트로 저장해 Set에 보관한다.

루프가 종료되면 Set Collection을 리스트의 파라미터로 넣어서 리턴한다.

이 방법은 가장 간단하지만, 시간이나 공간적인 면에서 완전 효율적이라고 이야기하지 못한다.

따라서 우리는 Two Pointer를 활용해 해당 문제를 풀어보도록하겠다.

public class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();

        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) break;
            if (i > 0 && nums[i] == nums[i - 1]) continue;

            int l = i + 1, r = nums.length - 1;
            while (l < r) {
                int sum = nums[i] + nums[l] + nums[r];
                if (sum > 0) {
                    r--;
                } else if (sum < 0) {
                    l++;
                } else {
                    res.add(Arrays.asList(nums[i], nums[l], nums[r]));
                    l++;
                    r--;
                    while (l < r && nums[l] == nums[l - 1]) {
                        l++;
                    }
                }
            }
        }
        return res;
    }
}

Brute Force 부분과 비슷한 점이라면 정렬을 우선적으로 해주는 것이다.

정렬을 함으로 인해서 중복된 수가 저장되는 걸 방어할 수 있다.

우선적으로 세 개의 수 중에 하나의 인덱스 값은 고정으로 두고,

나머지 두 개의 값을 투포인터를 이용해 찾는 것이다.

그리고 만약 고정한 인덱스의 값이 0보다 크다면,

즉 양수라면 세 개의 합이 0을 넘을 수 밖에 없다는 뜻이기에 반복문을 종료하고 값을 리턴한다.

투포인터의 인덱스 값은 고정된 인덱스 보다 1 큰 값과 뒤에서 마지막 인덱스를 둔다.

while문에서 만약 세 수의 합이 0보다 크다면 0에 가까운 값으로 만들기 위해 오른쪽 인덱스를 감소시키고

0보다 작다면 왼쪽 인덱스의 값을 증가시킨다.

만약 세 개의 합이 0이라면, 리스트에 저장하고 왼쪽과 오른쪽의 인덱스를 이동시켜준다.

조건문 내에 있는 while 반복문은 중복된 값이 들어가는지 확인하는 로직으로서

만약 왼쪽 현재 인덱스 위치와 이전 왼쪽 인덱스 값과 동일할 경우 왼쪽 인덱스를 증가하도록 하였다.

투 포인터 문제를 풀면서 세 개의 합을 어떻게 투 포인터로 구현하지라는 고민도 되었고,

중복된 값을 걸려내기 위해 왼쪽 인덱스는 증가하면서

오른쪽 인덱스는 반복문을 사용하지 않는 것에 대해 의문을 가지게 되었다.

일단 세 개의 합을 구현할 때에 하나의 인덱스를 고정으로 두게 되면

투 포인터로 구현이 가능하다는 것을 알게 되었고,

왼쪽 인덱스만 증가시켜도 중복된 값이 들어갈 수 없다는 것을 알게 되었다.

따끈따끈한 SAA-C03 자격증 합격 후기

yeoni:) — Mon, 3 Nov 2025 10:58:46 +0900

시험 후기

나는 부산에 위치한 앤아버 어학원 지하 1층 시험장에서 시험을 봤다. 시험 시간은 10시부터였지만 시험보는 사람이 나밖에 없어서 9시 반에 도착하자마자 시험을 봤다. 시험치기 전에는 소지품과 자켓을 락커에 보관하고, 동의서를 작성한 뒤 시험장에 들어가 시험을 쳤다.

시험 문제 절반 정도 가량은 덤프 문제와 동일했고 나머지는 처음보는 문제였다. 문제가 덤프 문제보다 지문 길이가 짧았지만 헷갈리는 문제가 많았던 것 같다. 다 풀고 나니 1시간 정도가 지났고 다시 한번 문제를 살펴보고 제출하니 1시간 반 정도 걸렸다.

여러 사람의 후기를 보니 당일날 시험 결과를 알 수 있대서 메일을 확인해보니 메일이 오지 않았다. 혹시나 하는 마음에 AWS 시험 결과 페이지에 들어가보니 '합격'이라는 시험 결과를 볼 수 있었다!!! 720점 커트라인에 800점, 나쁘지 않은 결과로 합격을 했고 배지를 받을 수 있었다.

준비 기간

AWS는 EC2인스턴스와 S3 정도 사용해본게 다였고 클라우드 지식이 부족하기에 1달 정도 넉넉히 잡고 준비를 했다. 근데 진짜 열심히 공부한 건 일주일 정도 밖에 안되는 것 같다. 일주일 동안 덤프 문제 500개 풀고, 강의를 다봤으니 말이다. 결론은 최대한 짧고 굵게 준비하는게 정신 건강에 좋다.

준비 방법

1. Udemy 강의

나는 유데미 강의와 유료 덤프 문제로 시험을 준비했다. 유데미 강의는 한글 버전도 있어 AWS 기초를 다듬기 좋다. 더군다나, 시험에 나올만한 서비스들을 상세히 설명해줘서 이해하고 문제를 풀 수 있었다. 처음에는 기초를 파악하기 위해 전체 강의를 한번 봤다. 덤프 문제를 풀고 난 이후에는 전체 강의를 2배속으로 다시 봤다. 이렇게 보니 처음에 흘려 들었던 정보도 덤프 문제를 풀면서 봤던 서비스들을 더 깊이 이해할 수 있게 되었다.

2. 유료 덤프 문제

유료 덤프 문제는 아는 동생이 시험을 보고 자신이 구매한 걸 공유해줬다. 1000문제 이상 되는데 시험 5일 전에 풀기 시작해서 500문제 조금 넘게 푼 것 같다. 처음 풀 때에는 정답인 것과 아닌 것의 이유를 찾아가며 공부를 했다. 문제의 번역이 이상하거나 가끔 정답이 아닌 것을 정답이라고 할 때도 있어 ChatGPT를 함께 활용하며 AWS 서비스를 이해하려고 했다. 시험 하루 전날에는 풀었던 문제의 지문과 정답을 다시 한번 확인했다. 전날에 이렇게 하지 않았다면 불합격했을지도 모르겠다. 왜냐하면 덤프문제에서 거의 절반 가까이 출제되었기 때문이다. 가격은 비싸지만, 해당 문제를 풀이하며 도움을 많이 받았기 때문에 준비하는 데 도움이 될 것이라 생각한다.

유데미 강의의 경우는 할인할 때 구매하면 15,000원에 구매가능하다. 사실 유데미는 할인을 자주 하기 때문에 정가를 주고 사면 바보다. 유료 덤프 문제의 같은 경우는 한글 버전이 69.98 달러 정도하는데, 지금 환율로 따지면 10만원 가량 한다. 할인 쿠폰을 적용하면 59.98 달러에 구매가능하다!

Udemy 강의: https://www.udemy.com/course/aws-certified-solutions-architect-associate-saa-c03/

유료 덤프 문제: https://www.dumptop.com/

국제 인증시험 최신버전 덤프를 제공해드리는 웹사이트 - DumpTOP

보물섬 문제들이 모두 덤프에서 출제되어 CFE-Investigation시험 가볍게 합격했습니다. 저는 문제만 달달 외우는것보다 문제푸는 방법을 알려고 많이 공들였어요. 자격증취득을 위한 덤프공부라지

www.dumptop.com

동기 처리와 비동기 처리의 차이, 그리고 서버 효율에 대한 이야기

yeoni:) — Sat, 5 Jul 2025 12:01:20 +0900

백엔드 개발을 하다 보면 동기 처리와 비동기 처리에 대한 이야기를 자주 접하게 된다. 개발을 처음 시작했을 때에는 코드를 작성하는 것에만 집중했지만 서비스를 운영하고 관리를 하다보니 API 처리 방식과 서버 리소스 사용의 효율성에 대해 고민이 든다. 이번 글에서는 동기 처리와 비동기 처리의 차이, 쓰레드 풀과 Executor의 역할, 그리고 비동기 처리의 메모리 사용 이슈까지 정리해본다. 또한 프론트엔드와 백엔드의 처리 방식이 서로 다를 때 발생하는 상황도 함께 살펴본다.

동기 처리란?

동기 처리란 요청을 보내고 응답이 올 때까지 작업 흐름이 멈추는 방식이다. 클라이언트가 서버에 API 요청을 보내면, 서버는 해당 요청을 처리하는 동안 쓰레드를 점유하고, 처리 완료 후에야 응답을 반환한다. 이 방식에서는 요청 처리 중 다른 작업을 할 수 없다.

서버 내부 흐름

1. 클라이언트가 HTTP 요청 전송

2. Tomcat(서블릿 컨테이너)가 요청 수신

3. 워커 스레드(Worker Thread)가 Thread Pool에서 할당

4. 비즈니스 로직(DB 조회, 외부 API 호출 등) 실행

5. 작업 완료 후 응답 반환

6. 워커 스레드가 Thread Pool로 반환

동기 처리의 한계

요청 하나당 서버 워커 스레드 하나를 점유하기 때문에 워커스레드가 모두 점유되면 추가 요청은 큐에 대기하거나 거절된다. 만약 IO 작업이나 외부 API를 불러오는 로직이 있다면 대기 시간이 길어지면서 처리량이 급감할 수 있다.

예제 코드

@RestController
public class SyncController {

    @GetMapping("/sync")
    public String syncApi() {
        heavyDatabaseQuery();
        return "Done";
    }

    private void heavyDatabaseQuery() {
        try {
            Thread.sleep(3000); // DB 작업 대기 시뮬레이션
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

비동기 처리란?

비동기 처리란 요청을 보내고 결과를 기다리는 동안 다른 작업을 수행할 수 있는 방식이다. 서버는 요청을 처리할 때 외부 작업(DB 조회, 파일 IO 등)을 별도의 스레드나 이벤트 루프에 위임하고, 메인 쓰레드는 즉시 반환된다. 클라이언트와 서버 모두 비동기 처리 방식을 적용할 수 있다.

서버 내부 흐름

1. 클라이언트가 HTTP 요청 전송

2. Tomcat이 요청 수신

3. 워커 스레드가 Thread Pool에서 할당

4. 비즈니스 로직을 Executor에게 위임

5. 워커 스레드는 즉시 반환

6. Executor 스레드가 비동기 처리 수행

7. 처리 완료 후 결과를 클라이언트에 비동기 응답

비동기 처리의 장점

워커 스레드가 Executor에게 위임 후 즉시 반환되기 때문에 더 많은 요청을 처리할 수 있다. 따라서 IO-bound 작업 지연이 생기더라도 서버 처리량에는 영향이 덜 미친다.

주의사항

비동기 처리를 위한 로직을 짤 때 예외처리가 복잡해진다. 또한 Executor Thread Pool이 과도하게 커지면 메모리 사용량이 증가하게 되고 컨텍스트 스위칭 비용이 발생하게 된다.

예제 코드

@RestController
public class AsyncController {

    @GetMapping("/async")
    public Mono<String> asyncApi() {
        return Mono.fromCallable(this::heavyDatabaseQuery)
                   .subscribeOn(Schedulers.boundedElastic());
    }

    private String heavyDatabaseQuery() {
        try {
            Thread.sleep(3000); // DB 작업 대기 시뮬레이션
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Done";
    }
}

쓰레드 풀과 Executor의 역할

쓰레드 풀이란?

쓰레드 풀은 서버(Tomcat)가 요청을 처리하기 위해 미리 생성해놓은 워커 스레드들의 집합이다. 요청이 들어오면 이 풀에서 하나의 워커 스레드를 할당하고, 요청 처리가 끝나면 반환한다.

항목	내용
관리 주체	Tomcat(또는 Jetty 등 서블릿 컨테이너)
기본 크기	200개
처리 방식	요청 하나당 스레드 하나 점유
반환 시점	요청 처리 완료 시

Executor란?

Executor는 자바에서 비동기 작업을 실행하고 관리하는 API이다. Spring에서는 @Async, WebClient 내부에서 Executor를 사용한다. 워크 스레드가 처리 중인 작업을 Executor Thread Pool에 위임하면 워커 스레드는 바로 반환된다.

항목	내용
관리 주체	Spring(ExecutorService, ThreadPoolTaskExecutor)
기본 크기	8개(Spring Boot 기본), 설정 가능
처리 방식	요청 로직을 비동기 스레드로 위임
반환 시점	위임 직후

비동기 처리에서 Executor를 사용하면 메모리를 더 사용하는 것이 아닐까?

비동기 처리 시 Executor Thread Pool이 추가로 동작하고, 비동기 작업을 담는 Future, Task 객체들이 힙 메모리에 유지된다. 이로 인해 메모리 사용량은 동기 처리보다 증가할 수 있다. 하지만 비동기 처리는 요청당 워커 스레드가 블로킹되지 않기 때문에 서버가 동시에 처리할 수 있는 요청의 양이 크게 늘어난다. 결과적으로 같은 시간 동안 더 많은 요청을 처리할 수 있고, 메모리 사용량 증가 대비 처리량 향상 폭이 더 크기 때문에 효율적이라고 말한다.

동기식 API의 블로킹 범위

동기식 API는 요청 하나가 처리될 때까지 해당 요청을 맡은 서버 워커 스레드를 반환하지 않는다. 이 블로킹은 한 사용자의 요청 범위에서 발생한다. 하지만 여러 사용자가 동시에 같은 API를 호출하면 각각의 요청이 별도의 워커 스레드에 할당되어 처리된다. 워커 스레드 수가 충분하다면 다른 사용자 요청에는 영향을 주지 않는다. 그러나 워커 스레드가 한계에 도달하면 새로운 요청은 대기하거나 실패하게 된다.

프론트 코드가 비동기 처리이고 백엔드 API가 동기 처리라면 데이터 처리는 빨라지는 것일까?

프론트엔드에서 API를 비동기 호출한다고 해서 백엔드의 처리 속도가 빨라지는 것은 아니다. 프론트 비동기 처리의 목적은 사용자 경험 개선이다. API 호출이 완료될 때까지 UI가 멈추지 않도록 하고, 다른 동작을 이어갈 수 있게 한다. 하지만 백엔드가 동기 처리 방식이라면 서버는 요청당 하나의 워커 스레드를 계속 점유하며 처리한다. 결국 백엔드 처리 시간이 느리면 전체 응답 시간은 그대로이다.

프론트 코드가 비동기 처리를 하는 이유

프론트엔드는 사용자의 UI 경험이 중요하기 때문에 비동기 처리가 기본이다. 비동기 호출을 통해 화면이 멈추지 않고 로딩 상태를 보여주거나 다른 인터랙션을 할 수 있다. 서버가 동기이든 비동기이든 프론트 비동기 처리는 사용자 인터페이스를 부드럽게 만드는 핵심 요소이다.

Docker를 사용할 때 Volume이란? 실무 경험으로 이해하기

yeoni:) — Tue, 24 Jun 2025 17:33:19 +0900

1. Docker란?

Docker는 애플리케이션을 컨테이너(container)라는 가벼운 단위로 패키징하고 실행할 수 있게 해주는 플랫폼이다.
이 컨테이너는 애플리케이션 + 환경(라이브러리, 설정 등)을 하나로 묶어 배포하므로, "내 PC에선 잘 되는데?" 같은 환경 문제를 크게 줄여준다는 특징이 있다. 이러한 장점 때문에 윈도우, 리눅스 등 어떤 OS를 사용하든지 상관없이 배포할 수 있다.

- 개발 → 배포 → 운영이 일관된 환경에서 이뤄짐

- Dockerfile, docker-compose.yml 등을 이용해 손쉽게 빌드/실행 가능

2. 그렇다면 Docker Volume은 무엇일까?

Docker 컨테이너는 기본적으로 임시적인 파일 시스템을 사용한다. 즉, 컨테이너를 삭제하거나 재시작하면 내부에 있던 데이터는 모두 사라지게 되버린다. 수정사항이 발생하면 컨테이너를 내렸다 올려야 하는 상황이 빈번한데, 자칫 잘못하다가는 큰 사고로 이어질 수 있다.

이때 Docker Volume을 사용하면 컨테이너와는 별도로 데이터를 지속적으로 저장할 수 있다.

사용 예시:

services:
  app:
    image: my-app
    volumes:
      - /host/data:/app/data	// 내부 저장소:도커 저장소

위처럼 볼륨을 설정하면, 컨테이너가 꺼져도 /host/data에 있는 파일은 유지된다.
즉, 컨테이너가 데이터를 저장하는 위치를 호스트의 폴더나 Docker Volume 저장소로 연결하는 것이다.

3. 실무에서 겪은 사례: 왜 볼륨이 중요했는가?

사내 시스템에는 파일 업로드와 다운로드 기능이 존재하는데, 볼륨을 설정하지 않고 서비스를 올렸다. 아직 시스템이 안정화되지 않은 상황에 볼륨을 설정하지 않고 올리게 되니 docker compose down -> up를 반복하는 상황에서 컨테이너 내부에 저장된 파일들이 전부 사라지는 문제가 발생하였다. 물론 DB에는 파일 경로가 저장되어 있었지만, 정작 파일 자체는 존재하지 않게 되어 파일을 읽어 오지 못했다.

사내 시스템이라 다행이었지, 이게 외부로 서비스되는 거였지만 큰 사고로 이어질 뻔했다.
이 경험을 통해, 데이터가 컨테이너 수명과 함께 날아가면 안 되는 경우에는 반드시 volume을 사용해야 한다는 점을 절실히 느꼈다.

volumes:
  - /var/groupware/data/upload:/var/groupware/upload
  - /var/groupware/data/logs:/var/groupware/logs
  - /var/groupware/data/doc:/var/groupware/doc
  - /var/groupware/data/font:/var/groupware/font

4. 깨달음: 볼륨은 선택이 아닌 필수다!

초기엔 Docker의 간편함에 집중했지만, 실제 운영환경에 가까워질수록 데이터의 지속성(persistence)이 매우 중요하다.
볼륨은 단순한 보조 수단이 아니라, 컨테이너 기반 시스템에서 데이터를 보호하기 위한 핵심 전략인 것 같다.

관련 명령어 간단 정리:

# 기존 볼륨 확인
docker volume ls

# 볼륨 생성
docker volume create my-volume

# 볼륨을 수동으로 컨테이너에 마운트
docker run -v my-volume:/data my-image

# docker-compose에서도 사용 가능
volumes:
  - my-volume:/data

5. 마무리하며

Docker를 처음 사용할 땐 시스템 구축에만 집중하게 되지만, 결국엔 지속 가능한 운영이 핵심이 된다.
볼륨은 그 지속성의 시작점이다. 나와 같이 실수로 소중한 데이터를 날리기 전에, 꼭 볼륨을 설정해두시길 바란다.

Grafana + Loki + Promtail을 활용한 로그 수집 및 시각화 시스템 구축하기(1)

yeoni:) — Wed, 4 Jun 2025 10:08:23 +0900

개요

실제 운영 중인 Spring 애플리케이션에서 발생하는 로그를 수집하고, 시각화하여 모니터링할 수 있는 시스템을 구축했다. 이 시스템은 Grafana, Loki, Promtail 세 가지 도구를 활용하였고, GCP의 Ubuntu 서버 2대에 구성되었다.

아키텍처 구조

서버 A (Spring 앱 실행 중)
- Spring 애플리케이션이 Docker 컨테이너에서 실행 중
- Promtail을 통해 컨테이너 로그 수집
- 수집된 로그는 서버 B의 Loki로 전송
서버 B (로그 저장 및 시각화)
- Loki: 로그 저장소 역할
- Grafana: 로그 시각화 대시보드
- Database: 별도 용도로 사용

네트워크 구성

3100 포트: Promtail이 Loki에 로그를 전송할 수 있도록 오픈
3000 포트: Grafana UI 접속용 포트

도구 설명

Promtail

로그 수집기 역할
로컬 로그 파일이나 도커 컨테이너 로그를 읽고, Loki에 전송
경량이므로 서버 부하가 거의 없음

Loki

로그를 저장하는 시스템
시계열 데이터베이스처럼 동작하나 인덱싱 방식이 경량화되어 있음

Grafana

Loki에 저장된 로그를 쿼리하여 시각화
다양한 필터링 및 탐색 기능을 제공

서버 B 설정 (Loki & Grafana)

1. Docker Compose 설정

# docker-compose.yml
version: "3"

services:
  loki:
    image: grafana/loki:2.9.2
    container_name: loki
    ports:
      - "3100:3100"
    volumes:
      - ./loki-config.yaml:/etc/loki/local-config.yaml
      - loki-data:/tmp/loki

  grafana:
    image: grafana/grafana
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana-storage:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_USER=user
      - GF_SECURITY_ADMIN_PASSWORD=password
    restart: always

volumes:
  grafana-storage:
  loki-data:

2. Loki 설정 파일

# loki-config.yaml
auth_enabled: false

server:
  http_listen_port: 3100
  grpc_listen_port: 9095

ingester:
  lifecycler:
    ring:
      kvstore:
        store: inmemory
      replication_factor: 1
  chunk_idle_period: 5m
  max_chunk_age: 1h
  wal:
    enabled: true
    dir: /tmp/loki/wal

schema_config:
  configs:
    - from: 2022-01-01
      store: boltdb-shipper
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 24h

storage_config:
  boltdb_shipper:
    active_index_directory: /tmp/loki/index
    cache_location: /tmp/loki/boltdb-cache
    shared_store: filesystem
  filesystem:
    directory: /tmp/loki/chunks

limits_config:
  reject_old_samples: true
  reject_old_samples_max_age: 168h

table_manager:
  retention_deletes_enabled: true
  retention_period: 168h

3. 실행 명령어

docker compose up -d

서버 A 설정 (Promtail)

Promtail 설정 파일

# promtail-config.yaml
server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://<서버B의IP>:3100/loki/api/v1/push

scrape_configs:
  - job_name: spring-app
    static_configs:
      - targets:
          - localhost
        labels:
          host: server-a
          job: spring
          __path__: /var/lib/docker/containers/*/*.log

Promtail 실행 명령어

docker run -d \
  --name=promtail \
  -v /var/lib/docker/containers:/var/lib/docker/containers:ro \
  -v /var/log:/var/log \
  -v "$(pwd)/promtail-config.yaml":/etc/promtail/config.yaml \
  grafana/promtail:2.9.2 \
  -config.file=/etc/promtail/config.yaml

Grafana 설정 및 시각화

1. Grafana 접속

브라우저에서 http://<서버B-IP>:3000으로 접속 후 로그인
기본 계정: user / password

2. 데이터 소스 추가

왼쪽 사이드바 > Settings > Data Sources > Add data source
Loki 선택
URL: http://loki:3100
Save & Test

3. 로그 탐색

왼쪽 메뉴 > Explore
쿼리 예시:
```
{job="spring", host="server-a"}
```
로그가 실시간으로 출력되는 것을 확인 가능

장점

운영 및 모니터링 측면

운영 중인 서버에서 발생하는 로그를 별도의 서버로 전송해 부하 분산
실시간으로 로그를 탐색하고, 오류 상황을 빠르게 인지 가능
다중 서버나 마이크로서비스 환경에서 로그 통합이 용이

관리 효율

특정 시간대, 호스트, job 단위로 필터링이 가능하여 분석 편의성 향상
개발 및 운영자 간 협업 시 동일한 로그를 기반으로 문제 해결 가능
필요 시 알람 설정도 가능 (Grafana Alert 설정 활용)

결론

Grafana, Loki, Promtail을 조합하면 로그 수집과 시각화를 매우 효율적으로 구성할 수 있다. 특히 도커 환경에서의 로그 수집에 최적화되어 있으며, GCP 또는 클라우드 서버에서도 비교적 쉽게 배포가 가능하다.

소비채집 프로젝트를 처음 배포했을 당시에는 실사용자가 적어 로그 수집과 분석에 대한 필요성을 크게 느끼지 못했다. 그러나 최근 400명 규모의 청소년들이 사용하는 서비스 운영을 앞두고, 장애 발생 시 빠르게 대응할 수 있는 체계가 필요하다고 느꼈다. 매번 서버에 접속해 도커 로그를 직접 확인하는 방식은 번거롭고, 로그를 한눈에 파악하기 어렵다는 한계도 있었다. 안정적인 운영을 위해 이제는 로그 수집 및 시각화 환경을 제대로 구축하고, 프로젝트의 로그 구조도 정비할 필요가 있다.

99클럽 코테 스터디 6기 16일차 TIL (미들러)

yeoni:) — Tue, 22 Apr 2025 21:19:53 +0900

문제: 백준 18126번 너구리 구구

풀이 방법

전형적인 그래프 문제로 DFS 혹은 BFS로 값을 구할 수 있다. 여기서 주의해야 할 점이 있다면, 가중치 값이 int 범위를 초과할 수 있기 때문에 반환 값의 형식을 long으로 설정해야 한다.

전체 코드

public class Main {
    static ArrayList<int[]>[] graph;
    static boolean[] visited;
    static long maxDistance = 0;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        graph = new ArrayList[n + 1];
        visited = new boolean[n + 1];

        for (int i = 1; i <= n; i++) {
            graph[i] = new ArrayList<>();
        }

        for (int i = 0; i < n - 1; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            int w = Integer.parseInt(st.nextToken());

            graph[u].add(new int[] {v, w});
            graph[v].add(new int[] {u, w});
        }

        dfs(1, 0);
        System.out.println(maxDistance);
    }

    static void dfs(int node, long distance) {
        visited[node] = true;
        maxDistance = Math.max(maxDistance, distance);

        for (int[] next : graph[node]) {
            int nextNode = next[0];
            int weight = next[1];

            if (!visited[nextNode]) {
                dfs(nextNode, distance + weight);
            }
        }
    }
}

graph

리스트를 생성한 뒤 초기화를 시켜주고 연결된 정점 번호와 가중치를 저장하기 위해 배열로 리스트에 저장한다.

dfs()

visited[] 배열은 방문 여부를 저장하기 위함이다.

이 메서드는 현재 노드까지의 누적 거리를 전달하고 가장 긴거리를 maxDistance에 저장한다.

99클럽 코테 스터디 6기 16일차 TIL (미들러)

yeoni:) — Mon, 21 Apr 2025 21:14:17 +0900

문제: 프로그래머스 신규 아이디 추천

풀이 방법

위와 같이 규칙에 맞는 아이디를 추천해주는 프로그램을 개발하는 것인데, 특별한 알고리즘이 필요하진 않고 요구한 것을 차례대로 구현하면 된다. 사실 정규표현식만 제대로 숙지하고 있으면 어려운 문제가 아니다. 하지만 난 정규 표현식에 익숙하지 않아서 그런지 클린하지 못한 코드를 작성하고 시간도 오래 걸렸다.

첫 번째 시도

import java.util.Stack;

class Solution {
    public String solution(String new_id) {
        char[] charId = new_id.toCharArray();

        Stack<Character> stack = new Stack<>();
        Character first = charId[0];
        if (Character.isUpperCase(first)) {
            first = Character.toLowerCase(first);
        }
        if (Character.isDigit(first) || Character.isLowerCase(first) || first == '-' || first == '_' || first == '.') {
            stack.add(first);
        }
        for (int i = 1; i < charId.length; i++) {
            Character c = charId[i];
            if (Character.isUpperCase(c)) {
                c = Character.toLowerCase(c);
            }
            if (!Character.isDigit(c) && c != '-' && c != '_' && c != '.' && !Character.isLowerCase(c)) {
                continue;
            }

            if (!stack.isEmpty() && stack.peek() == '.' && c == '.') {
                continue;
            }

            stack.add(c);
        }

        while (!stack.isEmpty()) {
            if (stack.peek() != '.' && stack.get(0) != '.')
                break;
            if (!stack.isEmpty() && stack.peek() == '.') {
                stack.pop();
            }
            if (!stack.isEmpty() && stack.get(0) == '.') {
                stack.remove(0);
            }
        }

        if (stack.isEmpty()) {
            stack.add('a');
        }

        if (stack.size() >= 16) {
            while (stack.size() >= 16 || stack.peek() == '.') {
                stack.pop();
            }
        }

        if (stack.size() <= 2) {
            while (stack.size() < 3) {
                stack.add(stack.peek());
            }
        }

        StringBuilder sb = new StringBuilder();
        for (Character c : stack) {
            sb.append(c);
        }
        
        return sb.toString();
    }
}

스택을 사용하여 모든 수를 저장하고 StringBuilder로 출력하도록 하였다.

코드도 길어지고 조건도 많아져서 코드가 많이 지저분해진 것 같다.

정규표현식 코드

public class Main {
    public static void main(String[] args) {
        // String id = "...!@BaT#*..y.abcdefghijklm";
        // String id = "z-+.^.";
        // String id = "=.=";
        String id = "123_.def";

        id = id.toLowerCase();
        id = id.replaceAll("[^a-z0-9._-]", "");
        id = id.replaceAll("[.]{2,}", ".");
        id = id.replaceAll("^[.][.]$", "");
        id = id.isEmpty() ? "a" : id;
        if (id.length() >= 16)
            id = id.substring(0, 15);
        id = id.replaceAll("[.]$", "");
        StringBuilder sb = new StringBuilder(id);
        while (sb.length() <= 2) {
            sb.append(sb.charAt(sb.length() - 1));
        }
        id = sb.toString();
        System.out.println(id);

    }
}

toLowerCase(): 모든 문자를 소문자로 변환시켜주는 메서드

"[^a-z0-9._-]": 대문자 안에서 '^'는 부정을 뜻한다, 즉 소문자나 숫자, '.', '_', '-' 가 아니라면 빈값으로 치환한다.

"^[.][.]$": 대문자 밖의 '^'는 첫 번째 문자를 뜻하며 대문자 뒤의 '$'는 마지막 문자를 뜻한다.

정규 표현식을 이용하니 확실히 코드가 간결해지고 쉽게 문제를 풀 수 있는 것 같다.

99클럽 코테 스터디 6기 15일차 TIL (미들러)

yeoni:) — Fri, 18 Apr 2025 11:39:20 +0900

문제: 백준 17271번 리그 오브 레전설(Small)

풀이 방법

A와 B의 스킬로 N시간 안에 가능한 스킬 조합을 찾는 문제다.스킬을 사용하지 않는 시간이 없어야 한다는 조건이 있기에 중간에 빈 시간이 없도록 만들어야 한다. 이 문제는 하위 문제의 중복으로 다이나믹 프로그래밍 알고리즘을 사용하여 풀 수 있다.

전체 코드

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] input = br.readLine().split(" ");
        int n = Integer.parseInt(input[0]);
        int m = Integer.parseInt(input[1]);

        final int MOD = 1_000_000_007;
        int[] dp = new int[n + 1];
        dp[0] = 1;

        for (int i = 1; i <= n; i++) {
            dp[i] = dp[i - 1];
            if (i >= m) {
                dp[i] = (dp[i] + dp[i - m]) % MOD;
            }
        }

        System.out.println(dp[n]);
    }
}

dp[i]는 길이가 i인 문자열을 만들 수 있는 경우의 수이다. 문자열의 길이를 1부터 N가지 증가시키면서, 경우의 수를 계산한다.

점화식

dp[i] += dp[i - 1]: 길이가 i - 1인 문자열에 문자 A를 추가하여 길이 i를 만드는 경우

dp[i] += dp[i - M]: 길이가 i - M인 문자열에 문자 B를 추가하여 길이 i를 만드는 경우 (단, i >= M일 때만 가능)

마지막에는 오버플로우 방지를 위해 1,000,000,007로 나눈다.

99클럽 코테 스터디 6기 14일차 TIL (미들러)

yeoni:) — Thu, 17 Apr 2025 16:42:52 +0900

문제: 백준 17484번 진우의 달 여행(Small)

풀이 방법

달의 도달하기 위해 필요한 최소 연료 값을 구하는 것인데, 이 문제에서의 조건은 같은 방향으로 연달아 움질일 수 없다는 점이다. 해당 조건 때문에 이 문제를 풀기까지 굉장히 오랜시간이 걸린 것 같다.

문제를 읽어보니 다이나믹 프로그래밍으로 풀어야 한다고 생각을 했는데, 방향이라는 조건이 있다보니 3차원 배열을 사용해야 했다. 스스로 풀기에 한계를 느껴 인공지능에게 도움을 받았다.

전체 코드

public class Main {
    public static void main(String[] args) throws IOException {
        // 입력 및 저장
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

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

        int[][][] dp = new int[n][m][3]; // 3차원 DP 배열
        final int MAX = 1000 * 100 + 1;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                Arrays.fill(dp[i][j], MAX);

        // 첫 번째 행 초기화
        for (int j = 0; j < m; j++) {
            dp[0][j][0] = dp[0][j][1] = dp[0][j][2] = space[0][j];
        }

        // DP
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < m; j++) {
                for (int d = 0; d < 3; d++) {
                    int prevJ = j + (d - 1);
                    if (prevJ < 0 || prevJ >= m)
                        continue;

                    for (int prevD = 0; prevD < 3; prevD++) {
                        if (d == prevD)
                            continue;
                        dp[i][j][d] = Math.min(dp[i][j][d], dp[i - 1][prevJ][prevD] + space[i][j]);
                    }
                }
            }
        }
        int answer = MAX;
        for (int j = 0; j < m; j++) {
            for (int d = 0; d < 3; d++) {
                answer = Math.min(answer, dp[n - 1][j][d]);
            }
        }
        System.out.println(answer);
    }
}

첫번째 행은 이전 행이 따로 없기 때문에 배열의 d 값을 초기화 시켜주는 작업이 필요하다.

prevJ

d 값에 따라 이전 열을 계산하는 변수이다. 만약 prevJ가 0보다 작거나, m보다 크거나 같다면 배열을 벗어났기에 continue를 해준다.

prevD

이전 방향과 동일한 방향으로 이동할 수 없기 때문에 d == prevD와 동일한다면 continue하고 그렇지 않은 경우 최소 값을 구해준다.

answer

최소값을 구해야 하기 때문에 반복문을 통해 마지막 행에서 최소값을 찾아준다.

메모이제이션을 항상 2차원 배열로 시행하다가 3차원 배열로 구현하려니 너무 어렵게 느껴졌다. 3차원 배열로 다이나믹 알고리즘을 구현하는 문제를 더 많이 접해봐야 할 것 같다는 생각이 들었다.

99클럽 코테 스터디 6기 13일차 TIL (미들러)

yeoni:) — Wed, 16 Apr 2025 10:56:09 +0900

문제: 프로그래머스 JadenCase 문자열 만들기

풀이 방법

이 문제에서 요구하는 건 첫글자는 대문자로, 나머지 글자는 소문자로 바꾸는 문제이다. 별다른 알고리즘이 필요하지 않고 구현만 하면 된다.

첫시도(실패)

class Solution {
    public String solution(String s) {
        String[] arr = s.split(" ");
        String answer = "";
        for (int i = 0; i < arr.length; i++) {
            char first = arr[i].charAt(0);
            if (Character.isAlphabetic(first)) {
                answer += Character.toUpperCase(first);
            } else {
                answer += first;
            }
            for (int j = 1; j < arr[i].length(); j++) {
                char c = arr[i].charAt(j);
                answer += Character.toLowerCase(c);
            }
            if (i != arr.length - 1)
                answer += " ";
        }
    return answer;
    }
}

이 코드에서 오류가 날 수 밖에 없었던 이유는 시간 초과도 있었고 첫 글자를 제외한 나머지 글자가 숫자일 때 LowerCase() 변경하는 과정에서 생길 수 밖에 없었다.

최종 코드

class Solution {
    public String solution(String s) {
        int idx = 0;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == ' ')
                idx = -1;

            if (Character.isDigit(c)) {
                sb.append(c);
                idx++;
                continue;
            }

            if (idx == 0) {
                sb.append(Character.toUpperCase(c));
            } else {
                sb.append(Character.toLowerCase(c));
            }

            idx++;
        }
    return sb.toString();
    }
}

String에 값을 담아 리턴하는 것보다 StringBuilder를 사용하는 것이 성능면에서 낫기 때문에 StringBuilder를 사용하였고 인덱스를 사용하여 글자의 위치를 파악하였다. 만약 현재 char 값이 숫자라면 변환없이 바로 리턴 값에 저장하고 idx == 0 이라면 첫 글자라는 뜻이기에 대문자로 변경한다. 그외의 경우는 소문자로 변경해주었다.

99클럽 코테 스터디 6기 12일차 TIL (미들러)

yeoni:) — Tue, 15 Apr 2025 11:52:04 +0900

문제: 백준 2156번 포도주 마시기

풀이 방법

일단 이 문제는 정렬이 안되기에 탐색은 어려울 것 같다는 생각이 들었고, 중복적으로 계산을 시도해야 하기 때문에 다이나믹 프로그래밍으로 풀어야 한다고 생각이 들었다.

첫시도(실패)

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        int[] wine = new int[n];
        for (int i = 0; i < n; i++) {
            wine[i] = Integer.parseInt(br.readLine());
        }

        int[] dp = new int[n];
        if (n >= 3) {
            dp[0] = wine[0];
            dp[1] = dp[0] + wine[1];
            dp[2] = wine[2] + Math.max(wine[0], wine[1]);
            for (int i = 3; i < n; i++) {
                dp[i] = wine[i] + Math.max(dp[i - 2], wine[i - 1] + dp[i - 3]);
            }
        } else if (n == 1) {
            System.out.println(wine[0]);
            return;
        } else if (n == 2) {
            System.out.println(wine[0] + wine[1]);
            return;
        }

        int max = 0;
        for (int val : dp) {
            max = Math.max(val, max);
        }

        System.out.println(max);
    }
}

문제에서 3잔을 연달아 마실 수 없다는 조건이 있다. 이에 따라 점화식을 아래와 같이 세웠다.

dp[i] = wine[i] + Math.max(dp[i - 2], wine[i - 1] + dp[i - 3]);

dp[i - 2] + wine[i] (현재 잔을 마시고, 이전 잔을 건너뛰는 경우)
dp[i - 3] + wine[i - 1] + wine[i] (현재 잔과 이전 잔을 마시고, 두 잔 전을 건너뛰는 경우)

하지만 코드를 제출해보니, 틀렸다는 메세지가 나왔다. 그 이유는 점화식에서 현재 포도주를 제외한 조건이 빠졌기 때문이었다. 올바른 점화식은 아래와 같다.

dp[i] = Math.max(dp[i - 1], Math.max(dp[i - 2] + wine[i], dp[i - 3] + wine[i - 1] + wine[i]));

dp[i - 1] (이전까지의 최대값, 현재 잔을 마시지 않는 경우)
dp[i - 2] + wine[i] (현재 잔을 마시고, 이전 잔을 건너뛰는 경우)
dp[i - 3] + wine[i - 1] + wine[i] (현재 잔과 이전 잔을 마시고, 두 잔 전을 건너뛰는 경우)

최종 코드

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        int[] wine = new int[n];
        for (int i = 0; i < n; i++) {
            wine[i] = Integer.parseInt(br.readLine());
        }

        if (n == 1) {
            System.out.println(wine[0]);
            return;
        }

        int[] dp = new int[n];
        dp[0] = wine[0];
        dp[1] = wine[0] + wine[1];
        if (n > 2) {
            dp[2] = Math.max(dp[1], Math.max(wine[0] + wine[2], wine[1] + wine[2]));
        }

        for (int i = 3; i < n; i++) {
            dp[i] = Math.max(dp[i - 1], Math.max(dp[i - 2] + wine[i], dp[i - 3] + wine[i - 1] + wine[i]));
        }

        System.out.println(dp[n - 1]);
    }
}

점화식을 이렇게 수정하고 나니, 통과할 수 있었다.

이전보다는 어떤 문제가 다이나믹 프로그래밍에 적합한지 알 것 같다. 하지만 아직까지 점화식을 세우는 데는 어려움이 있다. 다양한 문제를 경험해보고, 감을 잡아야 할 것 같다.

99클럽 코테 스터디 6기 11일차 TIL (미들러)

yeoni:) — Mon, 14 Apr 2025 11:20:25 +0900

문제: 백준 16401번 과자 나눠주기

풀이방법

M명의 조카가 있고 N개의 과자가 있다. 동일한 크기의 과자를 나눠준다고 할 때 최대 과자의 길이를 출력해야 한다. 여기서 과자의 길이는 양수이고 같은 길이로 막대과자를 나눠줄 수 없다면 0을 출력해야 한다. 또한 입력 값은 int 범위 내에 들어오는 값으로 입력되는 값 모두 int로 설정해주면 된다.

이 문제는 나눠줄 수 있는 막대과자의 최대 길이를 구하는 것으로 이분탐색을 통해 값을 구할 수 있다.

최종 코드

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

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

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

        Arrays.sort(snacks);

        int start = 1;
        int end = snacks[n - 1];

        while (start <= end) {
            int mid = (start + end) / 2;

            int cnt = 0;
            for (int i = 0; i < n; i++) {
                if (snacks[i] >= mid) {
                    cnt += snacks[i] / mid;
                }
            }

            if (cnt >= m) {
                start = mid + 1;
            } else {
                end = mid - 1;
            }

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

처음 이분 탐색으로 풀려고 하니, 탐색 대상을 어떻게 설정해야 하나 고민이 되었다. 다른 이분 탐색 문제를 풀었을 때 인덱스를 이용하여 탐색했기에 여기서도 인덱스를 가지고 탐색을 하려고 했다. 하지만 답이 나오지 않았다.

이분탐색에서 우리가 얻고자하는 것은 과자의 최대 길이이다. 특정 과자나 인덱스를 찾는 것이 아니기 때문에 과자의 길이로 탐색해야 한다는 것을 알게 되었다.

1. 입력: 값 입력 받기

2. 정렬: 값을 입력 받고 입력받은 막대 과자의 길이를 오름차순으로 정렬

3. 범위 지정하기: 시작 값은 막대의 최소 길이인 1, 최대 값은 입력 값에서 최대 막대 과자 길이

4. 반복문

- 반복문을 돌면서 중간값(mid)을 m명에게 나눠줄 수 있는지 탐색, cnt 변수로 몇 명에게 나눌 수 있는지 저장

- 조건을 만족하는 경우(cnt >= m), 더 큰 길이를 탐색하기 위해 start = mid + 1로 이동

- 만족하지 않는 경우, 더 작은 길이를 탐색하기 위해 end = mid + 1로 이동

5. 출력: end 값 출력

99클럽 코테 스터디 6기 10일차 TIL (미들러)

yeoni:) — Fri, 11 Apr 2025 22:49:31 +0900

문제: 백준 1783번 병든 나이트

풀이 방법

이 문제는 단순한 규칙 찾기 문제이다. 예제가 많은 것을 보고 눈치를 챘어야 하는데,,, 몰랐다. 그래서 이 문제를 어떤 알고리즘으로 풀어야 하나 고민이 되었던 것 같다.

이 문제에서 나이트는 4가지 방법으로만 움직일 수 있고 이동 횟수가 5회 이상이라면 모든 이동방법을 다 사용해야 한다는 조건이 있다. 그리고 나이트는 위, 아래 그리고 오른쪽으로 밖에 이동하지 못한다. 즉, n이 작다면 갈 수 있는 칸은 한정적인 것이다

전체코드

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] input = br.readLine().split(" ");
        long n = Long.parseLong(input[0]);
        long m = Long.parseLong(input[1]);

        long result = 0;

        if (n == 1) {
            result = 1;
        } else if (n == 2) {
            result = Math.min(4, (m + 1) / 2);
        } else {
            if (m < 7) {
                result = Math.min(4, m);
            } else {
                result = m - 2;
            }
        }
        System.out.println(result);
    }
}

n == 1 이라면 갈 수 있는 칸은 위치하고 있는 자리 뿐이기에 result 값을 1로 설정한다. n == 2라면 최대로 갈 수 있는 칸은 4개이지만 m의 수에 따라 달라진다. m이 2이하라면 조건에 따라 움직이지 못하기 때문이다. n == 3 이상이라면, 그리고 m이 6이상이라면 4가지 조건을 모두 사용할 수 있기에 조건문을 두어 result 값을 다르게 출력한다.

규칙만 찾으면 쉬운 문제인데 규칙을 못 찾으면 그 어느 문제보다 어려운 것 같다ㅠ

99클럽 코테 스터디 6기 9일차 TIL (미들러)

yeoni:) — Thu, 10 Apr 2025 11:30:55 +0900

문제: 백준 2437번 저울

풀이 방법

주어진 저울추를 가지고 측정할 수 없는 최소값(양수)를 찾아야 하는 문제이다. 이 문제를 보고 어떤 알고리즘을 사용해서 풀어야 할까 고민을 하다가 다이나믹 프로그래밍으로 풀면 되지 않을까라는 생각이 들었다. 정렬한 다음, 배열 하나를 만들고 해당 배열의 값을 메모이제이션하는 것이다. 하지만 다이나믹 프로그래밍을 하기엔 한계가 있었다.

1. 저울추의 값이 중복되는 문제

2. 메모이제이션을 실행할 때에 어떤 식으로 값을 저장해야 하는지에 대한 문제

해당 문제를 고민해보니, 다이나믹 프로그래밍으로 값이 도출되지 않을 것 같다는 결론에 이르렀다. 어떤 방식이 적합할 지 고민을 하다가 결국 인공지능의 도움을 얻었다.

코드

public class Test2437 {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

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

        Arrays.sort(w);

        long currentSum = 0;

        for (int i = 0; i < n; i++) {
            if (w[i] > currentSum + 1) {
                System.out.println(currentSum + 1);
                return;
            }
            currentSum += w[i];
        }

        System.out.println(currentSum + 1);
    }
}

그리디 알고리즘으로 문제를 풀이한 것으로 그리디 알고리즘이란 매 단계에서 가장 최적이라고 생각되는 선택을 하여 문제를 해결하는 방법이다.

추의 무게를 정렬한다음 현재 추의 무게가 측정 가능한 범위 + 1 보다 크다면 그 값이 최소 측정이 불가능한 값이 되는 것이다. 만약 값이 크지 않다면 현재 추를 사용해 측정 가능한 범위를 확장한다.

99클럽 코테 스터디 6기 8일차 TIL (미들러)

yeoni:) — Wed, 9 Apr 2025 13:59:44 +0900

문제: 백준 9996번 한국이 그리울 땐 서버에 접속하지

풀이 방법

소문자와 '*' 하나로 이루어진 패턴과 각각의 파일명이 일치하는지 구하는 문제이다. 입력 조건을 보게 되면 별표의 경우 문자열의 시작과 끝에 있지 않는다고 이야기한다. 이 말은 별표를 기준으로 두 그룹의 문자열로 나뉘게 되고 해당 문자열을 입력된 파일명과 비교를 해야 한다는 것이다.

첫 번째 시도(실패)

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        String pattern = br.readLine();

        String first = "";
        String last = "";
        int dividePlace = 0;
        for (int i = 0; i < pattern.length(); i++) {
            char c = pattern.charAt(i);
            if (c == '*') {
                dividePlace = i;
                first = pattern.substring(0, dividePlace);
                last = pattern.substring(dividePlace + 1, pattern.length());
                break;
            }
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            String fileName = br.readLine();
            if (fileName.substring(0, dividePlace).equals(first)
                    && fileName.substring(fileName.length() - dividePlace).equals(last)) {
                sb.append("DA");
            } else {
                sb.append("NE");
            }
            sb.append("\n");
        }

        System.out.println(sb);
    }
}

해당 코드를 제출하니 런타임 에러 (StringIndexOutOfBounds)라는 에러가 발생했다. 에러의 원인을 곰곰이 생각해 보니, 패턴 문자열보다 입력되는 파일명이 더 짧을 수도 있겠다는 생각이 들었다. 따라서 아래와 같이 코드를 변경하였다.

최종 코드

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        String pattern = br.readLine();

        String first = "";
        String last = "";
        for (int i = 0; i < pattern.length(); i++) {
            char c = pattern.charAt(i);
            if (c == '*') {
                first = pattern.substring(0, i);
                last = pattern.substring(i + 1, pattern.length());
                break;
            }
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            String fileName = br.readLine();

            if (fileName.length() < first.length() + last.length()) {
                sb.append("NE\n");
                continue;
            }

            if (fileName.substring(0, first.length()).equals(first)
                    && fileName.substring(fileName.length() - last.length()).equals(last)) {
                sb.append("DA");
            } else {
                sb.append("NE");
            }
            sb.append("\n");
        }

        System.out.println(sb);
    }
}

불필요한 변수는 제거해주고, 파일명의 길이가 패턴의 길이(별표 제외) 보다 짧으면 continue 하도록 코드를 변경했다.

코드를 간략히 설명하자면,

패턴에서 별표를 중심으로 문자열의 시작(first)과 끝(last) 문자를 생성하고 해당 문자와 파일명과 비교하도록 하였다. 만약 파일명의 시작과 끝이 동일할 경우 'DA'를 출력하고 아닐 경우 'NE'를 출력하도록 했다.

99클럽 코테 스터디 6기 7일차 TIL (미들러)

yeoni:) — Tue, 8 Apr 2025 11:08:11 +0900

문제: 백준 10799번 쇠막대기

풀이 방법

잘려진 쇠막대기 조각의 총 개수를 구하는 문제이다. Stack을 사용하여 쌍이 나올 때마다 개수를 세면 되지 않을까 생각했지만 원하는 출력 값이 나오지 않았다. 어떤 조건이 더 필요할까 곰곰이 생각해보니 곧바로 쌍이 나오는 경우와 닫는 괄호가 따로 나오는 경우가 다르다는 것을 알게 되었다.

닫는 괄호가 ')' 이고, 이전 문자가 여는 괄호 '(' 인 경우, 이는 레이저를 의미하기에 스택에서 하나를 제거하고 현재 스택에 남아있는 여는 괄호의 개수를 더해야 한다. 이와 다르게 이전 문자가 여는 괄호 '(' 가 아닌 경우는 쇠막대기의 끝을 의미하기에 스택에서 하나를 제거하고 조각 하나를 추가해야 한다.

제출 코드

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

        Stack<Character> stack = new Stack<>();
        int count = 0;

        char first = input.charAt(0);
        if (first == '(')
            stack.add(first);

        for (int i = 1; i < input.length(); i++) {
            char c = input.charAt(i);
            if (c == '(') {
                stack.add(c);
            } else if (c == ')' && input.charAt(i - 1) == '(') {
                stack.pop();
                count += stack.size();
            } else {
                stack.pop();
                count++;
            }
        }

        System.out.println(count);
    }
}

first 변수

닫는 괄호가 먼저 나올 일은 없지만 ArrayOutBoundException이라는 예외를 피하기 위해 변수를 만들고 조건문을 작성하였다.

for 반복문

1번부터 반복하면서 여는 괄호('(') 일때 Stack에 넣고 닫는 괄호이면서 이전 값이 여는 괄호일 때 Stack.pop()를 하고 stack에 남은 개수를 카운트하도록 하였다. 그 외의 경우에는 1만 카운트하도록 하였다.

최종 코드

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

        String str = br.readLine();

        int totalcount = 0;

        Stack<Character> stack = new Stack<>();

        for(int i = 0; i < str.length(); i++){
            char ch = str.charAt(i);
            if(ch == '('){
                stack.push(ch);
            }
            else{
                stack.pop();
                if(str.charAt(i - 1) == '('){
                    totalcount += stack.size();
                }else{
                    totalcount++;
                }
            }
        }
        System.out.println(totalcount);
    }
}

닫는 괄호가 먼저 나올 일이 없으니 first 변수를 제외하고 반복되어 사용되는 코드를 줄인 코드이다. 이렇게 하니 중복코드없이 보기에도 깔끔하고 보다 명확해진 것 같다.

99클럽 코테 스터디 6기 6일차 TIL (미들러)

yeoni:) — Mon, 7 Apr 2025 10:23:08 +0900

문제: 백준 4963번 섬의 개수

풀이방법

각 테스트 케이스에서 가로, 세로, 대각선으로 연결되어 있는 섬을 구하는 문제이다. 이 문제는 DFS나 BFS 알고리즘을 통해 풀 수 있다.

코드가 길기 때문에 메서드 별로 나눠서 설명하도록 하겠다.

Main

public class Main {
    static int[] dr = { 1, -1, 0, 0, -1, -1, 1, 1 };
    static int[] dc = { 0, 0, 1, -1, -1, 1, -1, 1 };

    static int w;
    static int h;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        StringBuilder sb = new StringBuilder();
        
        while (true) {
            st = new StringTokenizer(br.readLine(), " ");
            w = Integer.parseInt(st.nextToken());
            h = Integer.parseInt(st.nextToken());

            if (w == 0 && h == 0)
                break;

            int[][] map = new int[h][w];
            for (int i = 0; i < h; i++) {
                st = new StringTokenizer(br.readLine(), " ");
                for (int j = 0; j < w; j++) {
                    map[i][j] = Integer.parseInt(st.nextToken());
                }
            }
            boolean[][] visited = new boolean[h][w];
            sb.append(countLands(map, visited)).append("\n");
        }
        System.out.println(sb);
    }

static 변수 dr, dc

섬(1)이 가로, 세로, 대각선에 존재하는지 체크한다. 위, 아래, 양 옆뿐만 아니라 각 대각선도 체크해야 하기 때문이다.

while문

해당 문제는 여러 개의 테스트 케이스를 입력 값으로 두기 때문에 반복문을 이용하여 값을 받고 조건문을 통해 while문을 빠져나오도록 설정(조건: w와 h가 0일 때)

int[][] map

정사각형으로 이루어진 지도의 값을 저장하는 배열

boolean[][] visited

지도의 위치에 방문했는지 체크하는 배열

coundLands

private static int countLands(int[][] map, boolean[][] visited) {
    int count = 0;
    for (int i = 0; i < map.length; i++) {
        for (int j = 0; j < map[i].length; j++) {
            if (map[i][j] == 1 && !visited[i][j]) {
                count += bfs(i, j, map, visited);
            }
        }
    }
    return count;
}

섬의 개수를 세는 메서드로 만약 현재 반복문에서 가리키는 곳이 섬(1)이고 방문하지 않았다면 dfs() 메서드를 호출하고 count 값을 업데이트한다. 반복문이 종료되었을 때에는 count를 리턴한다.

bfs

private static int bfs(int x, int y, int[][] map, boolean[][] visited) {
    Queue<int[]> q = new LinkedList<>();
    q.offer(new int[] { x, y });
    visited[x][y] = true;

    while (!q.isEmpty()) {
        int[] target = q.poll();

        for (int i = 0; i < 8; i++) {
            int r = target[0] + dr[i];
            int c = target[1] + dc[i];
            if (r >= 0 && r < h && c >= 0 && c < w && map[r][c] == 1 && !visited[r][c]) {
                q.offer(new int[] { r, c });
                visited[r][c] = true;
            }
        }
    }
    return 1;
}

Queue를 만들어 현재 값을 저장하고 반복문을 통해 가로, 세로, 대각선에 섬이 있는지 체크하는 로직이다. 섬이 존재한다면 반복문을 돌며 q 변수에 저장이 되고 방문여부를 true로 변경한다. 존재하는 섬이 없다면 1을 리턴한다.

99클럽 코테 스터디 6기 5일차 TIL (미들러)

yeoni:) — Fri, 4 Apr 2025 10:35:51 +0900

문제: 백준 2559번 수열

풀이방법

이 문제는 주어진 k일 동안 연속된 온도의 합이 가장 큰 값을 출력해야 한다. 문제가 어렵지 않았는데 다양한 방법을 시도하다 여러 실패를 맛보았다.

첫 번째 시도

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new java.io.InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        int n = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());

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

        int max = Integer.MIN_VALUE;
        Queue<Integer> q = new LinkedList<>();
        
        for (int i = 0; i < n; i++) {
            if (q.size() == k) {
                int sum = 0;
                for (Integer val : q) {
                    sum += val;
                }
                max = Math.max(max, sum);
                q.remove();
            }
            q.add(arr[i]);
        }

        System.out.println(max);

    }
}

Queue를 활용하여 값을 저장하고 지정된 사이즈보다 클 때 합을 계산하도록 했다.

값은 정확하게 반환되는데, 큐 내부 연산과 for문 내에서 합을 계산하기 위해 반복문을 내부에서 한번 더 사용하기 때문에 시간 초과 에러가 떴다.

두 번째 시도

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new java.io.InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        int n = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());

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

        int max = Integer.MIN_VALUE;

        for (int i = 0; i <= n - k; i++) {
            int sum = 0;
            for (int j = i; j < k + i; j++) {
                sum += arr[j];
            }
            max = Math.max(max, sum);
        }

        System.out.println(max);
    }
}

이중 for문을 활용하여 값을 계산하도록 했다. 코드도 단순하고 쉽지만 중첩된 반복문을 사용하기 때문에 시간복잡도가 O(N^2)이 되어 좋지 않은 알고리즘 코드가 된다.

세 번째 시도

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new java.io.InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        int n = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());

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

        int max = Integer.MIN_VALUE;
        int sum = 0;

        int first = 0;
        int second = 0;
        while (second < n) {
            sum += arr[second];

            if (second - first + 1 > k) {
                sum -= arr[first];
                first++;
            }

            if (second - first + 1 == k) {
                max = Math.max(max, sum);
            }

            second++;
        }

        System.out.println(max);
    }
}

투포인터 알고리즘을 활용한 풀이이다. 다른 코드에 비해 for문을 한 번만 사용하기에 시간복잡도는 O(N)이 된다.

if(second - first +1 > k)

second - first +1 > k 가 된다면 구간의 길이를 초과하게 됨으로 첫 번째 포인터의 값을 빼주어야 한다. 그리고 해당 포인터의 위치를 이동한다.

if(second - first + 1 == k)

포인터의 간격이 구간의 길이와 일치할 때는 해당 값을 가장 큰 합과 비교하여 저장하도록 한다.

99클럽 코테 스터디 6기 4일차 TIL (미들러)

yeoni:) — Thu, 3 Apr 2025 11:26:03 +0900

문제: 백준 2468번 안전 영역

풀이방법

어떤 지역의 높이 정보가 주어졌을 때, 장마철에 물에 잠기지 않는 안전한 영역의 최대 개수를 계산해야 하는데, 이를 위해서는 모든 경우의 수를 구해야 한다고 생각했다. 모든 가능성을 다 확인한 다음, 안전한 영역의 개수를 구하기 위해 DFS || BFS 알고리즘을 활용해서 문제를 풀었다.

첫 번째 시도(실패)

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        int maxHeight = 0;
        for (int i = 1; i < max; i++) {
            maxHeight = Math.max(maxHeight, countSafeSpace(height, n, i));
        }

        System.out.println(maxHeight);
    }

    private static int countSafeSpace(int[][] height, int n, int h) {
        boolean[][] space = new boolean[n][n];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (height[i][j] <= h) {
                    space[i][j] = true;
                }
            }
        }

        int count = 0;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (!space[i][j]) {
                    count += dfs(space, i, j, n);
                }
            }
        }

        return count;
    }

    private static int dfs(boolean[][] space, int x, int y, int n) {
        int[] dr = { 1, -1, 0, 0 };
        int[] dc = { 0, 0, 1, -1 };
        Stack<int[]> stack = new Stack<>();
        stack.push(new int[] { x, y });
        space[x][y] = true;

        while (!stack.isEmpty()) {
            int[] val = stack.pop();
            for (int i = 0; i < 4; i++) {
                int r = val[0] + dr[i];
                int c = val[1] + dc[i];

                if (r >= 0 && r < n && c >= 0 && c < n && space[r][c] == false) {
                    stack.push(new int[] { r, c });
                    space[r][c] = true;
                }
            }
        }

        return 1;
    }
}

예제로 문제를 풀었을 때도 이상 없이 동작했는데 실패했다는 문구가 떴다. 무엇이 문제일까 곰곰이 생각해 봐도 답이 나오지 않았다. 그래서 나는 인공지능의 힘을 빌려 틀린 이유에 대해 알아보았다.

알아보니, 경우의 수 범위를 잘못 설정해 비가 안 오거나 모든 게 물에 잠길 가능성을 포함하지 않아서였다. 즉, main 메서드 내의 for문은 0 ~ max까지 탐색하도록 했어야 했다.

for (int i = 0; i <= max; i++) {
    maxHeight = Math.max(maxHeight, countSafeSpace(height, n, i));
}

코드를 아래와 같이 변경하니 오류 없이 동작했다.

인공지능의 제안(?)

1. DFS, BFS 모두 사용할 수 있지만 시간복잡도나 메모리 측면에서는 BFS가 더 효율적이고 직관적이다.

2. boolean[] 배열을 미리 초기화하는 건 직관적이지만, 방문 여부를 체크하는 배열로 따로 두고 조건문에서 관리하는 것이 더 명확하다.

인공지능의 제안에 따라 Queue로 BFS 알고리즘을 구현하였고, 방문 여부를 체크할 때 각 데이터의 높이를 비교하기로 하였다.

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        int maxHeight = 0;

        for (int i = 0; i <= max; i++) {
            maxHeight = Math.max(maxHeight, countSafeSpace(height, n, i));
        }

        System.out.println(maxHeight);
    }

    private static int countSafeSpace(int[][] height, int n, int h) {
        boolean[][] visited = new boolean[n][n];
        int count = 0;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (height[i][j] > h && !visited[i][j]) {
                    count += dfs(visited, height, i, j, n, h);
                }
            }
        }

        return count;
    }

    private static int dfs(boolean[][] visited, int[][] height, int x, int y, int n, int h) {
        int[] dr = { 1, -1, 0, 0 };
        int[] dc = { 0, 0, 1, -1 };
        visited[x][y] = true;
        Queue<int[]> q = new LinkedList<>();
        q.offer(new int[] { x, y });

        while (!q.isEmpty()) {
            int[] val = q.poll();
            for (int i = 0; i < 4; i++) {
                int r = val[0] + dr[i];
                int c = val[1] + dc[i];

                if (r >= 0 && r < n && c >= 0 && c < n && !visited[r][c] && height[r][c] > h) {
                    q.offer(new int[] { r, c });
                    visited[r][c] = true;
                }
            }
        }

        return 1;
    }
}

시간복잡도나 메모리 측면으로 봤을 때 더 나아졌는지 모르겠지만, 방문 여부 배열을 따로 두니 코드가 훨씬 깔끔해졌다. 인공지능의 말이 모두 정확한 건 아니지만 풀이할 때 다른 사람들의 코드를 보거나 인공지능의 힘을 빌리는 것도 생각을 확장하는 데에 도움을 주는 것 같다.

99클럽 코테 스터디 6기 3일차 TIL (미들러)

yeoni:) — Wed, 2 Apr 2025 14:33:23 +0900

문제: 프로그래머스 바탕화면 정리

코딩테스트를 준비하는 머쓱이는 프로그래머스에서 문제를 풀고 나중에 다시 코드를 보면서 공부하려고 작성한 코드를 컴퓨터 바탕화면에 아무 위치에나 저장해 둡니다. 저장한 코드가 많아지면서 머쓱이는 본인의 컴퓨터 바탕화면이 너무 지저분하다고 생각했습니다. 프로그래머스에서 작성했던 코드는 그 문제에 가서 다시 볼 수 있기 때문에 저장해 둔 파일들을 전부 삭제하기로 했습니다.

컴퓨터 바탕화면은 각 칸이 정사각형인 격자판입니다. 이때 컴퓨터 바탕화면의 상태를 나타낸 문자열 배열 wallpaper가 주어집니다. 파일들은 바탕화면의 격자칸에 위치하고 바탕화면의 격자점들은 바탕화면의 가장 왼쪽 위를 (0, 0)으로 시작해 (세로 좌표, 가로 좌표)로 표현합니다. 빈칸은 ".", 파일이 있는 칸은 "#"의 값을 가집니다. 드래그를 하면 파일들을 선택할 수 있고, 선택된 파일들을 삭제할 수 있습니다.

머쓱이는 최소한의 이동거리를 갖는 한 번의 드래그로 모든 파일을 선택해서 한 번에 지우려고 하며 드래그로 파일들을 선택하는 방법은 다음과 같습니다.드래그는 바탕화면의 격자점 S(lux, luy)를 마우스 왼쪽 버튼으로 클릭한 상태로 격자점 E(rdx, rdy)로 이동한 뒤 마우스 왼쪽 버튼을 떼는 행동입니다. 이때, "점 S에서 점 E로 드래그한다"고 표현하고 점 S와 점 E를 각각 드래그의 시작점, 끝점이라고 표현합니다.점 S(lux, luy)에서 점 E(rdx, rdy)로 드래그를 할 때, "드래그 한 거리"는 |rdx - lux| + |rdy - luy|로 정의합니다.점 S에서 점 E로 드래그를 하면 바탕화면에서 두 격자점을 각각 왼쪽 위, 오른쪽 아래로 하는 직사각형 내부에 있는 모든 파일이 선택됩니다.

예를 들어 wallpaper = [".#...", "..#..", "...#."]인 바탕화면을 그림으로 나타내면 다음과 같습니다.이러한 바탕화면에서 다음 그림과 같이 S(0, 1)에서 E(3, 4)로 드래그하면 세 개의 파일이 모두 선택되므로 드래그 한 거리 (3 - 0) + (4 - 1) = 6을 최솟값으로 모든 파일을 선택 가능합니다.

(0, 0)에서 (3, 5)로 드래그해도 모든 파일을 선택할 수 있지만 이때 드래그 한 거리는 (3 - 0) + (5 - 0) = 8이고 이전의 방법보다 거리가 늘어납니다.머쓱이의 컴퓨터 바탕화면의 상태를 나타내는 문자열 배열 wallpaper가 매개변수로 주어질 때 바탕화면의 파일들을 한 번에 삭제하기 위해 최소한의 이동거리를 갖는 드래그의 시작점과 끝점을 담은 정수 배열을 return하는 solution 함수를 작성해 주세요. 드래그의 시작점이 (lux, luy), 끝점이 (rdx, rdy)라면 정수 배열 [lux, luy, rdx, rdy]를 return하면 됩니다.

풀이방법

문제가 길어서 어려울 줄 알았는데, 읽어보니 x, y 최소 값과 최대 값을 구하면 되는 거였다.

값을 구하기 위해 Integer 클래스의 min(), max() 함수를 활용해보았다.

class Solution {
    public int[] solution(String[] wallpaper) {
        int[] answer = { Integer.MAX_VALUE, Integer.MAX_VALUE, 
                        Integer.MIN_VALUE, Integer.MIN_VALUE };

        for (int i = 0; i < wallpaper.length; i++) {
            char[] paper = wallpaper[i].toCharArray();
            for (int j = 0; j < paper.length; j++) {
                char c = paper[j];
                if (c == '#') {
                    answer[0] = Integer.min(answer[0], i);
                    answer[1] = Integer.min(answer[1], j);
                    answer[2] = Integer.max(answer[2], i + 1);
                    answer[3] = Integer.max(answer[3], j + 1);
                }
            }
        }
        return answer;
    }
}

int[] answer 배열 초기화

최소와 최대 값을 저장하기 위해 배열의 값을 초기화 해주었다. 배열의 0, 1 번째는 최소 값이 들어가야 하기에 Integer.MAX_VALUE를 사용하였고 2, 3 번째 배열은 최대 값을 저장하기 위해 MIN_VALUE 를 사용하였다.

반복문

이중 for문으로 배열의 모든 값을 반복하게 하였다. 만약 현재의 값이 '#'라면, 배열의 값을 갱신하도록 했다. 위의 배열과 동일하게 최소값이 저장되어야 할 answer[0]과 answer[1]의 Integer.min() 함수를 사용했고 나머지는 Integer.max() 함수를 사용했다. 최대 값의 경우 배열이 0부터 시작하기 때문에 +1를 해주었다.

99클럽 코테 스터디 6기 2일차 TIL (미들러)

yeoni:) — Tue, 1 Apr 2025 17:03:38 +0900

문제: 14495번 피보나치 비스무리한 수열

풀이방법

피보나치 수열 계산을 위해 배열을 만든 뒤 반복문으로 값을 저장했다.

n차 시도(실패)

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        if (n <= 3)
            System.out.println(1);
        else
            System.out.println(fibo(n));
    }
    private static int fibo(int n) {
        int[] arr = new int[n + 1];
        arr[1] = arr[2] = arr[3] = 1;

        for (int i = 4; i < arr.length; i++) {
            arr[i] = arr[i - 1] + arr[i - 3];
        }
        return arr[n];
    }
}

너무 쉬운 문제이기에 바로 통과할 줄 알았다. 근데 아무리 고치고 고쳐도 계속 틀렸다는 메세지만 받았다.

n차 시도 끝에 성공

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
       BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        long[] dp = new long[117];
        dp[1] = dp[2] = dp[3] = 1;
        for (int i = 4; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 3];
        }
        System.out.print(dp[n]);
    }
}

알고보니 값이 너무 커져서 int 범위를 초과했던 것.. 간단한 문제였는데 쓸데없이 시간을 많이 잡아먹었다.

다음부터는 데이터 범위를 고려하며 문제를 풀어야겠다.

99클럽 코테 스터디 22일차 TIL (미들러)

yeoni:) — Tue, 18 Feb 2025 22:12:59 +0900

문제: 11053번 가장 긴 증가하는 부분 수열

풀이방법

입력 수가 크지 않기 때문에 충분히 어렵지 않을 꺼라고 생각했다. 하지만 첫 시도부터 실패를 맛보고 말았다.

1차 시도(실패)

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[n];
        int[] dp = new int[n];
        dp[0] = 1;

        StringTokenizer st = new StringTokenizer(br.readLine(), " ");

        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

        int max = arr[0];

        for (int i = 1; i < n; i++) {
            if (max < arr[i]) {
                dp[i] = dp[i - 1] + 1;
                max = arr[i];
            } else {
                dp[i] = dp[i - 1];
            }
        }

        System.out.println(dp[n - 1]);
    }
}

실패한 이유

LIS의 경우 증가하는 부분 수열을 구해야 하는데, 단순히 이전 값만 비교하는 식으로 문제로 풀었다. 이 방식의 경우 부분을 찾지 않기 때문에 해당 문제에 올바르지 않은 코드였다.

두번째 시도(성공)

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        int[] dp = new int[n];
        Arrays.fill(dp, 1);

        StringTokenizer st = new StringTokenizer(br.readLine(), " ");

        for (int i = 0; i < n; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

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

        int max = 0;
        for (int i : dp) {
            max = Math.max(max, i);
        }

        System.out.println(max);
    }
}

모든 수의 값을 1로 업데이트 해주고, i번째 원소에 대해 이번 원소들을 모두 비교하여 큰 값으로 업데이트 하도록 코드를 변경했다. 그리고 가장 큰 부분 수열의 길이를 출력하도록 하였다.

코테스터디 TIL

2025.02.18 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 21일차 TIL (미들러)

99클럽 코테 스터디 21일차 TIL (미들러)

문제: 1003번 피보나치 함수예제// Input3013// Output1 00 11 2 풀이방법피보나치 수열을 이용하여 재귀를 풀 경우, 동일한 식을 반복해버리기에 시간을 초과해버린다. 메모이제이션 기법을 활용하면

become-programmer.tistory.com

2025.02.15 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 20일차 TIL (미들러)

99클럽 코테 스터디 20일차 TIL (미들러)

문제: 19598번 최소 회의실 개수예제// Input30 4015 305 10// Output2 풀이방법회의실 배정과 관련된 문제는 풀어보았지만, 최소 회의실 개수를 구하는 것은 쉽지 않은 것 같다. 시도1(실패)public class M

become-programmer.tistory.com

99클럽 코테 스터디 21일차 TIL (미들러)

yeoni:) — Tue, 18 Feb 2025 09:13:00 +0900

문제: 1003번 피보나치 함수

예제

// Input
3
0
1
3
// Output
1 0
0 1
1 2

풀이방법

피보나치 수열을 이용하여 재귀를 풀 경우, 동일한 식을 반복해버리기에 시간을 초과해버린다. 메모이제이션 기법을 활용하면 반복적인 계산을 하지 않고 해당 값을 저장해놓기 때문에 훨씬 효율적이다.

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int t = Integer.parseInt(br.readLine());
        int[][] dp = new int[41][2];

        dp[0][0] = 1;
        dp[0][1] = 0;
        dp[1][0] = 0;
        dp[1][1] = 1;

        for (int i = 2; i < 41; i++) {
            dp[i][0] = dp[i - 1][0] + dp[i - 2][0];
            dp[i][1] = dp[i - 1][1] + dp[i - 2][1];
        }

        StringBuilder sb = new StringBuilder();
        while (t-- > 0) {
            int n = Integer.parseInt(br.readLine());
            sb.append(dp[n][0]).append(" ").append(dp[n][1]).append("\n");

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

dp라는 이름을 배열을 생성하고, [n][0]에는 0의 호출 횟수, [n][1]에는 1의 호출 횟수를 자연수 40까지 값을 저장해놓는다. 그리고 반복문을 이용하여 해당 숫자의 0, 1의 호출 횟수를 출력한다.

코테스터디 TIL

2025.02.15 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 20일차 TIL (미들러)

99클럽 코테 스터디 20일차 TIL (미들러)

become-programmer.tistory.com

2025.02.13 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 18일차 TIL (미들러)

99클럽 코테 스터디 18일차 TIL (미들러)

문제: 17503번 맥주 축제import java.util.*;import java.io.*;public class Main { static class Beer { int favor, level; public Beer(int favor, int level) { this.favor = favor;

become-programmer.tistory.com

99클럽 코테 스터디 20일차 TIL (미들러)

yeoni:) — Sat, 15 Feb 2025 00:59:42 +0900

문제: 19598번 최소 회의실 개수

예제

// Input
3
0 40
15 30
5 10

// Output
2

풀이방법

회의실 배정과 관련된 문제는 풀어보았지만, 최소 회의실 개수를 구하는 것은 쉽지 않은 것 같다.

시도1(실패)

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        int[][] meetings = new int[n][2];

        for (int i = 0; i < n; i++) {
            String[] str = br.readLine().split(" ");
            meetings[i][0] = Integer.parseInt(str[0]);
            meetings[i][1] = Integer.parseInt(str[1]);
        }

        Arrays.sort(meetings, Comparator.comparingInt(o -> o[0]));

        int cnt = 1;
        int endTime = 0;
        int idx = 0;

        while (idx < n) {
            for (int i = idx + 1; i < n; i++) {
                if (endTime <= meetings[i][0]) {
                    endTime = meetings[i][1];
                } else {
                    cnt++;
                    break;
                }
            }
            idx++;
        }
        System.out.println(cnt);
    }
}

그리디 알고리즘을 활용하여 빨리 시작하는 회의 순으로 정렬한다.

이전 회의 종료시간과 현재 회의 시작시간을 비교하고 종료시간이 더 클 경우 회의실의 개수를 늘린다.

문제점

시작시간으로 정렬하고 비교하게 되면, 다음 회의를 제외하곤 비교가 불가능하다. 따라서 회의실의 개수가 잘못 계산된다.

시도2

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        int[][] meetings = new int[n][2];

        for (int i = 0; i < n; i++) {
            String[] str = br.readLine().split(" ");
            meetings[i][0] = Integer.parseInt(str[0]);
            meetings[i][1] = Integer.parseInt(str[1]);
        }

        Arrays.sort(meetings, Comparator.comparingInt(a -> a[0]));

        PriorityQueue<Integer> pq = new PriorityQueue<>();
        int cnt = 0;

        for (int[] meeting : meetings) {
            int start = meeting[0];
            int end = meeting[1];

            while (!pq.isEmpty() && pq.peek() <= start) {
                pq.poll();
            }

            pq.offer(end);

            cnt = Math.max(cnt, pq.size());
        }
        System.out.println(cnt);
    }
}

배열로 값을 입력 받고, 시작시간이 빠른 순으로 정렬한다.

우선순위 큐도 선언하는데, 이 큐에는 회의의 종료시간만 저장된다.

반복문을 이용하여 입력될 회의의 시작시간이 종료시간과 같거나 클 경우, 큐에 저장된 값을 제거한다.

만약 조건에 부합하지 못하면 큐에 값을 삽입한다.

그리고 회의실의 개수를 최대 갯수로 업데이트한다.

코테스터디 TIL

2023.06.26 - [알고리즘/백준] - JAVA [백준] 1946번: 신입사원

JAVA [백준] 1946번: 신입사원

자바 1946번 문제 언제나 최고만을 지향하는 굴지의 대기업 진영 주식회사가 신규 사원 채용을 실시한다. 인재 선발 시험은 1차 서류심사와 2차 면접시험으로 이루어진다. 최고만을 지향한다는

become-programmer.tistory.com

2025.02.13 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 18일차 TIL (미들러)

99클럽 코테 스터디 18일차 TIL (미들러)

문제: 17503번 맥주 축제import java.util.*;import java.io.*;public class Main { static class Beer { int favor, level; public Beer(int favor, int level) { this.favor = favor;

become-programmer.tistory.com

99클럽 코테 스터디 18일차 TIL (미들러)

yeoni:) — Thu, 13 Feb 2025 10:50:10 +0900

문제: 17503번 맥주 축제

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

public class Main {
    static class Beer {
        int favor, level;
        public Beer(int favor, int level) {
            this.favor = favor;
            this.level = level;
        }
    }

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

        int N = Integer.parseInt(st.nextToken()); // 마셔야 하는 맥주 개수
        int M = Integer.parseInt(st.nextToken()); // 선호도의 합
        int K = Integer.parseInt(st.nextToken()); // 맥주의 종류 수

        Beer[] beers = new Beer[K];
        for (int i = 0; i < K; i++) {
            st = new StringTokenizer(br.readLine());
            int favor = Integer.parseInt(st.nextToken());
            int level = Integer.parseInt(st.nextToken());
            beers[i] = new Beer(favor, level);
        }

        // 1. 도수 레벨이 낮은 순서로 정렬
        Arrays.sort(beers, (a, b) -> a.level - b.level);

        // 2. 최소 힙(우선순위 큐)을 사용하여 N개 선택
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        int sumFavor = 0; // 현재 선택한 맥주의 선호도 합
        int minLevel = -1; // 조건을 만족하는 최소 도수 레벨

        for (Beer beer : beers) {
            pq.offer(beer.favor);
            sumFavor += beer.favor;

            if (pq.size() > N) { // N개 초과하면 가장 작은 선호도 제거
                sumFavor -= pq.poll();
            }

            // 3. N개의 맥주를 선택했고, 선호도 합이 M 이상이면 최소 도수 업데이트
            if (pq.size() == N && sumFavor >= M) {
                minLevel = beer.level;
                break;
            }
        }

        // 4. 조건 만족 여부에 따라 출력
        System.out.println(minLevel);
    }
}

99클럽 코테 스터디 17일차 TIL (미들러)

yeoni:) — Wed, 12 Feb 2025 00:45:09 +0900

문제: 11399번 ATM

예제

// Input
5
3 1 4 3 2

// Output
32

풀이 방법

이 문제는 돈을 인출하는 데 걸리는 최소 시간을 출력해야 하는 문제다.

이 문제를 보자마자 최적의 값을 만들기 위해 그리디 알고리즘을 사용해야겠구나 생각이 들었다.

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

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

        if (n == 1) {
            System.out.println(nums[0]);
            return;
        } else {
            Arrays.sort(nums);
            long result = nums[0];

            for (int i = 1; i < n; i++) {
                nums[i] += nums[i - 1];
                result += nums[i];
            }
            System.out.println(result);
        }
    }
}

입력값 변수에 저장하기

주어진 사람의 수와 각 사람이 돈을 인출하는 데 걸리는 시간을 n과 nums에 저장한다.

조건문

사람의 수는 한 명이 될 수도 있기에 이와 같은 경우는 바로 출력하도록 하였다.

2명 이상인 경우에는 정렬을 하여 최소 시간이 우선이 되도록 하였다. 반복문을 활용하여 현재 배열의 값에 이전 값을 더하여 저장하였고, 그 값을 출력 값에 더하여 마지막에 해당 값을 리턴하도록 했다.

코테스터디 TIL

2025.02.11 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 16일차 보너스 문제

99클럽 코테 스터디 16일차 보너스 문제

문제: 프로그래머스 소수찾기문제 설명한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.각 종이 조각에 적힌 숫자가 적

become-programmer.tistory.com

2025.02.10 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 16일차 TIL (미들러)

99클럽 코테 스터디 16일차 TIL (미들러)

문제: 27961번 고양이는 많을수록 좋다예제// Input16// Output14// Input22147483648// Output232 풀이 방법이 문제는 주어진 N수에 만족하도록 고양이를 만들어야 하는 문제이다. 고양이를 생성하는 방법은

become-programmer.tistory.com

99클럽 코테 스터디 16일차 보너스 문제

yeoni:) — Tue, 11 Feb 2025 09:53:08 +0900

문제: 프로그래머스 소수찾기

문제 설명
한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.

제한사항
numbers는 길이 1 이상 7 이하인 문자열입니다.
numbers는 0~9까지 숫자만으로 이루어져 있습니다.
"013"은 0, 1, 3 숫자가 적힌 종이 조각이 흩어져있다는 의미입니다.

입출력
예제 #1
numbers "17"
#1[1, 7]으로는 소수 [7, 17, 71]를 만들 수 있습니다.

예제 #2
numbers "011"
[0, 1, 1]으로는 소수 [11, 101]를 만들 수 있습니다.11과 011은 같은 숫자로 취급합니다.

풀이방법

소수 찾기는 프로그래밍에서 꽤나 흔한 문제이다. 그러나 이 문제는 입력 값의 순열하여 소수를 찾아내야 하기에 일반적인 소수 찾기 예제보다 풀이가 까다롭다.

1. HashSet

HashSet<Integer> numberSet = new HashSet<>();

조합할 수 있는 모든 수를 저장하기 위해 HashSet을 생성한다.

2. boolean[]

boolean[] visited = new boolean[numbers.length()];

숫자의 모든 조합을 탐색하기 위해 입력 값의 길이 만큼 boolean[] 배열을 생성한다.

3. generateNumbers

void generateNumbers(String cur, String numbers, boolean[] visited){
    if(!cur.equals("")){
        set.add(Integer.parseInt(cur));
    }

    for(int i = 0; i < numbers.length(); i++){
        if(!visited[i]){
            visited[i] = true;
            generateNumbers(cur + numbers.charAt(i), numbers, visited);
            visited[i] = false;
        }
    }
}

순열을 이용하여 숫자를 조합하고 해당 수를 set에 저장한다.

4. isPrime

boolean isPrime(int num) {
    if (num < 2) return false;
    for (int i = 2; i <= Math.sqrt(num); i++) {
        if (num % i == 0) return false;
    }
    return true;
}

num의 제곱까지만 검사하여 변수의 값이 소수인지 아닌지 판별한다.

전체코드

import java.util.HashSet;

class Solution {
    static HashSet<Integer> numberSet = new HashSet<>();
    
    public int solution(String numbers) {
        // 1. 순열을 이용해 가능한 모든 숫자 조합 만들기
        boolean[] visited = new boolean[numbers.length()];
        generateNumbers("", numbers, visited);
        
        // 2. 소수인지 확인하고 개수 세기
        int count = 0;
        for (int num : numberSet) {
            if (isPrime(num)) count++;
        }
        
        return count;
    }

    // 모든 숫자 조합
    static void generateNumbers(String current, String numbers, boolean[] visited) {
        if (!current.equals("")) {
            numberSet.add(Integer.parseInt(current));
        }

        for (int i = 0; i < numbers.length(); i++) {
            if (!visited[i]) {
                visited[i] = true;
                generateNumbers(current + numbers.charAt(i), numbers, visited);
                visited[i] = false;
            }
        }
    }

    // 소수인지 아닌지 
    static boolean isPrime(int num) {
        if (num < 2) return false;
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) return false;
        }
        return true;
    }
}

99클럽 코테 스터디 16일차 TIL (미들러)

yeoni:) — Mon, 10 Feb 2025 11:49:30 +0900

문제: 27961번 고양이는 많을수록 좋다

예제

// Input1
6

// Output1
4

// Input2
2147483648

// Output2
32

풀이 방법

이 문제는 주어진 N수에 만족하도록 고양이를 만들어야 하는 문제이다. 고양이를 생성하는 방법은 두 가지인데, 아래와 같다.

1. 생성마법: 고양이 1마리 생성가능

2. 복제마법: 고양이 1 ~ 존재하는 고양이 마리 수까지 생성가능

만약 N = 6이라고 한다면,

1번 생성마법: 현재 고양이가 존재하지 않기에 1마리 생성

2번 생성 || 복제 마법: 어떤 마법을 쓰든 1마리 생성가능

3번 복제마법: 현재 2마리로 +2마리까지 생성가능

4번 복제마법: 4마리에서 2마리만 복제하면 됨

총 4번의 마법을 써야 N과 동일한 고양이를 만들 수 있고 8마리까지 만들 수 있다.

위의 예시를 보게 되면 처음에 고양이 한 마리를 생성하는 것 이외에는 거듭제곱을 통해 고양이 수를 늘려주는 게 최소 숫자가 최대 고양이를 만들 수 있다. 즉, 최적의 선택을 하기 위해 그리디 알고리즘을 이용하면 된다.

주의해야 할 점은 N은 10의 12제곱까지 가능하기에 변수 타입을 long으로 설정해야 한다.

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        long n = Long.parseLong(br.readLine());

        long catCount = 1;
        long magic = 1;

        if (n == 0) {
            System.out.println(0);
            return;
        } else {
            while (true) {
                if (catCount >= n) {
                    System.out.println(magic);
                    return;
                }
                catCount *= 2;
                magic++;
            }
        }
    }
}

N이 0일 경우 바로 0을 출력하도록 하고, 그 이외의 경우에는 고양이 수를 현재 고양이 수 * 2를 해주고, 마법 횟수를 증가해준다. 만약 고양이의 수가 n과 동일하거나 크다면, 마법 사용 횟수를 출력한다.

코테스터디 TIL

2025.02.07 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 14일차 TIL (미들러)

99클럽 코테 스터디 14일차 TIL (미들러)

문제: 2615번 오목예제// input0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 1 2 0 0 2 2 2 1 0 0 0 0 0 0 0 0 0 00 0 1 2 0 0 0 0 1 0 0 0 0 0 0 0 0 0 00 0 0 1 2 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 1 2 2 0 0 0 0 0 0 0 0 0 0 0

become-programmer.tistory.com

99클럽 코테 스터디 14일차 TIL (미들러)

yeoni:) — Fri, 7 Feb 2025 10:34:57 +0900

문제: 2615번 오목

예제

// input
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 2 0 0 2 2 2 1 0 0 0 0 0 0 0 0 0 0
0 0 1 2 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
0 0 0 1 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 2 2 0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 2 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

// output
1
3 2

풀이방법

이 문제를 접하고 DFS 알고리즘을 이용해 재귀적으로 탐색하면 될 것이라 생각하고 풀었는데, 계속 실패했다. 그 이유는 같은 방향으로 5개가 연속되었는지 확인해야 하기에 DFS보다 완전탐색이 적합했다.

1. 완전 탐색

for (int i = 0; i < 19; i++) {
    for (int j = 0; j < 19; j++) {
        if (board[i][j] != 0) {
            if (isFive(i, j)) {
                System.out.println(board[i][j]);
                System.out.println((i + 1) + " " + (j + 1));
                return;
            }
        }
    }
}

모든 위치를 다 탐색하는데, 바둑돌이 있을 경우에만 isFive()라는 메서드를 실행한다. 실행 결과가 true라면 즉시 값을 출력하고 종료한다.

2. isFive() 메서드

static boolean isFive(int x, int y) {
    int color = board[x][y];

    for (int i = 0; i < 4; i++) {
        int cnt = 1;
        int r = x + dr[i];
        int c = y + dc[i];

        while (isValid(r, c) && board[r][c] == color) {
            cnt++;
            r += dr[i];
            c += dc[i];
        }

        r = x - dr[i];
        c = y - dc[i];

        while (isValid(r, c) && board[r][c] == color) {
            cnt++;
            r -= dr[i];
            c -= dc[i];
        }

        if (cnt == 5) {
            if (!isValid(x - dr[i], y - dc[i]) || board[x - dr[i]][y - dc[i]] != color) {
                return true;
            }
        }
    }
    return false;
}

이 문제에서의 조건은 연속된 바둑돌이 6개가 되면 안된다. 따라서 한 방향으로 탐색한 이후 반대 방향도 탐색하여 바둑돌의 개수가 정확히 5개인지 확인해야 한다.

만약 시작점에서 반대 방향의 값이 범위를 벗어났거나 같은 색상의 바둑돌이 아니라면 연속된 바둑돌의 개수가 5개라는 뜻이기에 true를 리턴한다. 그게 아니라면 false를 리턴한다.

전체코드

public class Main {
    static int[][] board = new int[19][19];
    static int[] dr = { 0, 1, 1, -1 };
    static int[] dc = { 1, 0, 1, 1 };

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

        for (int i = 0; i < 19; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine(), " ");
            for (int j = 0; j < 19; j++) {
                board[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        for (int i = 0; i < 19; i++) {
            for (int j = 0; j < 19; j++) {
                if (board[i][j] != 0) {
                    if (isFive(i, j)) {
                        System.out.println(board[i][j]);
                        System.out.println((i + 1) + " " + (j + 1));
                        return;
                    }
                }
            }
        }
        System.out.println(0);
    }

    static boolean isFive(int x, int y) {
        int color = board[x][y];

        for (int i = 0; i < 4; i++) {
            int cnt = 1;
            int r = x + dr[i];
            int c = y + dc[i];

            while (isValid(r, c) && board[r][c] == color) {
                cnt++;
                r += dr[i];
                c += dc[i];
            }

            r = x - dr[i];
            c = y - dc[i];

            while (isValid(r, c) && board[r][c] == color) {
                cnt++;
                r -= dr[i];
                c -= dc[i];
            }

            if (cnt == 5) {
                if (!isValid(x - dr[i], y - dc[i]) || board[x - dr[i]][y - dc[i]] != color) {
                    return true;
                }
            }
        }
        return false;
    }

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

코테스터디 TIL

2025.02.06 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 13일차 TIL (미들러)

99클럽 코테 스터디 13일차 TIL (미들러)

문제: 2529번 부등호 문제예제// input9> > > 풀이방법이 문제에서는 주어진 부등호 조건을 만족하는 숫자 조합 중 최댓값과 최솟값을 구하는 것이다. 단, 0 ~ 9 사이의 숫자는 한번씩만 사용이 가

become-programmer.tistory.com

2025.02.05 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 12일차 TIL (미들러)

99클럽 코테 스터디 12일차 TIL (미들러)

문제: 1051번 숫자 정사각형예제// input3 5421012210022101// output9 풀이방법11일차 문제를 풀어보니 이 문제는 완전탐색으로 풀어야 할 것 같았다. 왜냐하면 입력 값의 최대가 50으로 완전 탐색으로도

become-programmer.tistory.com

99클럽 코테 스터디 13일차 TIL (미들러)

yeoni:) — Thu, 6 Feb 2025 09:51:27 +0900

문제: 2529번 부등호 문제

예제

// input
9
> < < < > > > < <

// output
9567843012
1023765489

풀이방법

이 문제에서는 주어진 부등호 조건을 만족하는 숫자 조합 중 최댓값과 최솟값을 구하는 것이다. 단, 0 ~ 9 사이의 숫자는 한번씩만 사용이 가능하다는 조건이 있다. 백트래킹(DFS) 알고리즘을 활용하면 가능한 모든 숫자의 조합을 탐색할 수 있다.

1. 백트래킹

static void dfs(String num, int depth) {
    if (depth == k + 1) { // 숫자가 k+1개가 되면 종료
        results.add(num);
        return;
    }

    for (int i = 0; i < 10; i++) { // 0~9 숫자 중 선택
        if (!visited[i]) { // 사용하지 않은 숫자만 선택
            if (depth == 0 || check(num.charAt(depth - 1) - '0', i, signs[depth - 1])) {
                visited[i] = true; // 숫자 사용 체크
                dfs(num + i, depth + 1); // 재귀 호출 (다음 숫자 탐색)
                visited[i] = false; // 백트래킹 (원상 복구)
            }
        }
    }
}

종료조건

숫자는 입력된 부등호의 수보다 하나 더 많아야 하므로 숫자가 k + 1개가 되면 해당 조합을 리스트에 추가하고 종료한다.

반복문

0 ~ 9까지의 숫자를 선택할 수 있기에 반복문의 범위는 이렇게 설정한다. 또한 문제의 조건이 숫자는 한번씩만 사용 가능하기에 visited 배열을 활용하여 중복되어 사용되진 않는지 확인한다.

2. 부등호 조건 체크

static boolean check(int a, int b, char sign) {
    if (sign == '<') return a < b;
    else return a > b;
}

선택된 숫자가 이전 숫자와 비교하여 부등호 조건에 만족하는지 확인한다. 만약 부등호가 '<' 라면 a(이전 숫자) < b(현재 숫자)여야 조건에 만족한다.

전체 코드

public class Main {
    static int k;
    static char[] signs;
    static boolean[] visited = new boolean[10];
    static List<String> results = new ArrayList<>();

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

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

        signs = br.readLine().replace(" ", "").toCharArray();

        dfs("", 0);

        Collections.sort(results);
        System.out.println(results.get(results.size() - 1)); // 최대값
        System.out.println(results.get(0)); // 최소값
    }

    static void dfs(String num, int depth) {
        if (depth == k + 1) {
            results.add(num);
            return;
        }

        for (int i = 0; i < 10; i++) {
            if (!visited[i]) {
                if (depth == 0 || check(num.charAt(depth - 1) - '0', i, signs[depth - 1])) {
                    visited[i] = true;
                    dfs(num + i, depth + 1);
                    visited[i] = false;
                }
            }
        }
    }

    static boolean check(int a, int b, char sign) {
        if (sign == '<')
            return a < b;
        else
            return a > b;
    }
}

코테스터디 TIL

2025.02.05 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 12일차 TIL (미들러)

99클럽 코테 스터디 12일차 TIL (미들러)

become-programmer.tistory.com

2025.02.04 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 11일차 TIL (미들러)

99클럽 코테 스터디 11일차 TIL (미들러)

문제: 1018번 체스판 다시 칠하기예제// input10 13BBBBBBBBWBWBWBBBBBBBBBWBWBBBBBBBBBWBWBWBBBBBBBBBWBWBBBBBBBBBWBWBWBBBBBBBBBWBWBBBBBBBBBWBWBWBBBBBBBBBWBWBWWWWWWWWWWBWBWWWWWWWWWWBWB// output12 풀이방법이 문제를 풀 때 최적의 값을

become-programmer.tistory.com

99클럽 코테 스터디 12일차 TIL (미들러)

yeoni:) — Wed, 5 Feb 2025 09:48:29 +0900

문제: 1051번 숫자 정사각형

예제

// input
3 5
42101
22100
22101

// output
9

풀이방법

11일차 문제를 풀어보니 이 문제는 완전탐색으로 풀어야 할 것 같았다. 왜냐하면 입력 값의 최대가 50으로 완전 탐색으로도 해결가능할 것이라 생각했고 모든 경우의 수를 다 탐색해야 하기 때문이다.

1. 완전 탐색

2. 꼭짓점의 수가 동일한지 확인하기

1. 완전 탐색

for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
        checkSquare(i, j);
        if (max == n * m) {
            System.out.println(max);
            return;
        }
    }
}

직사각형에서 시작점이 되는 곳을 모두 탐색한다. 만약 저장된 정사각형의 최대 크기보다 탐색하는 직사각형의 크기가 더 크다면, 반복문을 종료하고 값을 출력한다.

2. 꼭짓점의 수가 동일한지 확인하기

static void checkSquare(int x, int y) {
    for (int i = 1; x + i < n && y + i < m; i++) {
        if (rectangle[x][y] == rectangle[x + i][y]
                && rectangle[x][y] == rectangle[x][y + i]
                && rectangle[x][y] == rectangle[x + i][y + i]) {
            max = Math.max(max, (i + 1) * (i + 1));
        }
    }
}

반복문은 현재의 직사각형 범위를 넘어가면 종료된다. 조건문을 통하여 각 꼭짓점의 값을 비교하고 모든 꼭짓점의 크기가 동일하다면 해당 크기를 저장된 최대 크기와 비교하여 저장한다.

전체코드

public class Main {
    static int n;
    static int m;
    static int[][] rectangle;
    static int max = 1;

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

        String[] size = br.readLine().split(" ");
        n = Integer.parseInt(size[0]);
        m = Integer.parseInt(size[1]);

        rectangle = new int[n][m];

        for (int i = 0; i < n; i++) {
            String str = br.readLine();
            for (int j = 0; j < m; j++) {
                rectangle[i][j] = str.charAt(j) - '0';
            }
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                checkSquare(i, j);
                if (max == n * m) {
                    System.out.println(max);
                    return;
                }
            }
        }

        System.out.println(max);
    }

    static void checkSquare(int x, int y) {
        for (int i = 1; x + i < n && y + i < m; i++) {
            if (rectangle[x][y] == rectangle[x + i][y]
                    && rectangle[x][y] == rectangle[x][y + i]
                    && rectangle[x][y] == rectangle[x + i][y + i]) {
                max = Math.max(max, (i + 1) * (i + 1));
            }
        }
    }
}

코테스터디 TIL

2025.02.04 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 11일차 TIL (미들러)

99클럽 코테 스터디 11일차 TIL (미들러)

become-programmer.tistory.com

2025.01.30 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 10일차 TIL (미들러)

99클럽 코테 스터디 10일차 TIL (미들러)

문제: 2573번 빙산예제// Input5 70 0 0 0 0 0 00 2 4 5 3 0 00 3 0 2 5 2 00 7 6 2 4 0 00 0 0 0 0 0 0// Output2 풀이방법먼저 문제를 이해하기 위해 ChatGPT 도움을 받았다. 배열에서의 0은 바닷물을 뜻하고 다른 수는

become-programmer.tistory.com

99클럽 코테 스터디 11일차 TIL (미들러)

yeoni:) — Tue, 4 Feb 2025 10:28:09 +0900

문제: 1018번 체스판 다시 칠하기

예제

// input
10 13
BBBBBBBBWBWBW
BBBBBBBBBWBWB
BBBBBBBBWBWBW
BBBBBBBBBWBWB
BBBBBBBBWBWBW
BBBBBBBBBWBWB
BBBBBBBBWBWBW
BBBBBBBBBWBWB
WWWWWWWWWWBWB
WWWWWWWWWWBWB

// output
12

풀이방법

이 문제를 풀 때 최적의 값을 출력하려면 두가지를 고려해야 한다.

1. 8 * 8 체스판 만들기

2. 검은색으로 시작할지 흰색으로 시작할지 정하기

1. 8 * 8 체스판 만들기

먼저 8 * 8 체스판을 만들 수 있는 모든 경우의 수를 다 계산해야 한다.

for (int i = 0; i <= n - 8; i++) {
    for (int j = 0; j <= m - 8; j++) {
        checkBoard(i, j);
    }
}

8 * 8 체스판을 만들기 위해서 입력된 n, m에서 -8을 빼서 시작점을 알아내야 한다. 만약 입력된 n, m의 값이 8, 8 이라면, 시작점은 오직 0, 0 밖에 존재하지 않지만 입력 값이 n, m이 8,9라면 시작점은 [0,0], [0,1] 이 될 수 있다.

2. 검은색으로 시작할지 흰색으로 시작할지 정하기

private static void checkBoard(int x, int y) {
    // 'W'로 시작하는 체스판과 비교할 때 다시 칠해야 하는 개수
    int repaintW = 0;
    // 'B'로 시작하는 체스판과 비교할 때 다시 칠해야 하는 개수
    int repaintB = 0;

    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            if ((i + j) % 2 == 0) {
                if (board[x + i][y + j] != 'W')
                    repaintW++;
                if (board[x + i][y + j] != 'B')
                    repaintB++;
            } else {
                if (board[x + i][y + j] != 'B')
                    repaintW++;
                if (board[x + i][y + j] != 'W')
                    repaintB++;
            }
        }
    }
    min = Math.min(min, Math.min(repaintW, repaintB));
}

시작점을 알아냈다면 어떤 값이 시작점에 존재하는 지에 따라 다시 칠해야 하는 정사각형의 개수가 달라진다.

repaintW, repaintB

해당 변수는 검은색으로 시작하는 체스판과 흰색으로 시작하는 체스판에서 다시 칠해야 하는 정사각형의 개수를 저장한다.

반복문

짝수 칸의 경우와 홀수 칸의 경우를 나누어 조건문을 설정한다. 즉, (i + j) % 2 == 0이면 기준 칸과 같은 색이어야 하고, !=이면 반대 색이어야 한다. 흰색으로 시작할 경우와 검은색으로 시작할 경우를 나누어 각각 다시 칠해야 하는 개수를 저장한다.

마지막에는 모든 체스판을 탐색한 후의 다시 칠해야 하는 정사각형의 최소개수 저장한다.

전체코드

public class Main {
    static char[][] board;
    static int n, m;
    static int min = Integer.MAX_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());
        board = new char[n][m];

        for (int i = 0; i < n; i++) {
            board[i] = br.readLine().toCharArray();
        }

        for (int i = 0; i <= n - 8; i++) {
            for (int j = 0; j <= m - 8; j++) {
                checkBoard(i, j);
            }
        }

        System.out.println(min);
    }

    private static void checkBoard(int x, int y) {
        int repaintW = 0;
        int repaintB = 0;

        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                if ((i + j) % 2 == 0) {
                    if (board[x + i][y + j] != 'W')
                        repaintW++;
                    if (board[x + i][y + j] != 'B')
                        repaintB++;
                } else {
                    if (board[x + i][y + j] != 'B')
                        repaintW++;
                    if (board[x + i][y + j] != 'W')
                        repaintB++;
                }
            }
        }
        min = Math.min(min, Math.min(repaintW, repaintB));
    }
}

코테스터디 TIL

2025.01.30 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 10일차 TIL (미들러)

99클럽 코테 스터디 10일차 TIL (미들러)

become-programmer.tistory.com

2025.01.23 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 9일차 TIL (미들러)

99클럽 코테 스터디 9일차 TIL (미들러)

문제: 백준 1707번 이분 그래프예제// Input23 21 32 34 41 22 33 44 2// OutputYESNO 풀이방법문제를 읽어보니 이해가 되지 않아 ChatGPT에게 초등학생도 이해하기 쉽게 설명해 달라고 했다. GPT는 노드를 집,

become-programmer.tistory.com

99클럽 코테 스터디 10일차 TIL (미들러)

yeoni:) — Thu, 30 Jan 2025 13:44:01 +0900

문제: 2573번 빙산

예제

// Input
5 7
0 0 0 0 0 0 0
0 2 4 5 3 0 0
0 3 0 2 5 2 0
0 7 6 2 4 0 0
0 0 0 0 0 0 0

// Output
2

풀이방법

먼저 문제를 이해하기 위해 ChatGPT 도움을 받았다. 배열에서의 0은 바닷물을 뜻하고 다른 수는 빙산의 높이를 뜻한다. 해마다 빙산의 크기는 상하좌우의 바닷물 개수마다 줄어드는데, 이때 우리가 구할 것은 빙산이 두 덩이로 나누어지는 년도를 구해야한다.

문제를 이해하고 풀 때에는 DFS/BFS로 구현해서 변경된 빙산의 높이를 구하면 될 것이라 생각했다. 하지만 거듭해서 실패를 맛보고 막막함이 몰려왔다. 따라서 난 또 ChatGPT에게 도움을 구했다.

이 문제는 단순히 그래프 알고리즘으로 풀고 끝나는 것이 아니라 고려 해야 할 상황이 더 있다.

1. 빙산을 녹이기 이전에 빙산 덩어리 개수를 구하기

2. 빙산을 녹일 때 한번에 변경된 값을 적용하기

1. 빙산을 녹이기 이전에 빙산 덩어리 개수를 구하기

private static int countIcebergs() {
    boolean[][] visited = new boolean[n][m];
    int count = 0;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (ice[i][j] > 0 && !visited[i][j]) {
                bfs(i, j, visited);
                count++;
            }
        }
    }
    return count;
}

private static void bfs(int i, int j, boolean[][] visited) {
    Queue<int[]> q = new LinkedList<>();
    q.offer(new int[] { i, j });
    visited[i][j] = true;

    while (!q.isEmpty()) {
        int[] cur = q.poll();

        for (int f = 0; f < 4; f++) {
            int r = cur[0] + dr[f];
            int c = cur[1] + dc[f];

            if (r >= 0 && r < n && c >= 0 && c < m && !visited[r][c] && ice[r][c] > 0) {
                q.offer(new int[] { r, c });
                visited[r][c] = true;
            }
        }

    }
}

빙산을 녹이기 이전에 빙산의 개수가 몇 개인지 확인이 필요하다. 이를 위해서는 그래프 알고리즘인 DFS/BFS를 활용할 수 있다. 왜냐하면 bfs() 메서드는 상하좌우로 연결된 빙산을 모두 확인하기에 count가 2번 이상 돌게 될 경우 빙산이 두 덩이 이상이라는 것을 알 수 있기 때문이다.

bfs()메서드에서는 상하좌우를 모두 탐색해야 하기 때문에 해당 배열의 값(r, c)이 배열 범위 내에 있는지 확인해야 하며 이미 방문하지 않았는지, 배열의 값이 0보다 큰지를 확인해야 한다. 만약 조건에 만족한다면 Queue에 해당 배열의 위치 값을 저장하고 방문 여부를 true로 변경해준다.

2. 빙산을 녹일 때 한번에 변경된 값을 적용하기

private static void meltIce() {
    int[][] temp = new int[n][m];

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (ice[i][j] > 0) {
                int waterCount = 0;

                for (int f = 0; f < 4; f++) {
                    int r = i + dr[f];
                    int c = j + dc[f];

                    if (r >= 0 && r < n && c >= 0 && c < m && ice[r][c] == 0) {
                        waterCount++;
                    }
                }
                temp[i][j] = Math.max(0, ice[i][j] - waterCount);
            }
        }
    }

    for (int i = 0; i < n; i++) {
        System.arraycopy(temp[i], 0, ice[i], 0, m);
    }
}

처음 이 코드를 접했을 때는 왜 임시배열을 만들어 한번에 변경된 빙산의 높이를 적용하는 건지 이해를 하지 못했다. 바로 적용하면 되는데 왜 쓸데없이 메모리 공간을 차지하는 거지라는 생각이었다. 하지만 코드를 이렇게 작성하는 건 이유가 있었다. 만약 변경된 빙산 높이의 값을 즉시 적용해버리면 아직 방문하지 않은 빙산의 높이가 올바르지 않게 변경될 수 있기 때문이다.

예시를 들어 아래와 같은 배열이 있다고 가정하자

0 0 0 0 0
1 1 2 1 0
0 4 1 0 0

반복문을 돌아 i = 1, j = 1이 되었다. 현재 ice[1][1]의 값 1 이지만 ice[0][1]가 0(바닷물)이기에 빙산을 높이를 바로 적용하면 ice[1][1]의 값은 0이 된다.

이후 i = 1, j = 2일 때 변경된 빙산의 높이는 1 (상단에 바닷물 하나)이어야 하지만, ice[1][2]의 값은 ice[1][1]이 즉시 적용되었기 때문에 0이 돼버린다. 이러한 오류를 범하고자 임시배열을 만들어 한번에 적용해야 하는 것이다.

전체코드

public class Main {
    static int n, m;
    static int[][] ice;
    static int[] dr = { -1, 1, 0, 0 };
    static int[] dc = { 0, 0, -1, 1 };

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

        String[] input = br.readLine().split(" ");
        n = Integer.parseInt(input[0]);
        m = Integer.parseInt(input[1]);

        ice = new int[n][m];

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

        int year = 0;

        while (true) {
            int count = countIcebergs();

            if (count >= 2) {
                System.out.println(year);
                break;
            } else if (count == 0) {
                System.out.println(0);
                break;
            }

            meltIce();
            year++;

        }
    }

    private static int countIcebergs() {
        boolean[][] visited = new boolean[n][m];
        int count = 0;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (ice[i][j] > 0 && !visited[i][j]) {
                    bfs(i, j, visited);
                    count++;
                }
            }
        }
        return count;
    }

    private static void bfs(int i, int j, boolean[][] visited) {
        Queue<int[]> q = new LinkedList<>();
        q.offer(new int[] { i, j });
        visited[i][j] = true;

        while (!q.isEmpty()) {
            int[] cur = q.poll();

            for (int f = 0; f < 4; f++) {
                int r = cur[0] + dr[f];
                int c = cur[1] + dc[f];

                if (r >= 0 && r < n && c >= 0 && c < m && !visited[r][c] && ice[r][c] > 0) {
                    q.offer(new int[] { r, c });
                    visited[r][c] = true;
                }
            }

        }
    }

    private static void meltIce() {
        int[][] temp = new int[n][m];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (ice[i][j] > 0) {
                    int waterCount = 0;

                    for (int f = 0; f < 4; f++) {
                        int r = i + dr[f];
                        int c = j + dc[f];

                        if (r >= 0 && r < n && c >= 0 && c < m && ice[r][c] == 0) {
                            waterCount++;
                        }
                    }
                    temp[i][j] = Math.max(0, ice[i][j] - waterCount);
                }
            }
        }

        for (int i = 0; i < n; i++) {
            System.arraycopy(temp[i], 0, ice[i], 0, m);
        }
    }
}

코테스터디 TIL

2025.01.23 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 9일차 TIL (미들러)

99클럽 코테 스터디 9일차 TIL (미들러)

become-programmer.tistory.com

2025.01.23 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 8일차 TIL (미들러)

99클럽 코테 스터디 8일차 TIL (미들러)

문제: 백준 2667번 단지번호 붙이기 예제// Input70110100011010111101010000111010000001111100111000// Output3789 풀이방법이 문제에서는 다른 알고리즘보다는 DFS가 문제를 풀기에 적합해보였다. DFS는 깊이를 우

become-programmer.tistory.com

백준 32953번 회상

yeoni:) — Sat, 25 Jan 2025 07:42:57 +0900

문제

풀이방법

노교수의 수업을 들었던 학생들 중 M개 이상 들은 학생이 몇 명인지 알아내는 문제이다. 이 문제를 보자마자 Map 자료 구조가 떠올랐고 배열은 어려울 것 같다는 생각이 들었다. 배열로 구성하게 되면 학번의 숫자가 8개이기 때문에 자료 범위가 엄청 큰 배열을 생성해야 하는데, 그렇게 되면 성능이 좋지 못할 것이라 생각이 들었기 때문이다.

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

        String[] input = br.readLine().split(" ");
        int n = Integer.parseInt(input[0]);
        int m = Integer.parseInt(input[1]);

        Map<Integer, Integer> map = new HashMap<>();
        while(n-- > 0){
            int k = Integer.parseInt(br.readLine());
            
            StringTokenizer st = new StringTokenizer(br.readLine(), " ");
            for(int i = 0; i < k; i++){
                int num = Integer.parseInt(st.nextToken());
                map.put(num, map.getOrDefault(num, 0) + 1);
            }
        }

        int count = 0;
        for(int val: map.values()){
            if(val >= m) count++;
        }
        System.out.println(count);
    }
}

소스 코드는 비교적 간단하다. 입력 값을 각 변수에 저장하고 모든 수업을 들은 학생들 학번을 map의 Key로 저장한다. Value 값은 해당 학생이 다른 수업을 들을 경우에는 1씩 증가하도록 하였다.

while문이 종료된 후 map의 value가 주어진 m보다 크거나 같다면 count를 증가시키고 해당 값을 출력하였다.

99클럽 코테 스터디 9일차 TIL (미들러)

yeoni:) — Thu, 23 Jan 2025 15:38:27 +0900

문제: 백준 1707번 이분 그래프

예제

// Input
2
3 2
1 3
2 3
4 4
1 2
2 3
3 4
4 2

// Output
YES
NO

풀이방법

문제를 읽어보니 이해가 되지 않아 ChatGPT에게 초등학생도 이해하기 쉽게 설명해 달라고 했다. GPT는 노드를 집, 엣지를 길에 비유하였고 연결된 집이 같은 색으로 칠해지지 않을 경우 이분 그래프라고 하였다.

예를 들자면

- 1번 집(파란색), 2번 집(빨간색)이 순서대로 연결되었다면? 이분 그래프

- 1번 집(파란색), 2번 집(빨간색), 3번집(파란색)이 순서대로 연결되었다면? 이분그래프

- 1번 집(파란색), 2번 집(파란색), 3번집(빨간색)이 순서대로 연결되었다면? 이분그래프가 아님!

문제를 이해하고 나서 이 문제를 보니 최단 경로를 찾는 문제도 아니고 경로 탐색이 중요한 문제가 아니라서 DFS나 BFS 중 아무 알고리즘이나 가능할 것 같다는 생각이 들었다.

코드를 작성하기 전에 n, v, e을 제외하고 어떤 변수가 있어야 할까 고민을 해봤다.

- ArrayList<Integer>[]: 입력된 그래프 저장

- color[]: 방문 여부(-1이라면 미방문 상태를 나타나며 초기값으로 ) 및 색상 구분(0은 빨강, 1은 파랑)

- isBiPartite: 이분 그래프 여부(초기값 true)

1. 입력 값 셋팅 및 초기값 설정

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = Integer.parseInt(br.readLine()); // 테스트 케이스 수

while (t-- > 0) {
    String[] input = br.readLine().split(" ");
    int v = Integer.parseInt(input[0]); // 노드 수
    int e = Integer.parseInt(input[1]); // 간선 수

    // 그래프 초기화
    ArrayList<Integer>[] graph = new ArrayList[v + 1];
    for (int i = 1; i <= v; i++) {
        graph[i] = new ArrayList<>();
    }

    // 간선 입력
    for (int i = 0; i < e; i++) {
        String[] edge = br.readLine().split(" ");
        int u = Integer.parseInt(edge[0]);
        int vNode = Integer.parseInt(edge[1]);
        graph[u].add(vNode);
        graph[vNode].add(u);
    }

    // 색깔 배열 초기화 (-1: 미방문, 0: 빨강, 1: 파랑)
    int[] color = new int[v + 1];
    Arrays.fill(color, -1);
...
}

입력 값 저장 및 그래프 초기화

테스트 케이스 값을 입력받고 그 수만큼 반복문을 실행한다. 반복문 내에서 노드와 간선 수를 입력받아 저장한 뒤, 그래프를 초기화한다.

노드 값 그래프 저장

입력받은 간선을 그래프에 저장하는데, 양방향 연결이 되도록 앞 뒤 노드 값 모두에 연결된 노드 값을 add()한다.

색깔 배열 초기화

방문 여부 및 이분 그래프 판별을 위한 배열을 초기화해준다. 초기값은 -1로 하여 미방문 상태를 나타내었다.

2. 그래프 노드 탐색

// 이분 그래프 여부 판단 변수
boolean isBipartite = true;

// 모든 노드 탐색
for(int i = 1; i <= v; i++){
    if(color[i] == -1) {
        if(!search(i, nums, color)){
            isBipartite = false;
            break; // 이분 그래프 아니라면 종료
        }
    }
}

isBipartite

이분 그래프 여부를 판단하는 isBipartite 변수를 선언하고 초기값을 true로 설정한다.

모든 노드 탐색

연결되어 있지 않은 그래프도 포함하고 있기에 반복문을 사용해서 모든 노드를 탐색한다. 만약 해당 노드가 미방문 상태라면 search() 함수를 실행하는데, 해당 함수는 이분 그래프 여부를 판단하는 값을 리턴한다. 이 리턴 값이 false라면 isBipartite도 false로 설정하고 즉시 해당 반복문을 종료한다.

3. search() 함수: DFS

private static boolean search(int idx, ArrayList<Integer>[] nums, int[] color){
    Stack<Integer> stack = new Stack<>();
    stack.push(idx);
    color[idx] = 0;

    while(!stack.isEmpty()){
        int cur = stack.pop();

        for(int next:nums[cur]){
            if(color[next] == -1){
                color[next] = 1 - color[cur];
                stack.push(next);
            }else if(color[next] == color[cur]){
                return false;
            }
        }
    }
    return true;
}

Stack

DFS로 구현하였기 때문에 Stack를 생성하여 초기값을 push 하였다. 그리고 해당 color 값은 0으로 지정하였다.

while문

stack에 들어있는 값을 꺼내주고 해당 노드와 연결되는 모든 노드를 탐색한다. 노드 중 방문하지 않은 노드가 있다면, color의 값을 현재 값과 다른 값으로 변경해 주고 stack에 push 해준다.

이미 방문한 노드라면 현재 노드의 color와 연결된 노드의 color가 동일한지 확인한다. 만약 동일하다면 이분 그래프가 아니므로 false를 리턴한다.

4. BFS로 구현할 경우

private static boolean bfs(int start, ArrayList<Integer>[] graph, int[] color) {
    Queue<Integer> queue = new LinkedList<>();
    queue.offer(start);
    color[start] = 0; 

    while (!queue.isEmpty()) {
        int cur = queue.poll();

        for (int next : graph[cur]) {
            if (color[next] == -1) { 
                color[next] = 1 - color[cur]; 
                queue.offer(next);
            } else if (color[next] == color[cur]) {
                return false;
            }
        }
    }
    return true;
}

DFS랑 다른 부분은 queue로 구현했다는 점이다.

전체 코드

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        StringBuilder sb = new StringBuilder();

        while(t-- > 0){
            String[] input = br.readLine().split(" ");
            int v = Integer.parseInt(input[0]);
            int e = Integer.parseInt(input[1]);
            ArrayList<Integer>[] nums = new ArrayList[v+1];

            for(int i = 1; i <= v; i++){
                nums[i] = new ArrayList<>();
            }

            int[] color = new int[v + 1];
            Arrays.fill(color, -1);

            for(int i = 0; i < e; i++){
                String[] nodes = br.readLine().split(" ");
                int one = Integer.parseInt(nodes[0]);
                int two = Integer.parseInt(nodes[1]);

                nums[one].add(two);
                nums[two].add(one);
            }

            boolean isBipartite = true;

            for(int i = 1; i <= v; i++){
                if(color[i] == -1) {
                    if(!search(i, nums, color)){
                        isBipartite = false;
                        break;
                    }
                }
            }
            sb.append(isBipartite ? "YES":"NO").append("\n");
        }
        System.out.println(sb);
    }

    private static boolean search(int idx, ArrayList<Integer>[] nums, int[] color){
        Stack<Integer> stack = new Stack<>();
        stack.push(idx);
        color[idx] = 0;

        while(!stack.isEmpty()){
            int cur = stack.pop();

            for(int next:nums[cur]){
                if(color[next] == -1){
                    color[next] = 1 - color[cur];
                    stack.push(next);
                }else if(color[next] == color[cur]){
                    return false;
                }
            }
        }
        return true;
    }
}

코드를 짤 때 어려웠던 부분은 while문 내에서 조건문을 올바르게 작성하지 않아 이분 그래프를 판단하는 부분이 어려웠다. 그리고 연결된 노드의 색상을 어떻게 다르게 칠할 것인지에 대해 고민을 했다. 여러 도움으로 구분할 수 있는 방법을 알게 되었는데 color[next] = 1 - color[cur] 라는 코드가 너무 간단해 허탈하기도 했다.

나날이 어려운 문제를 풀이하면서 생각의 깊이가 달라지는 것 같고 사람이 가진 생각을 코드로 구현하는 것은 단순하지 않다는 걸 알게 되었다.

코테스터디 TIL

2025.01.23 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 8일차 TIL (미들러)

99클럽 코테 스터디 8일차 TIL (미들러)

become-programmer.tistory.com

2025.01.21 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 7일차 TIL (미들러)

99클럽 코테 스터디 7일차 TIL (미들러)

문제: 백준 1697번 숨박꼭질 풀이 방법1. 이진 탐색(실패)2. BFS 1. 이진탐색(실패)어떤 알고리즘으로 이 문제를 구현할 수 있을까 고민했다. 경로라는 것을 생각하지 않고 조건에 만

become-programmer.tistory.com

React란?

yeoni:) — Thu, 23 Jan 2025 13:32:30 +0900

React가 무엇인가?

- 사용자 인터페이스를 만들기 위한 Javascript 라이브러리

프레임워크는 개발을 위한 기본 틀 및 뼈대 라면, 라이브러리란 개발에 필요한 도구 또한 그 집합을 의미한다.

- SPA(Single Page Application)

클라이언트(브라우저)에서 화면을 그리는 방식으로 JavaScript를 통해 HTMl 작성한다.

React 외에 Vue, Angular 등이 존재한다.

왜 배워야 하는가?

1. 트렌드

- 수요가 많고 방대한 생태계를 가지고 있다.

2. 편리함

- 유용한 라이브러리가 많이 존재한다.

- SPA: 싱글 페이지 어플리케이션으로 서버에 부하가 적다.

- 화면을 여러 단위로 쪼개고, 재사용하는 식으로 코드 관리가 용이하다는 장점을 가진다.

React 특징

1. 컴포넌트 기반 설계

- 스스로 상태를 관리하는 캡슐화된 코드 조각으로 의미단위로 컴포넌트를 구성하는 것이다. 이 방법은 재사용성과 유지보수성이 좋다.

- 컴포넌트는 부모, 자식 관계를 가진다는 특징을 갖고 있다.

2. Virtual DOM(가상돔)

- 실제 DOM의 복사본으로 SPA에서의 동적인 변화를 효율적으로 관리하기 위해 사용한다.

- DOM을 직접 변경하여 발생하는 비효율을 해결할 수 있다.

3. CSR(Client Side Rendering)

- SPA 방식이기에 자바스트립트를 통해 서버가 아닌 클라이언트 브라우저에서 화면을 렌더링 하게 된다.

4. 풍부한 생태계

- 단순 웹 개발뿐만 아니라 React Native와 같은 앱 개발을 위한 라이브러리도 존재한다.

99클럽 코테 스터디 8일차 TIL (미들러)

yeoni:) — Thu, 23 Jan 2025 09:22:03 +0900

문제: 백준 2667번 단지번호 붙이기

예제

풀이방법

이 문제에서는 다른 알고리즘보다는 DFS가 문제를 풀기에 적합해보였다. DFS는 깊이를 우선으로 탐색하며, 한 경로를 끝까지 진행한 뒤 다시 돌아가서 다른 경로를 탐색하기 때문에 연결된 모든 집의 개수를 구할 수 있다고 생각했다.

1. 첫번째 시도(실패)

2. 두번째 시도(성공)

1. 첫번째 시도(실패)

package codingstudy.day8;

import java.io.BufferedReader;
public class Main {
    static int[][] map;
    static boolean[][] visited;
    static List<Integer> list = new ArrayList<>();
    
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        map = new int[n][n];

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

        StringBuilder sb = new StringBuilder();

        visited = new boolean[n][n];
        int[] dr = {-1, +1, 0, 0};
        int[] dc = {0, 0, -1, +1};


        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(!visited[i][j])dfs(i, j, n, dr, dc);
            }
        }

        Collections.sort(list);
        sb.append(list.size()).append("\n");
        for(int i : list){
            sb.append(i).append("\n");
        }
        System.out.println(sb);
        
    }

    private static void dfs(int row, int col, int n, int[] dr, int[] dc){
        Stack<int[]> stack = new Stack<>();

        stack.push(new int[]{row,col});
        visited[row][col] = true;
        int count = 0;

        while(!stack.isEmpty()){
            int[] cur = stack.pop();
            int first = cur[0];
            int second = cur[1];
            for(int i = 0; i < 4; i++){
                int f = first + dr[i];
                int s = second + dc[i];
                if(f >= 0 && f < n && s >= 0 && s < n && map[f][s] == 1 && !visited[f][s]){
                    count++;
                    stack.push(new int[]{f, s});
                    visited[f][s] = true;
                }
            }
        }
        
        if(count != 0) list.add(count);

    }
}

모든 수를 map[][] 배열에 저장하고 4방향(위, 아래, 좌, 우)를 탐색하기 위하여 dr, dc 배열을 만들었다. 반복문을 활용하여 모든 경우를 다 탐색하기로 하였고 DFS를 구현하기 위해 Stack를 사용하였다.

Stack이 비어 있을 때까지 탐색을 이어나가고 한 단지를 다 탐색했다면, count 값을 List에 저장하도록 하였다. 반복문이 종료되면 List를 오름차순으로 정렬하고 List의 사이즈 값과 단지마다 집의 개수를 출력하도록 했다.

예제 Output과 동일한 값이 출력되길래 제대로 코드를 구현한 줄 알았지만, 실패했다는 메세지가 떴다.

2. 두번째 시도(성공)

위의 코드가 실패한 원인이 뭔지 찾아보았다. 문제는 두 가지였다.

- 반복문으로 모든 경우의 수를 탐색할 때 해당 배열의 값이 1인지 확인하지 않는 것

for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++){
        if(!visited[i][j] && map[i][j] == 1)dfs(i, j, n, dr, dc);
    }
}

모든 경우의 수를 탐색할 때는 방문 여부 뿐만 아니라 해당 위치의 값이 1(집)인지 아닌지 확인 후 DFS() 메서드를 호출해야 했었다. 하지만 위의 코드에서는 오직 방문 여부만 판단하고 DFS()를 호출했기 떄문에 오류가 발생했다.

- 스택에서 시작노드의 개수를 count에 포함시키지 않은 것

private static void dfs(int row, int col, int n, int[] dr, int[] dc){
    Stack<int[]> stack = new Stack<>();

    stack.push(new int[]{row,col});
    visited[row][col] = true;
    int count = 1;

    while(!stack.isEmpty()){
        int[] cur = stack.pop();
        int first = cur[0];
        int second = cur[1];
        for(int i = 0; i < 4; i++){
            int f = first + dr[i];
            int s = second + dc[i];
            if(f >= 0 && f < n && s >= 0 && s < n && map[f][s] == 1 && !visited[f][s]){
                count++;
                stack.push(new int[]{f, s});
                visited[f][s] = true;
            }
        }
    }
    if(count > 0) list.add(count);
}

Stack를 생성하고 시작노드를 제외하고 이웃노드만 count를 하였다. 이렇게 되면 다른 테스트 코드에서 집의 개수가 잘못 출력되었을 것이다. 이에 따라 count의 초기값을 1로 설정하여 시작노드를 포함하도록 하였다.

전체코드

public class Main {
    static int[][] map;
    static boolean[][] visited;
    static List<Integer> list = new ArrayList<>();
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        map = new int[n][n];

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

        StringBuilder sb = new StringBuilder();

        visited = new boolean[n][n];
        int[] dr = {-1, +1, 0, 0};
        int[] dc = {0, 0, -1, +1};


        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(!visited[i][j] && map[i][j] == 1)dfs(i, j, n, dr, dc);
            }
        }

        Collections.sort(list);
        sb.append(list.size()).append("\n");
        for(int i : list){
            sb.append(i).append("\n");
        }
        System.out.println(sb);
        
    }

    private static void dfs(int row, int col, int n, int[] dr, int[] dc){
        Stack<int[]> stack = new Stack<>();

        stack.push(new int[]{row,col});
        visited[row][col] = true;
        int count = 1;

        while(!stack.isEmpty()){
            int[] cur = stack.pop();
            int first = cur[0];
            int second = cur[1];
            for(int i = 0; i < 4; i++){
                int f = first + dr[i];
                int s = second + dc[i];
                if(f >= 0 && f < n && s >= 0 && s < n && map[f][s] == 1 && !visited[f][s]){
                    count++;
                    stack.push(new int[]{f, s});
                    visited[f][s] = true;
                }
            }
        }
        
        if(count > 0) list.add(count);

    }
}

문제의 조건을 꼼꼼히 분석하고 정리하는 습관이 필요할 것 같다.

코테스터디 TIL

2025.01.21 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 7일차 TIL (미들러)

99클럽 코테 스터디 7일차 TIL (미들러)

become-programmer.tistory.com

2025.01.20 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 6일차 TIL (미들러)

99클럽 코테 스터디 6일차 TIL (미들러)

문제: 백준 1260번 DFS와 BFS예제// Input5 5 35 45 21 23 43 1// Output3 1 2 5 43 1 4 2 5 풀이 방법DFS, BFS를 구현할 줄 알면 어려운 문제는 아니다.문제 풀이할 때 주의할 점이라고 하면, 방문할 수 있는 정점이

become-programmer.tistory.com

99클럽 코테 스터디 7일차 TIL (미들러)

yeoni:) — Tue, 21 Jan 2025 16:55:42 +0900

문제: 백준 1697번 숨박꼭질

풀이 방법

1. 이진 탐색(실패)
2. BFS

1. 이진탐색(실패)
어떤 알고리즘으로 이 문제를 구현할 수 있을까 고민했다. 경로라는 것을 생각하지 않고 조건에 만족만 하면 되지 않을까 싶어서다. 탐색할 범위를 지정하고 나니 어떻게 타겟을 구해야 할지 막막했다. 그 이유는 이 문제는 이동 경로가 총 세가지( +1, -1, *2)경우이기 때문에 이동 시간을 계산하기 어렵기 때문이다.

즉, 이진 탐색은 특정 시간인 mid 값 내에서 n -> k 에서 갈 수 있는지 판단해야 하는데 이렇게 되면 결국 모든 이동 경로를 탐색해야 하는 상황이 된다.

2. BFS
이 문제는 수빈이가 동생을 찾을 수 있는 가장 빠른 시간을 구해야 한다. 즉, 빠른 경로를 찾아나서는 것이다. 모든 경로를 탐색하여 가장 빠르게 도달할 수 있는 시간을 구해야 하기 때문에 BFS 알고리즘으로 구현하기로 하였다.

BFS 알고리즘은 큐로 구현하는데 이러한 이유는 BFS 동작 원리와 큐의 자료 구조 특성이 맞기 때문이다. 무슨 말이냐면 BFS는 같은 depth의 노드들을 모두 탐색한 후 그 다음 depth의 노드들을 탐색한다. 큐의 경우 FIFO 특성으로 우선 삽입된 노드를 먼저 탐색하여 순서대로 노드를 처리한다.

이와 같이 BFS 탐색 방식과 큐의 탐색 방식(먼저 들어오는 노드대로 처리하기)이 동일하기 때문에 큐로 알고리즘을 구현하기로 하였다.

private static int bfs(int start, int target){
    int[] visited = new int[100001];
    Arrays.fill(visited, -1);

    Queue<Integer> q = new LinkedList<>();
    q.offer(start);
    visited[start] = 0;

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

        if(cur == target){
            return visited[cur];
        }

        for(int next: new int[]{cur - 1, cur + 1, cur * 2}){
            if(next >= 0 && next <= 100000 && visited[next] == -1){
                visited[next] = visited[cur] + 1;
                q.offer(next);
            }
        }
    }
    return -1;
}

int[] visited
해당 배열은 이동 시간을 저장하여 방문 여부를 확인하기 위해서다. 초기값을 -1로 준 이유는 아직 해당 노드에 방문하지 않았음을 나타내기 위함이다.

Queue<Integer> q = new LinkedList<>()
방문할 노드를 Queue에 저장한다. 수빈이의 위치는 시작 값으로써 Queue에 넣어놓는다. 그리고 visited[start] 값을 0으로 설정함으로써 시작 노드의 이동 시간(0초)을 저장한다.

while문
Queue에서 노드 하나를 가져온다. 해당 노드 값이 동생의 위치와 동일하다면, 이동 시간을 저장한 visited[cur] 값을 출력한다. 그렇지 않다면, for문을 실행한다.

for(int next: new int[]{cur - 1, cur + 1, cur * 2})
for문에서는 세가지 이동경로(+1, -1, *2)를 반복한다. 반복문 내에서는 해당 위치가 경로를 벗어나지 않고 방문하지 않았다면 visited[(cur-1 || cur+1 || cur *2)] 값을 현재 cur 이동 시간 + 1초를 더해주고 큐에 삽입한다.

return -1
문제에서는 항상 목적지에 도달할 수 있기 때문에 -1이 출력되는 상황은 없지만, 어떤 값이든 리턴해야 하는 함수 특성상 -1를 리턴하도록 하였다.

전체 코드

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

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

        String[] s = br.readLine().split(" ");
        int n = Integer.parseInt(s[0]);
        int k = Integer.parseInt(s[1]);

        System.out.println(bfs(n, k));
    }

    private static int bfs(int start, int target){
        int[] visited = new int[100001];
        Arrays.fill(visited, -1);

        Queue<Integer> q = new LinkedList<>();
        q.offer(start);
        visited[start] = 0;

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

            if(cur == target){
                return visited[cur];
            }

            for(int next: new int[]{cur - 1, cur + 1, cur * 2}){
                if(next >= 0 && next <= 100000 && visited[next] == -1){
                    visited[next] = visited[cur] + 1;
                    q.offer(next);
                }
            }
        }
        return -1;
    }
}

코테스터디 TIL

2025.01.20 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 6일차 TIL (미들러)

99클럽 코테 스터디 6일차 TIL (미들러)

become-programmer.tistory.com

2025.01.18 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 5일차 TIL (미들러)

99클럽 코테 스터디 5일차 TIL (미들러)

문제: 백준 2470번 두 용액예제// Input5-2 4 -99 -1 98// Output-99 98 풀이 방법입력되는 수의 범위가 크고, 시간제한이 있어 완전 탐색을 하게 되면 비효율적이다. 여기서는 음수와 양수의 합이 0에 가

become-programmer.tistory.com

99클럽 코테 스터디 6일차 TIL (미들러)

yeoni:) — Mon, 20 Jan 2025 21:53:57 +0900

문제: 백준 1260번 DFS와 BFS

예제

// Input
5 5 3
5 4
5 2
1 2
3 4
3 1

// Output
3 1 2 5 4
3 1 4 2 5

풀이 방법

DFS, BFS를 구현할 줄 알면 어려운 문제는 아니다.

문제 풀이할 때 주의할 점이라고 하면, 방문할 수 있는 정점이 여러 개라면 작은 수 먼저 방문해야 한다는 것이다. 이점을 고려하여 정렬만 해준다면 문제없이 풀 수 있다.

1. DFS

private static void dfs(int v){
    visited_dfs[v] = true;
    sb.append(v + " ");

    for (int i : graph[v]) {
        if(!visited_dfs[i]) dfs(i);
    }
}

파라미터 값

시작 정점 값

시작노드의 방문 여부를 true로 설정해 주고, 방문한 배열을 sb에 저장한다.

반복문에서는 해당 정점 값에서 방문할 수 있는 정점을 모두 탐색한다. 만약 방문하려는 정점을 방문하지 않았다면, dfs() 함수를 실행한다.

2. BFS

private static void bfs(int v){
    Queue<Integer> q = new LinkedList<>();
    q.offer(v);
    visited_bfs[v] = true;

    while(!q.isEmpty()){
        int cur = q.poll();
        sb.append(cur + " ");
        for(int i : graph[cur]){
            if(!visited_bfs[i]){
                q.offer(i);
                visited_bfs[i] = true;
            }
        }
    }
}

Queue<Integer>

큐는 FIFO 형식으로 BFS를 구현하기에 적합한 자료구조이다.

파라미터

파라미터 값으로 시작 정점을 받아 해당 값 q에 저장하고 방문 여부를 true로 설정해 준다.

while 반복문

q의 값이 없을 때 종료하도록 조건을 작성하고, q에 넣은 값을 하나씩 꺼내 출력 값에 저장한다. 내부에 있는 for문은 해당 정점이 방문할 수 있는 정점을 탐색하고 방문하지 않는 노드를 q에 저장하고 방문 여부를 true로 설정한다.

전체 코드

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

public class Main {
    private static ArrayList<Integer>[] graph;
    private static boolean[] visited_dfs;
    private static boolean[] visited_bfs;
    private static StringBuilder sb;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        int v = Integer.parseInt(st.nextToken());

        graph = new ArrayList[n+1];
        visited_dfs = new boolean[n+1];
        visited_bfs = new boolean[n+1];
        sb = new StringBuilder();

        for(int i = 1; i <= n; i++){
            graph[i] = new ArrayList<>();
        }

        for(int i = 0; i < m; i++){
            String[] input = br.readLine().split(" ");
            int from = Integer.parseInt(input[0]);
            int to = Integer.parseInt(input[1]);

            graph[from].add(to);
            graph[to].add(from);
        }

        for (int i = 1; i <= n; i++) {
            Collections.sort(graph[i]);
        }

        dfs(v);
        sb.append("\n");
        bfs(v);
        System.out.println(sb);
    }

    private static void dfs(int v){
        visited_dfs[v] = true;
        sb.append(v + " ");

        for (int i : graph[v]) {
            if(!visited_dfs[i]) dfs(i);
        }
    }

    private static void bfs(int v){
        Queue<Integer> q = new LinkedList<>();
        q.offer(v);
        visited_bfs[v] = true;

        while(!q.isEmpty()){
            int cur = q.poll();
            sb.append(cur + " ");
            for(int i : graph[cur]){
                if(!visited_bfs[i]){
                    q.offer(i);
                    visited_bfs[i] = true;
                }
            }
        }
    }
}

ArrayList<Integer>[]

입력 값 저장

boolean[] visited

배열로 방문 여부 저장

Collections.sort()

방문할 수 있는 정점을 오름차순으로 정렬하는 메서드

코테스터디 TIL

2025.01.18 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 5일차 TIL (미들러)

99클럽 코테 스터디 5일차 TIL (미들러)

become-programmer.tistory.com

2025.01.17 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 4일차 TIL (미들러)

99클럽 코테 스터디 4일차 TIL (미들러)

문제: 백준 2343번 기타 레슨예제// Input9 31 2 3 4 5 6 7 8 9// Output17 풀이방법이 문제는 최적의 블루레이 크기를 찾아야 한다. 가능한 블루레이 크기를 순차적으로 탐색하게 되면 비효율적이기도 하

become-programmer.tistory.com

99클럽 코테 스터디 5일차 TIL (미들러)

yeoni:) — Sat, 18 Jan 2025 08:22:26 +0900

문제: 백준 2470번 두 용액

예제

// Input
5
-2 4 -99 -1 98

// Output
-99 98

풀이 방법

입력되는 수의 범위가 크고, 시간제한이 있어 완전 탐색을 하게 되면 비효율적이다. 여기서는 음수와 양수의 합이 0에 가까운 수를 찾아야 하기 때문에 정렬 후 투포인터 알고리즘을 사용하는 게 적절하다.

1. 값 입력 받고 배열 정렬하기

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

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

Arrays.sort(nums);

2. 변수 생성하기

int i, j: 투 포인터 양 끝 점을 변수로 생성

int min: 0에 가까운 수를 저장하기 위한 변수로 초기값은 Integer 타입의 최댓값으로 지정

int[] result: 0에 가까운 두 용액을 저장하기 위한 배열

int i = 0, j = nums.length - 1;
int min = Integer.MAX_VALUE;
int[] result = new int[2];

3. 조건 생성

while문: 양 끝에서 시작하는 i, j가 서로 겹치지 않을 때까지 반복

int sum: 두 용액의 합을 저장한 변수

 while(i < j){
    int sum = nums[i] + nums[j];
    if(Math.abs(sum) < min){
        min = Math.abs(sum);
        result[0] = nums[i];
        result[1] = nums[j];
    }
    if(sum == 0) break;
    if(sum > 0) j--;
    else i++;
}

Math.abs()를 이용하여 음수인 sum 값을 절댓값으로 만들어 주어 현재까지의 최솟값인 min과 비교한다. min보다 절댓값(sum)이 작다면 min 값을 수정하고 result 배열에 해당 값들을 저장한다.

만약 sum이 0 이라면 반복문을 바로 종료하게 되고 sum이 0보다 크다면 합이 더 작아져야 하니 j 변수의 값을 줄이고 0보다 작다면 합이 커져야 하니 i 변수의 값을 증가시켜 준다.

전체 코드

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

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

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

        Arrays.sort(nums);

        int i = 0, j = nums.length - 1;
        int min = Integer.MAX_VALUE;
        int[] result = new int[2];

        while(i < j){
            int sum = nums[i] + nums[j];
            if(Math.abs(sum) < min){
                min = Math.abs(sum);
                result[0] = nums[i];
                result[1] = nums[j];
            }
            if(sum == 0) break;
            if(sum > 0) j--;
            else i++;
        }

        System.out.println(result[0] + " " + result[1]);
    }
}

코테스터디 TIL

2025.01.17 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 4일차 TIL (미들러)

99클럽 코테 스터디 4일차 TIL (미들러)

become-programmer.tistory.com

99클럽 코테 스터디 4일차 TIL (미들러)

yeoni:) — Fri, 17 Jan 2025 09:54:15 +0900

문제: 백준 2343번 기타 레슨

예제

// Input
9 3
1 2 3 4 5 6 7 8 9

// Output
17

풀이방법

이 문제는 최적의 블루레이 크기를 찾아야 한다. 가능한 블루레이 크기를 순차적으로 탐색하게 되면 비효율적이기도 하고 입력된 강의 길이의 범위가 연속적이고 정렬하기 때문에 이분 탐색을 이용해 풀이한다.

1. 이분 탐색 범위

코드를 짜며 가장 고민했던 부분은 이분 탐색의 범위였던 것 같다. 이분 탐색의 타겟 값이 블루레이 최대 크기라고 한다면, 최소값의 경우 강의 중에서 가장 긴 길이가 될 것이고, 최대값의 경우 모든 강의 길의의 합이 된다. 즉, 이분탐색의 범위는 max(lessons) ~ sum(lessons) 인 것이다.

int sum = 0;
int max = 0;
int[] lessons = new int[n];
StringTokenizer st = new StringTokenizer(br.readLine(), " ");
for(int i = 0; i < n; i++){
    lessons[i] = Integer.parseInt(st.nextToken());
    max = Math.max(max, lessons[i]);
    sum += lessons[i];
}

2. 블루레이 크기 검증

이분 탐색의 범위를 지정하고 탐색에 들어간다면, 블루레이 개수가 m보다 작은지 확인해야 한다. 반복문을 활용해 중간값 길이로 블루레이를 나누었을 때, 블루레이 크기가 m를 초과 여부를 먼저 확인하고 이에 따라 최소값을 변경할지, 최대값을 변경할지 결정한다.

 private static int minBluelay(int[] lessons, int max, int sum, int m){
    int low = max;
    int high = sum;

    while(low <= high){
        int mid = low + (high - low) / 2;

        if(isValid(lessons, mid, m)) high = mid - 1;
        else low = mid + 1;
    }

    return low;
}

private static boolean isValid(int[] lessons, int mid, int m){
    int count = 1;
    int total = 0;

    for(int i = 0; i < lessons.length; i++){
        if(total + lessons[i] > mid){
            count++;
            total = lessons[i];
            if(count > m) return false;
        }else{
            total += lessons[i];
        }
    }

    return true;
}

전체 코드

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

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

        String[] input = br.readLine().split(" ");
        int n = Integer.parseInt(input[0]);
        int m = Integer.parseInt(input[1]);

        int sum = 0;
        int max = 0;
        int[] lessons = new int[n];
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
        for(int i = 0; i < n; i++){
            lessons[i] = Integer.parseInt(st.nextToken());
            max = Math.max(max, lessons[i]);
            sum += lessons[i];
        }

        System.out.println(minBluelay(lessons, max, sum, m));
    }

    private static int minBluelay(int[] lessons, int max, int sum, int m){
        int low = max;
        int high = sum;
        
        while(low <= high){
            int mid = low + (high - low) / 2;

            if(isValid(lessons, mid, m)) high = mid - 1;
            else low = mid + 1;
        }

        return low;
    }

    private static boolean isValid(int[] lessons, int mid, int m){
        int count = 1; // 최소 1개의 블루레이는 필요
        int total = 0;
        
        for(int i = 0; i < lessons.length; i++){
            if(total + lessons[i] > mid){
                count++;
                total = lessons[i];
                if(count > m) return false; // 개수 초과 시 false 리턴
            }else{
                total += lessons[i];
            }
        }

        return true;
    }
}

minBluelay(): 최적의 블루레이 크기를 찾는 이분탐색 메서드

최소값(low)는 max로 설정하고, 최대값(high)는 sum으로 설정한다. 이는 블루레이의 크기가 max 이상이어야 모든 강의를 담을 수 있고, sum 이하이어야 모든 강의를 한 개의 블루레이에 담을 수 있기 때문이다.

중간값(mid)를 계산한 뒤, 해당 블루레이 크기로 주어진 블루레이 개수(m)를 만족할 수 있는지 isValid() 메서드를 호출하여 검증한다.

조건을 만족한다면(isValid()가 true) 더 작은 블루레이 크기에서도 가능할 수 있으므로 최대값(high)를 줄여야 하고, 조건을 만족하지 않는다면(isValid()가 false) 더 큰 블루레이 크기가 필요하므로 최소값(low)를 늘려야 한다.

이 과정을 반복하여 탐색 범위를 좁혀가면 최적의 블루레이 크기를 찾을 수 있다.

isValid(): 파라미터로 넘겨받은 블루레이 크기가 유효한지 검증하는 메서드

count 변수는 블루레이 개수를 세고 total 변수는 블루레이의 합을 저장한다.

반복문을 생성하고 만약 저장된 강의 길이의 합과 현재 강의 길이 합이 블루레이 크기보다 크다면 count를 증가하고 total 값은 현재 강의 길이로 변경해준다. 만약 count 즉, 블루레이 개수가 m이라는 주어진 조건에 부합하지 않는 경우 false를 리턴한다. else 문에 부합할 경우 total 값에 현재 강의 길이를 더해준다.

코테스터디 TIL

2025.01.16 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 3일차 TIL (미들러)

99클럽 코테 스터디 3일차 TIL (미들러)

문제: 백준 11663번 선분 위의 점 예제// Input5 51 3 10 20 301 1020 603 302 154 8// Output32420 풀이방법이 문제는 각 선분 위에 주어진 점이 몇 개가 있는지 출력해야 한다.점과 선분은 1 ~100,000개가 주어지

become-programmer.tistory.com

2025.01.14 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 2일차 TIL (미들러)

99클럽 코테 스터디 2일차 TIL (미들러)

문제: 백준 1654번 랜선 자르기 예제// Input4 11802743457539// Output200 알고리즘 풀이 방법랜선의 길이를 자르는 최적의 길이를 찾기 위해 다음 두 가지 방법을 시도했습니다. 1. 반복문 탐색(실패)2.

become-programmer.tistory.com

2025.01.13 - [알고리즘/99클럽 코테스터디 5기] - 99클럽 코테 스터디 1일차 TIL (미들러)

99클럽 코테 스터디 1일차 TIL (미들러)

문제: 백준 2776번 암기왕 예제// Input 1154 1 5 2 351 3 7 9 5// Output 111001 알고리즘 풀이 방법1. Binary Search(반복문, 재귀)2. Hash Set 수첩 1에 적힌 정수의 입력을 오름차순으로 정렬한 뒤, 이분 탐색을

become-programmer.tistory.com

99클럽 코테 스터디 3일차 TIL (미들러)

yeoni:) — Thu, 16 Jan 2025 09:41:10 +0900

문제: 백준 11663번 선분 위의 점

예제

// Input
5 5
1 3 10 20 30
1 10
20 60
3 30
2 15
4 8

// Output
3
2
4
2
0

풀이방법

이 문제는 각 선분 위에 주어진 점이 몇 개가 있는지 출력해야 한다.

점과 선분은 1 ~100,000개가 주어지기 때문에 일반적인 탐색을 하게 되면 시간초과가 발생한다.

여기서는 이분 탐색을 활용해 해당 문제를 풀어보려고 한다.

1. 이분탐색

먼저 주어진 점의 좌표 값이 [1,3,10,20,30]이라고 가정하고 선분의 시작과 종료가 3과 30이라고 했을 때 모든 점의 좌표를 비교하려고 하면 시간초과가 발생한다.

모든 수를 비교하지 않고 탐색할 수 있는 방안을 생각해보면 좌표 값이 정렬되어 있다는 가정하에 3보다 크거나 같은 점의 인덱스와 30보다 작거나 같은 인덱스를 찾아 큰 인덱스에서 작은 인덱스를 빼준다면 모든 값을 일일이 비교하지 않아도 된다!

여기서 주의해야 하는 것은 선분의 시작이나 종료 값이 점의 좌표와 완전히 동일하지 않다는 것이다. 따라서 시작인덱스와 종료인덱스를 찾는 각각의 함수를 생성하여야 한다.

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

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

        String[] input = br.readLine().split(" ");
        int n = Integer.parseInt(input[0]);
        int m = Integer.parseInt(input[1]);

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

        Arrays.sort(nums);

        StringBuilder sb = new StringBuilder();
        while(m-- > 0){
            String[] line = br.readLine().split(" ");
            int start = Integer.parseInt(line[0]);
            int end = Integer.parseInt(line[1]);

            int count = endDots(nums, end) - startDots(nums, start);
            sb.append(count).append("\n");
            
        }

        System.out.println(sb);
    }

    private static int startDots(int[] nums, int target){
        int s = 0;
        int e = nums.length;

        while(s < e){
            int mid = s + (e - s) / 2;
            if(nums[mid] >= target) e = mid;
            else s = mid + 1;
        }
        return s;
    }

    private static int endDots(int[] nums, int target){
        int s = 0;
        int e = nums.length;

        while(s < e){
            int mid = s + (e - s) / 2;
            if(nums[mid] > target) e = mid;
            else s = mid + 1;
        }
        return s;
    }
}

nums[]: 해당 배열은 입력된 점의 좌표를 저장하는 배열이다. 이분 탐색을 하려면 값이 정렬되어 있어야 하기 때문에 Arrays.sort(nums) 메서드를 활용해 오름차순으로 정렬하였다.

StringBuilder: 여러 개의 선분이 주어지고, 각 선분마다 입력된 점을 출력해야 한다. 각 선분마다 값을 출력해도 되지만, 성능이 좋지 않기 때문에 StringBuilder를 활용해 Output을 저장하고 출력하도록 하였다.

startDots(int[] a, int target): 점의 좌표가 target 값보다 크거나 같은 인덱스를 찾는 이분 탐색 로직이다. 파라미터 값으로는 점의 좌표가 저장된 배열과 선분의 시작 값을 넘겨준다. 내부 로직을 보게 되면 배열의 시작(s)과 끝(e)을 탐색의 범위로 지정하고 중간 값을 mid라는 변수에 저장한다. 만약 배열의 중간 값이 타겟보다 크거나 같다면 e를 mid설정하고 작다면 s를 mid + 1로 설정하여 탐색 범위를 줄인다.

예를 들어 [1,3,10,20,30]이라는 점의 좌표가 존재하고 선분의 시작과 끝이 [3,30]이라고 하였다면,

1번째: s = 1, e = 30, mid = 10
타겟인 3보다 mid가 크기 때문에 e = 10으로 설정
2번째: s = 1, e = 10, mid = 3
타겟인 3과 동일하기 때문에 e = 3
3번째: s = 1, e = 3, mid = 1
타겟보다 작기 때문에 s = 3
s와 e가 동일하기 때문에 반복문 종료 후 s 인덱스를 리턴

endDots(int[] a, int target): 선분의 종료 값보다 작거나 같은 인덱스를 찾는 이분 탐색 로직이다. startDots() 메서드와 다른 점은 조건문에 있다. a[mid] 보다 target이 큰 수 일 때, e를 mid로 설정하고 작거나 같다면 s = mid + 1로 지정한다.

1번째: s = 1, e = 30, mid = 10
타겟인 30보다 mid가 작기 때문에 s = 20으로 설정
2번째: s = 20, e = 30, mid = 20
타겟인 30보다 mid가 작기 때문에 s = 30
s와 e가 동일하기 때문에 반복문 종료 후 s 인덱스를 리턴

count: 메서드를 통해 시작 인덱스와 종료 인덱스를 찾았다면 큰 값 즉, 종료인덱스에서 작은 값인 시작인덱스를 빼주면 선분 위에 입력된 점이 몇 개인지 알 수 있다.

회고

2일 차와 동일하게 이분탐색을 진행했다. 이 문제는 완전히 동일한 수를 찾는 탐색이 아니었기 때문에 코드를 짤 때 조금 복잡했던 것 같다.

코테스터디 TIL

2025.01.14 - [알고리즘] - 99클럽 코테 스터디 2일차 TIL (미들러)

99클럽 코테 스터디 2일차 TIL (미들러)

become-programmer.tistory.com

2025.01.13 - [알고리즘] - 99클럽 코테 스터디 1일차 TIL (미들러)

99클럽 코테 스터디 1일차 TIL (미들러)

become-programmer.tistory.com

99클럽 코테 스터디 2일차 TIL (미들러)

yeoni:) — Tue, 14 Jan 2025 14:51:54 +0900

문제: 백준 1654번 랜선 자르기

예제

// Input
4 11
802
743
457
539

// Output
200

알고리즘 풀이 방법

랜선의 길이를 자르는 최적의 길이를 찾기 위해 다음 두 가지 방법을 시도했습니다.

1. 반복문 탐색(실패)

2. 이분탐색(성공)

1. 반복문 탐색(실패)

먼저 모든 K랜선의 길이를 더하여 N으로 나눈 값부터 하나씩 줄여나가도록 반복문을 작성하였다. 이렇게 한 이유는 K랜선의 길이를 모두 합하여 나눈 길이보다 더 큰 수가 나올 수 없기 때문이다. 그리고 K 랜선을 자른 개수보다 크거나 같으면 값을 출력할 수 있도록 하였다.

import java.io.*;

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

        String[] input = br.readLine().split(" ");
        int k = Integer.parseInt(input[0]);
        int n = Integer.parseInt(input[1]);

        int[] kArr = new int[k];
        int total = 0;
        for(int i = 0; i < kArr.length; i++){
            kArr[i] = Integer.parseInt(br.readLine());
            total += kArr[i];
        }

        for(int i = total / n; i >= 0; i--){
            if(n <= lan(kArr, i, n)){
                System.out.println(i);
                return;
            }
        }
        
    }

    private static int lan(int[] arr, int x, int n){
        int cnt = 0;
        for(int i = 0; i < arr.length; i++){
            cnt += arr[i] / x;
        }
        return cnt;
    }
    
}

하지만 입력되는 K 랜선의 길이는 1 이상 10,000 이하이기에 연산량이 많아 시간 초과가 발생하였고, 이 방법은 랜선 길이를 하나씩 줄여가며 확인하기 때문에, 입력 크기가 커질수록 비효율적이라는 것을 알게 되었다.

2. 이분 탐색 활용하기

이분 탐색을 활용하면 지정한 범위에서 조건에 맞지 않다면 랜선 길이의 범위를 반씩 줄여나가기 때문에 반복문보다 빠르게 최적값을 찾을 수 있다.

import java.io.*;

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

        String[] input = br.readLine().split(" ");
        int k = Integer.parseInt(input[0]);
        int n = Integer.parseInt(input[1]);

        int[] kArr = new int[k];
        long max = 0;
        for(int i = 0; i < k; i++){
            kArr[i] = Integer.parseInt(br.readLine());
            if(kArr[i] > max) max = kArr[i];
        }

        long left = 1;
        long right = max;
        long result = 0;

        while(left <= right){
            long mid = left + (right - left) / 2;
            if(isPossible(kArr, mid, n)){
                result = mid;
                left = mid + 1;
            }else{
                right = mid - 1;
            }
        }
        System.out.println(result);
    }

    private static boolean isPossible(int[] arr, long mid, int n){
        long count = 0;
        for(int length : arr){
            count += length / mid;
        }
        return count >= n;
    }
    
}

이분 탐색 범위: 랜선의 최대 길이를 max라는 변수에 저장한 다음 이분탐색을 시작한다. 이분 탐색의 범위는 랜선의 최소 길이인 1부터 최대 길이인 max로 설정한다. mid 값은 혹시 모를 오버플로우를 대비하여 left + (right-right) / 2로 구한다.

isPossible 함수: 랜선을 mid 길이로 자를 때, 만들어지는 랜선의 개수를 계산한다. count라는 변수를 두어 만들어진 총 랜선 길이를 계산하고 count가 n보다 크거나 같다면 true, 작다면 false를 리턴하도록 한다.

조건문: 길이가 리턴 값이 true라면 최소 길이를 mid + 1로 설정하여 더 긴 길이를 탐색하도록 하고, false라면 더 짧은 길이를 탐색할 수 있도록 한다.

출력: 이분 탐색의 종료 조건에 충족하면 반복문을 빠져나와 최댓값 result를 출력한다.

회고

이분 탐색을 활용하는 것이 더 빠르고 효율적으로 값을 탐색할 수 있다는 것을 다시 한번 경험한 문제였다. 반복문이 아닌 재귀 형식으로 탐색 범위를 좁여 나가는 방법도 익혀서 이분 탐색에 대한 이해도를 높여야겠다는 생각이 들었다.

코테스터디 TIL

99클럽 코테 스터디 1일차 TIL (미들러)

become-programmer.tistory.com

99클럽 코테 스터디 1일차 TIL (미들러)

yeoni:) — Mon, 13 Jan 2025 21:56:02 +0900

문제: 백준 2776번 암기왕

예제

// Input 1
1
5
4 1 5 2 3
5
1 3 7 9 5

// Output 1
1
1
0
0
1

알고리즘 풀이 방법

1. Binary Search(반복문, 재귀)

2. Hash Set

수첩 1에 적힌 정수의 입력을 오름차순으로 정렬한 뒤, 이분 탐색을 이용해 푸는 방법과, 유니크한 키만 가질 수 있다는 특성을 활용하여 HashSet 혹은 HashMap으로 풀어 보았다.

1. Binary Search

수첩 2에 적힌 수가 수첩 1에 포함되어 있는 가를 확인하는 문제이기 때문에 이분탐색을 이용해서 풀 수 있겠다는 생각이 들었다. 이분 탐색을 진행하려면 우선 정렬이 되어 있어야 하기 때문에, Arrays.sort() 메서드를 활용해서 오름차순 정렬을 시켰다.

1-1 재귀형식

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

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringBuilder sb = new StringBuilder(); 
        int t = Integer.parseInt(br.readLine());

        while(t-- > 0){
            int n = Integer.parseInt(br.readLine());

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

            Arrays.sort(nArr);

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

            st = new StringTokenizer(br.readLine(), " ");
            for(int i = 0; i < m; i++){
                int num = Integer.parseInt(st.nextToken());
                int result = binarySearch(num, nArr);
                sb.append(result).append("\n");
            }
            
        }

        System.out.println(sb);
    }

    private static int binarySearch(int target, int[] nArr){
        int start = 0; 
        int end = nArr.length - 1;

        while(start <= end){
            int mid = start + (end - start) / 2;

            if(nArr[mid] == target) return 1;
            else if(nArr[mid] < target) start = mid + 1;
            else end = mid - 1;
        }

        return 0;
    }
}

이후에는 반복문을 이용하여 이분 탐색을 할 수 있는 메서드를 호출했다. 처음 시도에는 재귀 형식으로 구현했다. 재귀 형식은 간결하다는 특징이 있지만 오버플로우의 위험이나 가독성이 좋지 않기에 반복문을 이용해서도 구현해 보았다.

1-2 반복문 활용

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

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringBuilder sb = new StringBuilder();
        int t = Integer.parseInt(br.readLine());

        while(t-- > 0){
            int n = Integer.parseInt(br.readLine());

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

            Arrays.sort(nArr);

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

            st = new StringTokenizer(br.readLine(), " ");
            for(int i = 0; i < m; i++){
                int num = Integer.parseInt(st.nextToken());
                int result = binarySearch(num, 0, nArr.length - 1, nArr);
                sb.append(result).append("\n");
            }
            
        }

        System.out.println(sb);
    }

    private static int binarySearch(int num, int start, int end, int[] nArr){
        if(start > end) return 0;

        int mid = start + (end - start) /2;

        if(num == nArr[mid]) return 1;
        else if(num < nArr[mid]) return binarySearch(num, start, mid - 1, nArr);
        else return binarySearch(num, mid + 1, end, nArr);
    }
}

2. HashSet

Set이라는 자료구조는 중복 값을 저장하지 않는다는 특징을 가지고 있다. 또한 HashSet은 해쉬 알고리즘으로 동작해 총 시간 복잡도가 O(n + m)으로 탐색 속도가 빠르다. 이때에 HashSet이 아닌 HashMap을 사용해도 된다. 하지만 불필요하게 메모리를 더 차지하게 되기에 HashSet을 사용하여 구현하였다.

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

public class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringBuilder sb = new StringBuilder();
        int t = Integer.parseInt(br.readLine());

        Set<Integer> set;
        while(t-- > 0){
            int n = Integer.parseInt(br.readLine());

            set = new HashSet<>();
            
            StringTokenizer st = new StringTokenizer(br.readLine(), " ");
            for(int i = 0; i < n; i++){
                set.add(Integer.parseInt(st.nextToken()));
            }

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

            st = new StringTokenizer(br.readLine(), " ");
            for(int i = 0; i < m; i++){
                int token = Integer.parseInt(st.nextToken());
                if(set.contains(token)){
                    sb.append(1);
                }else{
                    sb.append(0);
                }
                sb.append("\n");
            }
        }

        System.out.println(sb);
    }
}

회고

여러 가지 방향으로 풀어보니 자료구조의 특징이나, 어떤 방식이 더 효율적인지 알게 된 것 같다. 코테 스터디 첫 날인만큼 집중해서 풀었는데 이러한 마음가짐이 마지막까지 지속되었으면 좋을 것 같다.

Spring boot + Docker + Jenkins + GCP SSL 인증서 적용하기(HTTPS)

yeoni:) — Fri, 13 Dec 2024 13:30:47 +0900

API 개발을 다 끝내고 마무리 하는 타이밍에 vercel로 배포하려면 Https 요청만 가능하다고 프론트 개발자 분께서 이야기 하셨다.

스프링 부트에 적용하기 위해서는 아래와 같은 과정을 거쳐야 한다.

1. 도메인 발급(내도메인.한국)

2. CerBot을 통해서 인증서 발급(GCP)

3. PEM 인증서를 PKCS12 형태로 변환

4. Spring boot에 인증서 적용하기(Putty, 파일질라)

5. 재배포하기(Docker, Jenkins)

위 과정에 따라 배포했던 방법과 경험했던 에러를 작성하려고 한다.

1. 도메인 발급

내도메인.한국 - 한글 무료 도메인 등록센터

한글 무료 도메인 내도메인.한국, 웹포워딩, DNS 등 무료 도메인 기능 제공

xn--220b31d95hq8o.xn--3e0b707e

해당 사이트에 가입 후, 일반 도메인을 검색해 원하는 도메인을 등록한다.

IP연결에서 구글 클라우드로 사용중인 인스턴스 IP 주소를 입력하고 등록하면 된다.

2. Certbot으로 인증서 발급

발급 종류에는 standalone, webroot, DNS 총 세가지 방법이 있는데 나는 standalone를 선택했다.

Ubuntu 서버에 apt를 사용하여 certbot를 설치해도 되지만, 난 도커가 이미 깔려 있어서 도커를 이용해서 certbot 이미지를 가져왔다.

sudo docker pull certbot/certbot

그리고 이미지로 컨테이너를 실행한다.

docker run -it --rm --name certbot \
  -v  컨테이너외부폴더:/etc/letsencrypt \
  -v  컨테이너외부폴더:/var/lib/letsencrypt \
  -p 80:80 certbot/certbot certonly --standalone --preferred-challenges http -d 도메인주소

GCP 인스턴스에 certbot이라는 폴더를 생성하고 pwd 명령어로 주소를 가져와 [컨테이너외부폴더]에 붙여넣었다.

컨테이너 내부 폴더와 외부의 폴더를 볼륨해줘서 컨테이너와 함께 인증서가 삭제되지 않게 하기 위함이다.

마지막 줄에는 cerbot 방식과 도메인 주소를 넣어줬다. 컨테이너를 실행하게 되면 이메일을 요청하게 되는데, 이메일을 작성해주면 된다.

이렇게 되면 인증서 발급이 완료된다.

볼륨을 통해 연결한 폴더에 /live/도메인이름 으로 이동하면 4개의 키가 생성된 것을 알 수 있다.

여기서는 privkey.pem, fullchain.pem, chain.pem 키만 사용한다.

3. PEM to PKCS12 변경

해당 인스턴스에 OpenSSL를 설치한다.

sudo apt update
sudo apt install openssl

아래와 같은 명령을 통해 키를 변환한다.

openssl pkcs12 -export -inkey privkey.pem  -in fullchain.pem -out keystore.p12
-name tomcat -CAfile chain.pem -caname root

이렇게 되면 해당 키가 들어있는 폴더에 keystore.p12라는 파일이 생기게 된다.

4. Spring boot에 인증서 적용하기

이제 이 파일을 Spring boot에 적용하기 위해서 인스턴스에 저장되어 있는 해당 인증서를 putty와 파일질라를 이용해서 가져와야 한다.

GCP VM 인스턴스 FileZilla로 파일 전송하기

공부를 위해 Google Cloud Platform의 VM 인스턴스를 사용하던 중 Local의 파일을 VM 인스턴스로 전송해야 하는 일이 생겼다.VM 인스턴스와 FileZilla를 어떻게 연결하는지 알아보도록 한다.먼저 PuTTYgen을 실

velog.io

위를 참조해서 파일을 가져오면 스프링 프로젝트의 resources 밑에 keystore.p12를 적용하면 된다.

그리고 application.yml에 키 경로, 형식, 비밀번호를 입력해주면 된다.

이 프로젝트에서는 비밀번호를 도커에서 환경 변수를 넘겨주게 설정했다.

이렇게 하면 HTTPS 적용이 마무리된다!

* 트러블 슈팅

로컬에서는 잘 돌아가는데, 서버에 올리면 도커 컨테이너가 자꾸 내려갔다.

도커 로그를 살펴보니

java.lang.IllegalStateException: Unable to create key store: Could not load store form 'classpath:keystore.p12'

오류가 났다.

처음에는 도커가 경로 파일을 인식하지 못해서 생긴 에러라고 생각했는데, 알고보니 젠킨스에 변수 값만 추가하고 스트립트에 변수를 추가하지 않아서 비밀번호를 가져오지 못해서 생긴 에러였다.

뒤늦게 스크립트 수정하지 않았다는 사실을 알게 되고, 수정 후에는 컨테이너가 아무 문제 없이 동작하는 걸 볼 수 있었다.

Linked List Cycle

yeoni:) — Mon, 11 Nov 2024 13:52:21 +0900

Solution

Given head, the head of a linked list, determine if the linked list has a cycle in it.

There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next pointer. Internally, pos is used to denote the index of the node that tail's next pointer is connected to. Note that pos is not passed as a parameter.

Return true if there is a cycle in the linked list. Otherwise, return false.

Examples

Example 1:

Input: head = [3,2,0,-4], pos = 1
Output: true
Explanation: There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).

Example 2:

Input: head = [1,2], pos = 0
Output: true
Explanation: There is a cycle in the linked list, where the tail connects to the 0th node.

Example 3:

Input: head = [1], pos = -1
Output: false
Explanation: There is no cycle in the linked list.

Constraints:

The number of the nodes in the list is in the range [0, 104].
-105 <= Node.val <= 105
pos is -1 or a valid index in the linked-list.

Explanation

public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null) return false;
        ListNode walker = head, runner = head;
        while(runner.next != null && runner.next.next != null){
            walker = walker.next;
            runner = runner.next.next;
            if(walker == runner) return true;
        }
        return false;
        
    }
}

1. The problem with Cycles

In a linked list, if there is a cycle, some node will eventually point back to a previous node, causing an infinite loop. Without a mechanism to detect this, a standard traversal would never stop. Therefore, we use a two-pointer algorithm to check if it has a cycle in it.

2. Two-Pointer Approach

There are two ListNodes; one node, runner, moves twice as fast as the other, walker. If there is no cycle in it, the runner pointer will eventually reach the end of the list, the loop will terminate, and return false. If there is a cycle, the runner pointer will eventually "lap" the walker pointer. This is because the runner is moving faster, so it will finally catch up to the walker in the cycle. If this happens, the function returns true.

Palindrome Linked List

yeoni:) — Mon, 11 Nov 2024 12:01:31 +0900

Solution

Given the head of a singly linked list, return true if it is a palindrome or false otherwise.

Examples

Example 1:

Input: head = [1,2,2,1]
Output: true

Example 2:

Input: head = [1,2]
Output: false

Constraints:

The number of nodes in the list is in the range [1, 105].
0 <= Node.val <= 9

Explanation

class Solution {
    public boolean isPalindrome(ListNode head) {
    	// Find the middle ListNode
        ListNode slow = head, fast = head, prev, temp;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }

	// Reverse the Half list
        prev = slow;
        slow = slow.next;
        prev.next = null;
        while(slow != null){
            temp = slow.next;
            slow.next = prev;
            prev = slow;
            slow = temp;
        }
        
        // Iterate over two pointers, one starting from the first element 
        // and the other from the last, moving inward while checking if the values match
        fast = head;
        slow = prev;
        while(slow != null){
            if(fast.val != slow.val) return false;
            fast = fast.next;
            slow = slow.next;
        }
        return true;
    }
                                        
}

1. Find the middle in the given ListNode

We use the two-pointer technique to find the middle of the linked list. One pointer, fast, moves twice as fast as the other, slow. When fast reaches the end of the list (i.e., fast or fast.next is null), the slow pointer will be at the middle of the list. If the number of nodes is even, slow will point to the second half of the list (after the middle node).

2. Reverse the Half of the list

After finding the middle of the list, we reverse the second half. This is crucial because to check if the linked list is a palindrome, we need to compare the first half of the list with the reversed second half. Since singly linked lists do not allow backward traversal, reversing the second half of the list makes it easier to compare the two halves.

For example, for the list [1, 2, 4, 4, 2, 1], after finding the middle and reversing the second half [4, 2, 1], the list becomes [1, 2, 4] and [1, 2, 4], which can then be compared node by node

3. Check if values match

Now, with two pointers, one starting from the head of the list (the first element) and the other starting from the reversed second half, we move inward, comparing the values of the nodes. If at any point the values don’t match, return false. If all values match, return true, indicating that the list is a palindrome.

Java Concurrency - Java Memory Area & JMM

yeoni:) — Sat, 9 Nov 2024 13:44:35 +0900

Java Memory Area

The area where data is shared with all threads: Method Area, Heap.

The thread-private data area: Program Counter Register, VM Stack, Native Method Stack.

When running a program, the JVM automatically divides the memory it manages into the above areas, each of which has its own purpose and the timing of creation and destruction.

The area where data is shared with all threads

Method Area

It is mainly used to store class information, constants, static variables, code complied by the just-in-time compiler, and other data that have been loaded by the virtual machine.

Runtime Constant Pool in the Method area

It is used to store various literals and symbolic references generated by the compiler after class loading for subsequent use.

* literals: Similar to the concept of constants at the Java language level, including text strings, constant values declared as final, etc.

* Symbolic references: Concepts at the compilation language level (class names, variable names, method names, etc).

To distinguish the concepts of several of "constant pools"

1. Constant pool: The constant pool is determined during data compilation and is part of the Class file. It stores constants in classes, methods, interfaces, etc., including string constants.

2. String Pool/String Constant Pool: It is a part of the constant pool and stores string-type data generated in the compiled class.

3. Runtime Constant Pool: Part of the method area, shared by all threads. After the virtual machine loads the Class, it puts the data in the constant pool into the runtime constant pool.

JVM Heap

It is created when the virtual machine starts and is the largest piece of memory managed by the JVM. It is used to store object instances, and almost all object instances are allocated memory here. Because the Java heap is the main area managed by the garbage collector, it is often called the GC heap.

The thread-private data area

Program Counter Register

It is a small memory space, mainly representing the bytecode line number indicator executed by the current thread. When the bytecode interpreter works, it selects the instruction to be executed by changing the value of this counter.

Java Virtual Machine Stacks

It is created simultaneously with the thread, and the total number is associated with the thread, representing the memory model for the execution of Java methods. When each method is executed, a stack frame is created to store local variable tables, operand stacks, dynamic links, method exits, and other information.

- Local Variable Table: It is allocated during the compilation period and is used to store method parameters and local variables defined within the method. It may be basic types, object references, or a handle pointing to an object or other location related to, and returnAddress types, with Slot as the minimum unit of capacity.

- Operand Stack: It is also often called the operation stack, and each element in the stack can be any Java data type. During the execution of the method, various bytecodes will be directed to write and extract values in the operand stack, that is, push and pop operations.

- Dynamic Linking: Each stack frame contains a reference to the method in the runtime constant pool to which the stack frame belongs. Holding this reference is to support dynamic linking during the method call process.

- Method Exit: Normal exit, the execution engine encounters the bytecode of the method return and passes the return value to the caller. Abnormal exit, when encountering an Exception and the method does not catch the exception, there will be no return value.

Native Method Stacks

It is mainly related to the native methods used by the virtual machine and used to distinguish the division of the Java memory model from the division of the Java memory area. After all, these two divisions belongs to different levels of concepts.

Java Memory Model

It is an abstract concept that does not actually exist. It describes a set of rules or specifications. Through this set of specifications, the access methods of various variables in the program are defined. In addition, the CPU and compiler need to cooperate with this specification to make it easier for developers to develop multithreaded programs.

Since the entity running the program in the JVM is a thread, each thread has its own working memory for storing thread-private data. The Java Memory Model stipulates that all variables are in the main memory, which is a shared memory area that all threads can access. Threads cannot directly operate on the variables in the main memory but must first copy the variables from the main memory to their own working memory, operate on the variables in the working memory to their own working memory, operate on the variables in the working memory, and then write them back to the main memory after completion. Since the working memory is a private area for each thread, different threads cannot access each other's working memory, and communication between threads must go through the main memory.

It should be noted that the division of the JMM and the Java memory area is at a different conceptual level. In other words, the JMM describes a set of rules that control the access methods of various variables in the shared data area and the private data area in the program. The JMM revolves around atomicity, orderliness, and visibility.

The only similarity between the JMM and the Java memory area is that there are both shared data areas and private data areas. In the JMM, the main memory belongs to the shared data area, and to some extent, it should include the heap and the method area, while the working memory data thread private data area, to some extent, should include the program counter, the virtual machine stack, and the local method stack.

Main Memory

It mainly stores Java instance objects. All instance objects created by threads are stored in the main memory, regardless of whether the instance object is a member variable or a local variable in a method, and of course, shared class information, constants, and static variables are also included. Since it is a shared data area, multiple threads accessing the same variable may encounter thread safety issues.

Working Memory

It stores all the local variable information of the current method (the working memory stores a copy of the variables in the main memory). Each thread can only access its own working memory; that is, the local variables in the thread are invisible to other threads. Even if two threads execute the same code, they will each create local variables belonging to the current thread in their own working memory, including the bytecode line number indicator and information about related Native methods. So the data stored in the working memory does not have thread safety issues.

According to the virtual machine specification, for a member method in an instance object, if the method contains local variables and isiof a basic data type, it will be directly stored in the local variable table of the stack frame structure in the working memory.

If the local variable is of a reference type, then the specific reference address of the object in memory will be stored in the local variable table of the stack frame structure in the working memory, while the specific instance object will be stored in the main memory.

However, for the member variables of an instance object, whether it is a basic data type, a wrapper type such as Integer, Double, or a reference type, they will all be stored in the heap area. As for static variables and class-related information itself, they will be stored in the main memory.

Merge Two Sorted Lists

yeoni:) — Fri, 8 Nov 2024 14:50:46 +0900

Solution

You are given the heads of two sorted linked lists list1 and list2.

Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists.

Return the head of the merged linked list.

Examples

Example 1:

Input: list1 = [1,2,4], list2 = [1,3,4]
Output: [1,1,2,3,4,4]

Example 2:

Input: list1 = [], list2 = []
Output: []

Example 3:

Input: list1 = [], list2 = [0]
Output: [0]

Constraints:

The number of nodes in both lists is in the range [0, 50].
-100 <= Node.val <= 100
Both list1 and list2 are sorted in non-decreasing order.

Explanation

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode newNode = new ListNode(0);
        ListNode currNode = newNode;
        
        while(list1 != null && list2 != null){
            if(list1.val < list2.val){
                currNode.next = list1;
                list1 = list1.next;
            }else{
                currNode.next = list2;
                list2 = list2.next;
            }
            currNode = currNode.next;   
        }
        
        if(list1 != null){
            currNode.next = list1;
            list1 = list1.next;
        }
        
        if(list2 != null){
            currNode.next = list2;
            list2 = list2.next;
        }
        
        return newNode.next;
        
    }
}

newNode: It is a dummy node and created with an arbitrary value (0 in this case) to make managing the merged list simpler.

currNode: It is initialized to point to newNode. It will move through the new list as nodes are added.

A while loop runs as long as both list1 and list2 are non-null.

Inside this loop, if list1's current value is smaller than list2's, currNode.next is set to list1's current node, and list1 moves to its next node. Otherwise, currNode.next is set to list2's current node, and list2 moves to its next node. currNode is then updated to its next node in the new merged list, effectively adding the selected node to the merged list.

After exiting the while loop, if either list1 or list2 still has nodes left, they are already sorted, so we attach the remaining nodes to currNode.next.

Finally, the merged list starts at newNode.next since newNode is just a dummy. This merged list is returned.