궁금하신 점이 있다면 댓글로 남겨주세요.(2023년~ 노션으로 이동)

[교양학습] Gen AI (Generative AI / 생성형 AI)

[Contect] nyong9221@gmail.com — Tue, 21 May 2024 10:41:50 +0900

개념 설명

1. 특징

- 기계가 콘텐츠, 예술, 음악 등을 만들고 생성할 수 있도록 하는 인공지능의 하위집합으로 여러 산업을 변화시킬 수 있는 잠재력을 지닌 빠르게 진화하는 기술

- Gen AI(Gen AI, Generation AI)은 새로운 이미지를 생성하여 만들어내는 인공지능 기술

- 이미지 생성 AI의 일종으로, 다양한 유형의 이미지를 생성할 수 있음

2. 유형 (3가지)

1) Generation(생성) : 새로운 이미지를 만들어내는 기능

일본의 AI 기업인 "Data Grid"의 "Gene Idol" 프로젝트는 AI 아이돌을 생성해내는 예시입니다.
이 프로젝트에서는 AI 기술을 사용하여 일본 아이돌과 유사한 외모와 스타일을 갖춘 여성 이미지를
생성하는 것을 목표로 하고 있습니다.

2) Translation(변형) : 이미지 변형 AI는 기존 이미지를 변형해 새로운 이미지를 만들어 내는 기능

이미지를 스케치 스타일로 변형하거나, 주어진 이미지를 다른 스타일의 그림으로 변환하는 등의 
작업을 수행할 수 있습니다.

3) Conversion(전환) : 이미지 변환 AI는 이미지의 스타일을 변환하는 기능

주어진 이미지를 수채화 스타일이나 만화 스타일로 변환하는 등의 작업을 수행할 수 있습니다.

3. 종류

- GPT-4 (대형언어모델/LLM, Large Language Model), DALL·E 2, Stable Diffusion, Midjourney

Gen AI의 가치 사슬

1. 컴퓨터 하드웨어

- 훈련 단계 : 콘텐츠 생성을 위한 빅데이터 학습이 필요(수십억 개 단위의 매개변수를 병렬로 처리해야함)

따라서, 가속기칩을 가지고 있는 그래픽처리장치(GPU)나 텐서처리장치(TPU)로 구성된대규모 클러스터가 필요

- 조정 단계 : 모델의 맞춤화(조정)하는 단계로 컴퓨팅 파워를 요구하는 모델을 애플리케이션 내에서 실행할 수 있음.

이 때는 초기 훈련 단계보단 적은 컴퓨팅 파워로도 가능

- 따라서, NVIDIA와 GOOGLE칩 이 시장의 지배적임

2. 클라우드 플랫폼

- GPU와 TPU가 비싸고 부족한 자원이기 때문에 클라우드에서 작업을 수행

3. 파운데이션 모델(대규모 딥러닝 모델)

- 인간 뇌에 연결된 수십억 개의 뉴런에 영감을 받은 확장된 인공신경망을 포함

- 매우 크고 다양한 형태의 비정형 데이터를 처리하고 여러 작업을 수행

- 원하는 수준의 정확도를 위해 훈련 알고리즘은 신경망의 가중치를 조정하고, 이러한 과정을 수백만 번 수행해야함

- 대형언어모델(LLM)이 필요.

4.모델 허브와 MLOps

- 파운데이션 모델을 저장하고 액세스할 수 있는 장소

- 파운데이션 모델을 적용하고 애플리케이션 내에 배포하기 위한 특화된 MLOps 도구 및 기술이 필요

- 추가 훈련 데이터를 통합하고 레이블을 지정하거나 애플리케이션이 모델과 상호 작용할 수 있는 API를 구축하는 기능이 포함

- 소스코드가 공개되지 않은 모델의 경우, 라이선싱 계약을 통해 모델에 액세스할 수 있도록 API를 제공

- 제공업체가 MLOps 기능을 제공하여 모델을 조정하고 다양한 애플리케이션에 배포할 수 있도록 함

- 베드록(Bedrock) : AWS에서 제공하는 MLOps로써, Anthropic사의 Claude와 Stability사의 Stable Diffusion 등의

다양한 모델을 활용할 수 있는 플랫폼을 제공

5. 애플리케이션

6. 서비스

- Gen AI를 사용한 실질적인 서비스로, 특정 기능이나 산업 등 다양한 맥락에서

Gen AI 활용이나 전문 지식, 자료를 제공하는 역할

/* 참고링크 */
https://www.samsungsds.com/kr/insights/future_of_generative_ai_1.html

[git] 403에러 : remote: Permission to ... fatal: unable to access

[Contect] nyong9221@gmail.com — Thu, 2 May 2024 01:37:02 +0900

에러코드

remote: Permission to {나의 git Repository} denied to {내 계정}.
fatal: unable to access 'https://github.com/{나의 git Repository}': The requested URL returned error: 403

상황

: 작업 내역을 git push 하려니 발생

원인

: 내 로컬 PC에 저장된 git 인증 설정이 만료되거나 바뀌어서 발생

해결방법

1. [Windows 11 기준] 제어판 > 사용자 계정 > windows 자격 증명 관리 > git:https://github.com 토글 열기 > 제거

2. 다시 push 해보면 github Sign in 필요 > Sign in 진행 (이때, 브라우저에 흰 창만 뜨는 경우 정상적으로 된 것임)

3. 다시 push 해보면 정상적으로 동작하는 것을 확인 가능

[백준] no2490: 윳놀이

[Contect] nyong9221@gmail.com — Tue, 5 Sep 2023 20:28:33 +0900

문제

3번의 윳 상태가 주어진다.

각각의 윳 상태에 대해 아래 조건에 맞는 결과 출력하기.

         * 0이 1개 도
         * 0이 2개 개
         * 0이 3개 걸
         * 0이 4개 윳
         * 0이 0개 모

나의 코드

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

public class no2490 {
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static StringTokenizer st;

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

        int round = 3;
        while (round-- > 0) {
            st = new StringTokenizer(br.readLine(), " ");
            int cnt = 0;

            for (int i = 0; i < 4; i++) if (st.nextToken().equals("0")) cnt++;

            switch (cnt) {
                case 0:
                    System.out.println("E");
                    break;
                case 1:
                    System.out.println("A");
                    break;
                case 2:
                    System.out.println("B");
                    break;
                case 3:
                    System.out.println("C");
                    break;
                case 4:
                    System.out.println("D");
                    break;
            }
        }
    }
}

[백준] no5639:이진 검색 트리

[Contect] nyong9221@gmail.com — Sun, 3 Sep 2023 22:15:31 +0900

문제

이진 트리를 이루는 숫자가 전위 순환 순서로 주어진다.

해당 트리를 후위 순환한 경우의 순서대로 출력하시오.

문제 링크 : https://www.acmicpc.net/problem/5639

원리

1. root Node를 먼저 만든다.

2. insert 메소드를 이용해 순차적으로 값을 넣어 트리를 만든다. (큰값/작은값에 따라 null인지/null이 아닌지로 판명)

3. 완성된 트리를 대상으로 후위 순환하여 출력한다.

나의 코드

public class Main {
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int T;

    public static void main(String[] args) throws IOException {
        Node root = new Node(Integer.parseInt(br.readLine()));

        String input; // 메모리 아끼기 위해 변수는 반복문 밖에 선언
        while (true) {
            input = br.readLine(); // 새로들어오는 값 할당

            if(input == null || input.equals("")) break; // 더이상 입력이 없으면 무한반복 종료

            root.insert(Integer.parseInt(input)); // root를 대상으로 이중 트리 생성 시작.
            /*
                root를 대상으로 탐색하지만,
                루트에 대해 자식노드가 가득 차 있으면 그 다음 레벨들의 노드에 대해 insert가 실행되는 방식이다.
             */
        }

        // 후위순회 시작 -> 후위 순회하면서 맨 아래 왼쪽부터 시계반대 방향으로 차곡차곡 출력해줌
        postOrder(root);
    }

    private static class Node {
        private int Num; // 현재 노드의 값
        private Node Lt, Rt; // 자식 노드들 (없으면 null)

        private Node(int num) { this.Num = num; } // 빈 노드 생성용
        /* 어차피 Lt, Rt값은 insert메소드의 탐색을 통해 넣어질 것이다. */

        // 재귀 메소드
        public void insert (int n) {
            if(n<this.Num) { // 주어진 숫자가 현재노드보다 작은 수 일때,
                if(this.Lt == null) this.Lt = new Node(n); // 왼쪽 자식 노드(작은 수)가 없으면, 거기 넣어줌
                else this.Lt.insert(n);  // 이미 왼쪽 자식이 있다면, 해당 자식노드에 대해 다시 탐색해서 넣어줌
            }
            else { // 주어진 숫자가 현재노드보다 크거나 같은 수 일 때,
                if(this.Rt==null) this.Rt = new Node(n); // 오른쪽 자식 노드(큰 수)가 없으면, 거기 넣어줌
                else this.Rt.insert(n); // 이미 오른쪽 자식이 있다면, 해당 자식노드에 대해 다시 탐색해서 넣어줌
            }
        }
    }
    private static void postOrder (Node node) {
        if(node == null) return; // 더이상 탐색할 노드가 없으면 이전 뎁스로

        postOrder(node.Lt); // 가장 왼쪽부터 System.out.println(node.Num);
        postOrder(node.Rt); // 그다음 오른쪽부터 아래부터 System.out.println(node.Num);
        System.out.println(node.Num); // 최종적으로 루트가 가장 왼쪽부터 System.out.println(node.Num);
    }

레퍼런스

참고 링크 : https://girawhale.tistory.com/59

[백준] no2712: 미국스타일 - 구현

[Contect] nyong9221@gmail.com — Thu, 31 Aug 2023 19:45:39 +0900

문제

주어진 N개의 숫자를 단위환산해서 출력하기

이때, 출력포맷은 소수점 4번째 자리까지 반올림

무게	1.000 kg	2.2046 lb
	0.4536 kg	1.0000 lb
부피	1.0000 l	0.2642 g
	3.7854 l	1.0000 g

문제 링크 : https://www.acmicpc.net/problem/2712

원리

1. 입력된 숫자와 단위를 구분

2. 단위에 맞춰 숫자 변환 (exchange 메소드에 위임 : 단위에 따른 switch문)

3. 출력 포맷에 맞춰 변환 (change 메소드에 위임 : 반올림 및 소수점 4번째 자리까지)

나의 코드

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int T;
    private static StringTokenizer st;

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

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

        for(int i=0; i<T ; i++) {
            st = new StringTokenizer(br.readLine(), " ");
            double num = Double.parseDouble(st.nextToken());
            String unit = st.nextToken();
            bw.write(exchange(num, unit) + "\n");
        }

        bw.close();
    }

    private static String exchange (double num, String unit) {
        String result = "";

        switch (unit) {
            case ("kg") :
                result += change(num * 2.2046) + " lb";
                break;
            case ("l") :
                result += change(num * 0.2642) + " g";
                break;
            case ("lb") :
                result += change(num * 0.4536) + " kg";
                break;
            case ("g") :
                result += change(num * 3.7854) + " l";
                break;
        }

        return result;
    }

    private static String change(double num) {
        return String.format("%.4f", Math.abs(num * 10000)/10000);
    }

레퍼런스

소수점 출력포맷 만들기 : https://radpro.tistory.com/710

[백준] no2476:주사위 게임 - 구현

[Contect] nyong9221@gmail.com — Wed, 30 Aug 2023 17:11:15 +0900

문제

N명의 인원이 각각 3번씩 주사위를 굴려 다음 규칙에 따른 값을 가진다.

같은 눈이 3개가 나오면 10,000원+(같은 눈)×1,000원의 상금을 받게 된다. 
같은 눈이 2개만 나오는 경우에는 1,000원+(같은 눈)×100원의 상금을 받게 된다. 
모두 다른 눈이 나오는 경우에는 (그 중 가장 큰 눈)×100원의 상금을 받게 된다.

N명이 갖는 값중 최대값을 출력하기.

문제링크 : https://www.acmicpc.net/problem/2476

원리

             * 리스트에 중복될 눈이 있다면, 담지 않음
             * 다른 눈이라면 리스트에 담음
             * 리스트 사이즈에 따라, 상태는 다음과 같음
             * 리스트 사이즈 1 = 전체 중복
             * 리스트 사이즈 2 = 두개 중복
             * 리스트 사이즈 3 = 모두 다름
             *
             * 따라서, 각 케이스에 맞춰 계산 진행.
             * 이때, 중복된 눈이 있다면, 따로 메모라이즈

나의 코드

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

public class no2476 {
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static int N;
    private static ArrayList<Integer> members = new ArrayList<>(); // 결과 값들을 담을 리스트
    private static StringTokenizer st;

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

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

        // 각 인원수별 조사 반복
        while(N-->0) {
            List<Integer> temp_list = new ArrayList<>(); // 주사위 눈을 담을 리스트

            st = new StringTokenizer(br.readLine(), " ");
            int fst = Integer.parseInt(st.nextToken());
            int sec = Integer.parseInt(st.nextToken());
            int trd = Integer.parseInt(st.nextToken());

            temp_list.add(fst); // 첫 눈금은 비교를 위해 무조건 담음
            int memory = fst;

            //두번째 눈금 비교
            if(!temp_list.contains(sec)) temp_list.add(sec);
            else memory = sec;

            //세번째 눈금 비교
            if(!temp_list.contains(trd)) temp_list.add(trd);
            else memory = trd;

            // 각 케이스별 결과 계산 후 저장
            int result;
            if(temp_list.size() == 1) result = 10000 + (memory * 1000);
            else if(temp_list.size() == 2) result = 1000 + (memory * 100);
            else result = Collections.max(temp_list) * 100;
            members.add(result);
        }

        // 결과들 중 최대값 출력
        System.out.println(Collections.max(members));
    }
}

[백준] no6887:Squares - 제곱근 구하기

[Contect] nyong9221@gmail.com — Mon, 28 Aug 2023 21:07:53 +0900

문제

1 x 1 사이즈의 정사각형 타일 개수가 주어진다.

주어진 타일을 이용해 만들 수 있는 최대 사이즈의 정사각형의 한 변의 길이를 구하시오.

단, 출력은 아래 양식을 따른다.

/* 예제 */
input = 8
output = "The largest square has side length 2."

원리

방법 1. 정수로 떨어지는 제곱근의 최대값을 구한다. (심플)

방법 2. 정수로 떨어질 때까지 주어진 숫자를 -1 해가며 브루트 포스로 구한다. (비추)

나의 코드

import java.io.*;

public class no6887 {
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static int T;

    public static void main(String[] args) throws IOException {
        // 주어진 타일의 수
        T = Integer.parseInt(br.readLine());
        
        // Math 라이브러리의 제곱근 구하는 메소드 sqrt()를 사용. 출력값을 int형으로 변환 시 정수 최대값이 구해짐.
        int answer = (int) Math.sqrt(T);
        
        // 형식에 맞게 출력
        System.out.println(String.format("The largest square has side length %d.", answer));
    }
}

[SpringBoot] MySQL 연결하기 in yml

[Contect] nyong9221@gmail.com — Sun, 27 Aug 2023 22:23:34 +0900

목적

SpringBoot에서 MySQL workbeanch를 연동해서 사용하고 싶다.

(필자의 경우 새 노트북 사면서 새로 한동안 H2만 쓰다보니 잊고있다가 재설치하게 되었다)

환경

SpringBoot 2.7.13 버전 (gradle, JPA, yml 사용)
MySQL 8.0 버전

방법

SpringBoot쪽 설정

1. build.gradle에 dependency 추가 (안하면 아래 에러 항목 중 1번 에러 발생)

: 반드시 H2용 dependency는 제거 또는 주석처리 필요

dependencies {
    ...
    runtimeOnly 'com.mysql:mysql-connector-j' // MySQL
    ...
}

2. application.yml에 MySQL 설정 추가

: 반드시 H2설정은 제거 또는 주석처리 필요

: ${키값}으로 된 변수는 시스템 환경 변수에 해당 키값에 대한 밸류값을 저장해주기 (설정 후 재부팅 필요)

spring:
  ...
  ## MySQL 사용시
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/${TEMPLATE_SCHEME}
    username: ${MYSQL_USERNAME}
    password: ${MYSQL_PASSWORD}
  ...

MySQL쪽 설정

1. MySQL Installer로 MySQL 서버 설치 (참고링크 : 공식문서)

2. MySQL Workbench 설치

3. MySQL Workbench에서 DB 및 스키마 생성

에러 참고

1. cannot load driver class: com.mysql.cj.jdbc.driver

1-1) 원인 : MySQL을 읽어낼 의존성이 없다.

1-2) 해결방법 : build.gradle의 dependencies에 dependency를 추가해준다.

dependencies {
    ...
    runtimeOnly 'com.mysql:mysql-connector-j' // MySQL
    ...
}

참고링크: https://velog.io/@godkimchichi/Spring-Boot-Cannot-load-driver-class-com.mysql.cj.jdbc.Driver

2. test connection failed

2-1) 원인

경우 1. MySQL workbench만 설치하고 MySQL server는 설치 안한 경우

경우 2. MySQL 비밀번호를 설정 안한경우

2-2) 해결방법

경우 1. MySQL Installer로 server 설치

경우 2. MySQL Installer의 Reconfiguration을 이용해 유저네임 및 비밀번호 재설정

참고링크 : https://velog.io/@qowl880/mysql-%EC%97%B0%EA%B2%B0-%EC%8B%A4%ED%8C%A8-%EC%98%A4%EB%A5%98failed-to-connect-to-mysql-at-localhost-3306-with-user-root

[백준] no11504:바이토닉 수열 - 바이토닉 정렬(Bitonic)

[Contect] nyong9221@gmail.com — Fri, 25 Aug 2023 18:52:00 +0900

문제

주어진 수열에서 구할 수 있는 바이토닉 수열의 최대길이를 구하기

바이토닉 수열 : 수열 내 요소가 순차적으로 증가하다가 감소하는 수열

즉, {0,1,2,3,4,3,2,1}, {0,1,2,3}, {4,3,2,1}은 바이토닉 수열 O

단, {0,1,3,2,4,3,2,1}, {0,1,2,3,2,4,0}은 바이토닉 수열 X

원리

         * 1. arr에 대해, 0번 인덱스~N-1번 인덱스까지 도달하면서 오름차순으로 가장 길게 얻을 수 있는 길이를 기록하는 DP를 실행
         * 2. 반대 방향으로 DP실행
         * 3. 두 수열의 값을 합치면 바이토닉 수열의 최대값들이 기록된 DP 배열이 됨.
         * 4. 단, 각 위치별 중복값을 포함하게 되므로, 각 위치 최대값에 대해 -1을 해줘야 함

나의 코드

[실패] 1차시도 : DFS를 이용한 조건문 하드코딩

실패원인 : 인덱스 설정 오류, 코드 실행에 따른 메모리 소모 심함(브루트 포스이기 때문)

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/**
 * 각 숫자에 대해 DFS 실행
 *
 * DFS 조건
 * 1. 현재 list의 마지막 값보다 다음 값이 더 크다면 증가 유지
 * 2. 현재 list의 마지막 값보다 다음 값이 더 작다면 감소 시작
 * 3. 감소 중 다음 값이 현재 list의 마지막 값보다 더 큰 값이라면, 탐색 종료 후 list의 사이즈를 max값과 비교해서 업데이트
 *
 */
public class no11054 {
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int N;
    private static int[] arr;
    private static StringTokenizer st;
    private static int max_val;

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

        N = Integer.parseInt(br.readLine());
        arr = new int[N];
        st = new StringTokenizer(br.readLine(), " ");
        max_val = Integer.MIN_VALUE;

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

        for(int i=0; i<N ; i++) {
            ArrayList<Integer> list = new ArrayList<>();
            list.add(arr[i]);
            DFS(i, list);
        }

        System.out.println(max_val);
        bw.close();
    }

    private static void DFS (int start, List<Integer> list) {

        if(list.size()<=1) {
            List<Integer> temp_list = new ArrayList<>(List.copyOf(list));
            temp_list.add(arr[start+1]);
            DFS(start+1, temp_list);
        }

        for(int i=start+1 ; i<N ; i++) {
            if(list.get(list.size()-1)<arr[i]) {
                if(list.get(list.size()-1)<list.get(list.size()-2)) {
                    max_val = Math.max(max_val, list.size());
                    continue;
                }
                List<Integer> temp_list = new ArrayList<>(List.copyOf(list));
                temp_list.add(arr[i]);
                DFS(i, temp_list);
            }
            else if(list.get(list.size()-1)>arr[i]) {
                List<Integer> temp_list = new ArrayList<>(List.copyOf(list));
                temp_list.add(arr[i]);
                DFS(i, temp_list);
            }
        }
    }
}

[성공] 레퍼런스를 참고한 LIS + LDS를 이용한 바이토닉 공식

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

public class Main {
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static int[] arr;
    private static Integer[] Rt_DP, Lt_DP;

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

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

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

        for(int i=0 ; i<N ; i++) {
            LIS(i);
            LDS(i);
        }

        int max = -1;
        for(int i = 0; i <N ; i++) max =Math.max(Rt_DP[i]+ Lt_DP[i], max);

        System.out.println(max - 1); // 결국 모든 값은 다 -1 해줘야 하므로
    }

    // 순방향 오름차순 부분 수열 구하기
    private static int LIS(int N) {

        // 탐색하지 않았던 곳이면 1로 초기화
        if (Rt_DP[N] == null) {
            Rt_DP[N] = 1;

            // 이전 노드 탐색
            for (int i=N-1; i>=0; i--) {
                //이전 노드 중 작은 값을 발견한 경우
                if(arr[i] < arr[N]) Rt_DP[N] = Math.max(Rt_DP[N], LIS(i)+1);
            }
        }    
        return Rt_DP[N];
    }

    // 역방향 오름차순 부분 수열 구하기
    private static int LDS(int N) {

        // 탐색하지 않았던 곳이면 1로 초기화
        if (Lt_DP[N] == null) {
            Lt_DP[N] = 1;

            // N 이후 노드 탐색
            for (int i=N+1; i<Lt_DP.length; i++) {
                //이후 노드 중 작은 값을 발견한 경우
                if(arr[i] < arr[N]) Lt_DP[N] = Math.max(Lt_DP[N], LDS(i) +1);
            }
        }
        return Lt_DP[N];
    }
}

레퍼런스

참고링크 1 : LIS 및 LDS를 이용한 풀이 방법 https://st-lab.tistory.com/136

[백준] no2638:치즈 - BFS, DFS

[Contect] nyong9221@gmail.com — Thu, 24 Aug 2023 20:30:24 +0900

문제

N x M 크기의 맵에 공기는 0, 치즈는 1로 주어진다.

조건 1. 맵의 최외각은 항상 0이다.

조건 2. 치즈는 2면의 공기가 닿으면 1시간 안에 녹는다.

조건 3. 공기는 치즈 외부의 0에만 존재한다. (치즈로 사면이 둘러쌓인 공간의 0은 공기가 아니다.

원리

1. 1턴(1시간)에 한 번씩 맵을 순회한다.

2. 순회 중 외부 공기면, 사방향 탐색 진행(방문한 공기좌표는 방문체크 후 재방문 차단)

3. 순회 중 처음 방문한 치즈면, 방문체크만 함.

4. 순회 중 두번째 방문한 치즈면, 녹여버림.

5. 이 과정에서 치즈의 외각에서 별다른 사방향 탐색이 진행되지 않으므로, 내부 치즈는 탐색을 하지 않게됨.

6. 마찬가지로 치즈 내부 빈공간도 탐색하지 않게됨.

7. 만약 외부공기가 유입되는 경우는, 곧 치즈가 없는 구역에 대한 공기 탐색이 이루어 짐

8. 한 번이라도 치즈를 녹였다는게 체크되면, 1시간 지났음을 체크

9. 만약 탐색을 마치고 치즈를 녹인적이 없다면, 반복 종료.

나의 코드

[실패] 원인 : 2개 이상의 변이 닿아야 치즈가 녹는다는 조건을 깜빡함

즉, 이 코드는 한 변만 외부공기에 닿아도 녹는 코드임

public class no2638 {
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    private static int N, M, Hours;
    private static int[][] map;
    private static boolean[][] visited;
    private static StringTokenizer st;
    private static int[] ver = {-1, 1, 0, 0};
    private static int[] hor = {0, 0 ,-1, 1};

    public static void main(String[] args) throws IOException {
        st = new StringTokenizer(br.readLine(), " ");
        N= Integer.parseInt(st.nextToken());
        M= Integer.parseInt(st.nextToken());
        map = new int[N][M];
        Hours = 0;

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

        while(true) {
            if(BFS()) Hours++;
            else break;
        }

        System.out.println(Hours);
    }

    private static boolean BFS() {
        Deque<Node> dq = new ArrayDeque<>();
        visited = new boolean[N][M];
        dq.add(new Node(0,0));
        boolean exist = false;

        while(!dq.isEmpty()) {
            Node now = dq.poll();

            for(int move=0; move<4 ; move++) {
                int nextY = now.Y + ver[move];
                int nextX = now.X + hor[move];

                if(nextY < 0 || nextX < 0 || nextY >= N || nextX >= M) continue; // 범위 넘어가면 패스
                if(visited[nextY][nextX]) continue; // 이미 이번 탐색때 방문한 좌표인 경우 패스

                if(map[nextY][nextX]==1) {
                    visited[nextY][nextX] = true; // 치즈 가장자리를 방문체크함으로서 재탐색을 막으며, 내부 공기는 아예 탐색자체를 막음
                    map[nextY][nextX] = 0; // 처음 온 치즈 가장자리는 녹임 (만약 내부 공기인 경우엔 외부에 치즈가 있으므로 방문 자체가 막힘)
                    exist = true;
                } else { // 방문한 적 없는 외부 공기인 경우
                    visited[nextY][nextX] = true;
                    dq.add(new Node(nextY, nextX)); // 인근의 다른칸을 탐색
                }
            }
        }

        return exist; // 이번 탐색에서 치즈가 존재했는지 리턴
    }

    private static class Node {
        private int Y, X;
        public Node(int y, int x) {
            this.Y = y;
            this.X = x;
        }
    }
}

[성공] BFS를 이용한 탐색 (2면 인접 조건 달성)

public class no2638 {
    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static int N, M, Hours;
    private static int[][] map;
    private static boolean[][] visited;
    private static StringTokenizer st;
    private static int[] ver = {-1, 1, 0, 0};
    private static int[] hor = {0, 0 ,-1, 1};

    public static void main(String[] args) throws IOException {
        st = new StringTokenizer(br.readLine(), " ");
        N= Integer.parseInt(st.nextToken());
        M= Integer.parseInt(st.nextToken());
        map = new int[N][M];
        Hours = 0;

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

        while(true) {
            if(BFS()) Hours++;
            else break;
        }

        System.out.println(Hours);
    }

    private static boolean BFS() {
        Deque<Node> dq = new ArrayDeque<>();
        visited = new boolean[N][M];
        dq.add(new Node(0,0));
        boolean exist = false;

        while(!dq.isEmpty()) {
            Node now = dq.poll();

            for(int move=0; move<4 ; move++) {
                int nextY = now.Y + ver[move];
                int nextX = now.X + hor[move];

                /*
                 1. 치즈의 경우, visited인데 재방문이면 map에서 녹여주는 과정 필요
                 2. 공기의 경우, visited면 바로 패스
                 */

                if(nextY < 0 || nextX < 0 || nextY >= N || nextX >= M) continue; // 범위 넘어가면 패스
               
                // 공기든 치즈든 방문한 적이 있을 때, 
                if(visited[nextY][nextX]) {
                    if(map[nextY][nextX]==0) continue; // 이미 방문한 공기는 탐색 X
                    else {  // 한 면에 이미 공기가 닿은 치즈인 경우
                        map[nextY][nextX] = 0; // 치즈 녹여주고
                        exist = true;  // 이번 탐색에서 치즈 녹인 전적이 있음을 체크
                        continue;  // *아래 코드를 실행하지 못하도록 필수로 넣어줘야 함*
                    }
                }

                if(map[nextY][nextX]==1) visited[nextY][nextX] = true; // 치즈 가장자리를 방문체크함으로서 재탐색을 막으며, 내부 공기는 아예 탐색자체를 막음
                else { // 방문한 적 없는 외부 공기인 경우
                    visited[nextY][nextX] = true;
                    dq.add(new Node(nextY, nextX)); // 인근의 다른 칸을 탐색
                }
            }
        }

        return exist; // 이번 탐색에서 치즈를 녹였는지 여부를 리턴 : 하나라도 녹였으면 시간 + 1 해줘야 하므로 
    }

    private static class Node {
        private int Y, X;
        public Node(int y, int x) {
            this.Y = y;
            this.X = x;
        }
    }
}

레퍼런스 및 회고

레퍼런스 참고링크 : https://minhamina.tistory.com/156

1. DFS를 이용한 탐색 레퍼런스 코드

// dfs로 외부와 접촉한 공기 2로 표시
static void dfs(int x, int y) {
	visited[x][y] = true;
	map[x][y] = 2; // 외부 공기라는 의미로 2로 바꿔줌 

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

		if (nx < 0 || ny < 0 || nx >= N || ny >= M) continue;
		if (visited[nx][ny] || map[nx][ny] == 1) continue;

		dfs(nx, ny); // 공기인 경우만 dfs 수행 
	}
}

2. BFS를 이용한 탐색 레퍼런스 코드

// bfs로 외부와 접촉한 공기 2로 표시
public static void bfs() {
	Queue<Point> queue = new LinkedList<>();
	queue.add(new Point(0, 0));
	visited[0][0] = true;
	map[0][0] = 2;

	while(!queue.isEmpty()) {
		int x = queue.peek().x;
		int y = queue.poll().y;

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

			if (nx < 0 || ny < 0 || nx >= N || ny >= M) continue;
			if (visited[nx][ny] || map[nx][ny] == 1) continue; 

			map[nx][ny] = 2; // 외부 공기라는 의미로 2로 바꿔줌 
			queue.add(new Point(nx, ny)); // 공기인 경우만 큐에 넣어줌
			visited[nx][ny] = true;
		}
	}
}

회고

1. 바둑 알고리즘과 유사하다

2. 현재는 각 턴당(시간당) 맵 전체를 탐색하게 되는데, 이는 비효율적일 수 있다.

따라서, 기존에 탐색했던 외부 공기층(0) 중 직전에 녹은 부분에 대해서만 탐색하는 BFS를 구현하면 메모리를 절약할 수 있을것이다.