📌 풀이

📍 문제 이해 & 구현에 필요한 자료구조

재현이는 잘못된 수를 부를 때마다 0을 외쳐서, 가장 최근에 재민이가 쓴 수를 지우게 시킨다. ➡️ 재현이가 가장 최근에 재민이가 쓴 수를 지우는 과정은 후입선출(LIFO, Last-In-First-Out) 원칙을 따르고 있으므로, 스택 자료구조를 사용해 문제를 해결한다.

📍 구현 단계

1. K개의 숫자를 입력받아 stack 자료구조에 저장한다. 1-1. 만약 0을 입력받으면, stack의 top에 있는 숫자를 삭제시킨다.
2. stack에 담긴 모든 원소의 합을 구한다.

📌 문제 해결

📍 기댓값과 다른 결괏값

package ch05_Stack;

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

public class p10773 {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int K = Integer.valueOf(br.readLine());

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

        for (int i = 0; i < K; i++) {
            int input = Integer.valueOf(br.readLine());

            if (input == 0) {
                stack.pop();
                continue;
            }

            stack.add(input);
        }

        int sum = 0;
        for (int i = 0; i < stack.size(); i++) {
            sum += stack.pop();
        }

        System.out.println(sum);

    }

}

문제 원인

아래 코드대로 구현할 시 스택의 크기가 반복될 때마다 변경되고, 예상치 못한 결과가 발생할 수 있다.

int sum = 0;
for (int i = 0; i < stack.size(); i++) {
            sum += stack.pop();
}

수정한 코드

int sum = 0;
while(!stack.isEmpty()) {
            sum += stack.pop();
}

stack.size() 대신에 stack.isEmpty() 메서드를 사용하여 스택이 비어 있는지 확인해 반복문을 돈다.

📌 최종 코드

package ch05_Stack;

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

public class p10773 {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int K = Integer.valueOf(br.readLine());

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

        for (int i = 0; i < K; i++) {
            int input = Integer.valueOf(br.readLine());

            if (input == 0) {
                stack.pop();
                continue;
            }

            stack.add(input);
        }

        int sum = 0;
        while(!stack.isEmpty()) {
            sum += stack.pop();
        }

        System.out.println(sum);

    }
}

📌 참고

📍 자바의 int 데이터 타입은 32비트를 사용하며, 부호 비트를 포함하여 31비트의 값을 저장한다. 따라서 int형은 2의 31승의 범위를 표현할 수 있다.

📍 스택 STL 함수

• stack.add(x)
• stack.pop()
• stack.size() : 스택에 포함된 요소의 개수를 반환

백준 2579번 계단 오르기

✍️ 문제 풀이

• 접근 방법
  • DP(Dynamic Progmamming)
  • Bottom-Up

1. 테이블 정의하기 D[i][j] = 현재까지 j개의 계단을 연속해서 밟고 i번째 계단까지 올라섰을 때 점수 합의 최댓값, 단 i번째 계단은 반드시 밟아야 함

2. 점화식 찾기

3. 초기값 세팅

참고 자료 https://blog.encrypted.gg/974

💻 java 구현 코드

package ch10_DynamicProgramming;

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

public class p2579 {

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

        Scanner scanner = new Scanner(System.in);

        int N = scanner.nextInt();

        int[] score = new int[N + 1];  // 각 계단에서 얻을 수 있는 점수
        int[][] dp = new int[N + 1][3];  // DP테이블 (각 계단까지 올라갔을 때 얻을 수 있는 점수의 최댓값)

        // score 배열 값 세팅
        for (int i = 1; i <= N; i++) {
            score[i] = scanner.nextInt();
        }

        // 예외 처리
        if (N == 1) {
            System.out.println(score[1]);
            return;
        }

        // 초기값 세팅
        dp[1][1] = score[1]; dp[1][2] = 0;
        dp[2][1] = score[2]; dp[2][2] = dp[1][1] + score[2];

        // DP테이블 값 세팅
        for (int i = 3; i <= N; i++) {
            dp[i][1] = Math.max(dp[i - 2][1], dp[i - 2][2]) + score[i];
            dp[i][2] = dp[i - 1][1] + score[i];
        }

        System.out.println(Math.max(dp[N][1], dp[N][2]));
    }
}

💡 문제 해결

❗️ 런타임 에러

package ch10_DynamicProgramming;

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

public class p2579 {

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

        Scanner scanner = new Scanner(System.in);

        int N = scanner.nextInt();

        int[] score = new int[N + 1];  // 각 계단에서 얻을 수 있는 점수
        int[][] dp = new int[N + 1][3];  // DP테이블 (각 계단까지 올라갔을 때 얻을 수 있는 점수의 최댓값)

        // score 배열 값 세팅
        for (int i = 1; i <= N; i++) {
            score[i] = scanner.nextInt();
        }

        // 초기값 세팅
        dp[1][1] = score[1]; dp[1][2] = 0;
        dp[2][1] = score[2]; dp[2][2] = dp[1][1] + score[2];

        // DP테이블 값 세팅
        for (int i = 3; i <= N; i++) {
            dp[i][1] = Math.max(dp[i - 2][1], dp[i - 2][2]) + score[i];
            dp[i][2] = dp[i - 1][1] + score[i];
        }
        System.out.println(Math.max(dp[N][1], dp[N][2]));
    }
}

N의 값으로 1이 입력될 수 있는데, 이에 대한 예외처리 없이 dp[2][1] = score[2]; dp[2][2] = dp[1][1] + score[2]; 라인을 무조건 수행하도록 코드를 작성해서 런타임 에러가 발생하였다.

아래 코드를 추가해줌으로써 해당 에러를 해결하였다.

    // 예외 처리
        if (N == 1) {
            System.out.println(score[1]);
            return;
        }

✍️ 문제 풀이

• 접근법
• DP(Dynamic Programming) Bottom-Up * vs Top-Down 재귀

💻 java 구현 코드

📍 Bottom-Up

반복문을 사용하여 DP테이블(각 숫자를 1로 만드는데 필요한 최소 연산 횟수를 저장) 값을 1부터 N까지 차례대로 완성시킨다.

package ch10_DynamicProgramming;

import java.util.Scanner;

public class p1463 {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();

        int[] dp = new int[N + 1];  // DP테이블 (각 숫자를 1로 만드는데 필요한 최소 연산 횟수)

        dp[1] = 0;  // 초기값 세팅 

        for (int i = 2; i <= N; i++) {

            int val1 = N; int val2 = N; 

            if (i % 3 == 0) val1 = dp[i / 3] + 1;  // 3으로 나누어 떨어지면, 3으로 나누기
            if (i % 2 == 0) val2 = dp[i / 2] + 1;  // 2로 나누어 떨어지면, 2로 나누기
            int val3 = dp[i - 1] + 1;  // 1 빼기

            dp[i] = Math.min(val1, Math.min(val2, val3));
        }
        System.out.println(dp[N]);
    }
}

📍 Top-Down

재귀를 사용하여 구현

package ch10_DynamicProgramming;

import java.util.Scanner;

public class p1463 {

    static Integer[] dp;  // DP테이블 (각 숫자를 1로 만드는데 필요한 최소 연산 횟수)

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();

        dp = new Integer[N + 1];
        dp[0] = dp[1] = 0;  // 초기값 세팅

        if (N == 1)
            System.out.println(0);
        else
            System.out.println(cal(N));
    }

    static int cal(int N) {

        if (dp[N] == null) {  // 값이 구해져있지 않으면
            if (N % 6 == 0)  // 6으로 나눠지면
                dp[N] = Math.min(cal(N / 3), Math.min(cal(N / 2), cal(N - 1))) + 1;
            else if (N % 3 == 0)  // 3으로 나눠지면
                dp[N] = Math.min(cal(N / 3), cal(N - 1)) + 1;
            else if (N % 2 == 0)  // 2로 나눠지면 
                dp[N] = Math.min(cal(N / 2), cal(N - 1)) + 1;
            else  //2와 3으로 나누어지지 않으면
                dp[N] = cal(N - 1) + 1;
        }

        return dp[N];
    }
}

💡 문제 해결

💢 예상과 다른 출력값 계속 원하는 출력값이 나오지 않는 상황이 반복되었다. 코드를 아무리 봐도 문제가 없는 것 같아 보여서 결국 GPT한테 도움을 요청했더니,,, 정말 허무하게도 % 연산자 대신 / 연산자를 사용하여 발생한 문제였다.ㅎ 이런 실수 한 번 하면 다음부턴 주의해서 사용하게 되어서 시간 낭비했다고 생각하지 않으려고 한다. 👍

🧷 null값 활용

Java에서 Integer 객체 배열을 생성하면 기본적으로 각 요소는 null로 초기화된다. Integer 클래스의 객체 배열이므로 객체 자체가 null로 초기화되기 때문이다.

문제풀이

• 접근법 : BFS

• 풀이과정

  1. 그림 배열을 전체 순회하면서, 아직 방문하지 않은 구역을 시작점으로 설정하고, 인접한 구역 중에서 해당 구역의 색깔과 동일한 구역을 계속해서 큐에 넣으면서 BFS를 수행한다. ⇒ 적록색약이 아닌 사람이 보는 구역의 개수 구하기
  2. 만약 적록색약 확인용으로도 방문하지 않은 구역이고 빨간색 또는 초록색이면, 해당 구역을 시작점으로 설정하고 인접한 빨간색 또는 초록색 구역을 계속해서 큐에 넣으면서 BFS를 수행한다. ⇒ 적록색약인 사람이 보는 구역의 개수 구하기

java 구현 코드

package ch08_BFS;

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

public class p10026 {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.valueOf(br.readLine());

        int[] dx = {1,0,-1,0};
        int[] dy = {0,1,0,-1};

        char[][] picture = new char[N][N];  // 그림 배열
        boolean[][] visited = new boolean[N][N];  // 적록색약 X 방문 여부 표시 배열
        boolean[][] visited_RG = new boolean[N][N];  // 적록색약 O 방문 여부 표시 배열

        Queue<Point> queue = new LinkedList<>();  // 큐 생성

        int count = 0;  // 적록색약 X 구역의 개수
        int RG = 0;  // 적록색약 O 구역의 개수 
        int B = 0;  // B의 개수 


        /*
         * 그림 배열 값 세팅
         */
        for (int i = 0; i < N; i++) {
            String input = br.readLine();
            for (int j = 0; j < N; j++) {
                picture[i][j] = input.charAt(j);
            }
        }

        /*
         * 그림 배열 전체 순회하면서, 방문하지 않은 구역을 시작점으로 BFS 수행
         */
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                /*
                 * 적록색약 X에 대한 BFS
                 */
                if (visited[i][j] == true) continue;  // 방문 여부 검증 
                queue.add(new Point(i, j));  // enqueue
                visited[i][j] = true;  // 방문 표시
                count++;

                char color = picture[i][j];  // 시작점의 색깔 color 
                if (color == 'B') B++;

                while (!queue.isEmpty()) {
                    Point dequeue = queue.remove();  // dequeue

                    for (int d = 0; d < 4; d++) {
                        int dX = dequeue.X + dx[d];
                        int dY = dequeue.Y + dy[d];

                        if (dX < 0 || dX >= N || dY < 0 || dY >= N || visited[dX][dY] == true) continue;  // 좌표 유효성 검증, 방문 여부 검증 
                        if (picture[dX][dY] != color) continue;  // 시작점의 색깔과 비교
                        queue.add(new Point(dX, dY));  // enqueue
                        visited[dX][dY] = true;  // 방문 표시
                    }
                }

                /*
                 * 적록색약 O에 대한 BFS
                 */
                if (visited_RG[i][j] == true || picture[i][j] == 'B') continue;  // 방문 여부, 색깔 검증 
                queue.add(new Point(i, j));  // enqueue
                visited_RG[i][j] = true;  // 방문 표시
                RG++;

                while (!queue.isEmpty()) {
                    Point dequeue = queue.remove();  // dequeue

                    for (int d = 0; d < 4; d++) {
                        int dX = dequeue.X + dx[d];
                        int dY = dequeue.Y + dy[d];

                        if (dX < 0 || dX >= N || dY < 0 || dY >= N || visited_RG[dX][dY] == true) continue;  // 좌표 유효성 검증, 방문 여부 검증 
                        if (picture[dX][dY] == 'B') continue;  // 시작점의 색깔과 비교
                        queue.add(new Point(dX, dY));  // enqueue
                        visited_RG[dX][dY] = true;  // 방문 표시
                    }
                }
            }
        }
        System.out.println(count + " " + (RG + B));
    }
}

class Point {
    int X;
    int Y;

    Point(int X, int Y) {
        this.X = X;
        this.Y = Y;
    }
}

comment

• 풀이 날짜 : 2312어느날, 240101

저번에 풀었다가 해결 못한 문제를 오늘 끝내 해결했다. 2024년에 처음으로 해결한 문제다. 2024년 시작이 좋다! 🍀

2024년 2월 6일 복습 코드

package review;

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

public class p1926 {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        int n = Integer.valueOf(st.nextToken());  // 세로
        int m = Integer.valueOf(st.nextToken());  // 가로

        int[][] picture = new int[n][m];

        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(br.readLine());

            for (int j = 0; j < m; j++) {
                picture[i][j] = Integer.valueOf(st.nextToken());
            }
        }

        int[] dx = {0, 0, -1, 1};
        int[] dy = {1, -1, 0, 0};

        int count = 0;
        int maxSize = 0;

        boolean visited[][] = new boolean[n][m];
        Queue<Point> queue = new LinkedList<>();

        for (int i = 0 ; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (!visited[i][j] && picture[i][j] == 1) {
                    int size = 1;
                    count++;

                    queue.add(new Point(i, j));
                    visited[i][j] = true;

                    while (!queue.isEmpty()) {
                        Point dequeue = queue.remove();

                        for (int d = 0; d < 4; d++) {
                            int dX = dequeue.X + dx[d];
                            int dY = dequeue.Y + dy[d];

                            if (dX < 0 || dX >= m || dY < 0 || dY >= n) continue;

                            if (!visited[dY][dX] && picture[dY][dX] == 1) {
                                queue.add(new Point(dX, dY));
                                visited[dY][dX] = true;
                                size++;
                            }
                        }
                    }
                    maxSize = (size > maxSize) ? size : maxSize;
                }
            }
        }
        System.out.println(count + "\n" + maxSize);
    }
}

class Point {
    int X;
    int Y;

    Point(int X, int Y) {
        this.X = X;
        this.Y = Y;
    }
}

(( 연결 표 추가 작성 필요 ))

라즈베리파이에서 세팅하기

sudo apt-get update sudo apt-get upgrade

라즈베리파이에서 Preferences → Raspberry Pi Configuration → Interfaces

“I2C”를 Enable 설정하고 sudo reboot

sudo apt-get install python3-dev python3-pip python3-smbus i2c-tools -y

i2cdetect -y 0 ⇒ I2C 버스에 연결된 장치의 주소 확인

파이썬 샘플 코드

import smbus
import time

bus = smbus.SMBus(1)  # I2C 버스 번호 (라즈베리파이 2 이상일 때는 1, 라즈베리파이 1일 때는 0)
address = 0x53  # ADXL345 센서의 I2C 주소 (i2cdetect -y 0로 확인한 주소)

# ADXL345 초기화 함수
def init_ADXL345():
    bus.write_byte_data(address, 0x2D, 0x08)

# 가속도 값을 측정하는 함수
def measure_acc(adr):
    acc0 = bus.read_byte_data(address, adr)
    acc1 = bus.read_byte_data(address, adr + 1)
    acc = (acc1 << 8) + acc0
    # 2의 보수 변환
    if acc > 0x1FF:
        acc = (65536 - acc) * -1
    return acc

try:
    init_ADXL345()
    while True:
        # x, y, z 축의 가속도 값을 읽어옴
        x_acc = measure_acc(0x32)  # X 축 레지스터 주소
        y_acc = measure_acc(0x34)  # Y 축 레지스터 주소
        z_acc = measure_acc(0x36)  # Z 축 레지스터 주소

        # 읽어온 가속도 값을 출력
        print(f"X-Axis: {x_acc}, Y-Axis: {y_acc}, Z-Axis: {z_acc}")

        time.sleep(0.5)  # 0.5초 간격으로 측정

except KeyboardInterrupt:
    pass

문제 풀이

• 접근법 : BFS 모든 원소를 순회하면서 방문하지 않은 배추를 시작점으로 BFS를 수행하여 배추 무리를 찾아나간다.

java 구현 코드

package ch08_BFS;

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

public class p1012 {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder output = new StringBuilder();
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        int T = Integer.valueOf(st.nextToken());  // 테스트 케이스의 개수 T

        /*
         * 배추밭 배열 값 세팅하기
         */
        for (int t = 0; t < T; t++) {

            st = new StringTokenizer(br.readLine());
            int M = Integer.valueOf(st.nextToken());  // 배추밭의 가로길이 M 
            int N = Integer.valueOf(st.nextToken());  // 배추밭의 세로길이 N 
            int K = Integer.valueOf(st.nextToken());  // 배추가 심어져 있는 위치의 개수 K

            int[][] field = new int[N][M];  // 배추밭 배열

            for (int k = 0; k < K; k++) {
                st = new StringTokenizer(br.readLine());
                int X = Integer.valueOf(st.nextToken());  // 배추 위치의 X좌표
                int Y = Integer.valueOf(st.nextToken());  // 배추 위치의 Y좌표

                // field[X][Y] = 1;  // 배추가 심어져 있음을 표시
                field[Y][X] = 1;  // 배추가 심어져 있음을 표시
            }

            int[] dx = {1,0,-1,0};
            int[] dy = {0,1,0,-1};

            Queue<Spot> queue = new LinkedList<>();  // 큐 생성
            int count = 0;  // 결괏값

            /*
             * 배추밭 전체 순회하면서 방문하지 않은 배추를 시작점으로 BFS 수행
             */
            for (int n = 0; n < N; n++) {
                for (int m = 0; m < M; m++) {
                    if (field[n][m] == 1) {  // 방문 안 한 배추면
                        queue.add(new Spot(m, n));  // enqueue
                        field[n][m] = -1;  // 방문 표시
                        count++;  // 배추 무리 + 1
                    }

                    while (!queue.isEmpty()) {
                        Spot dequeue = queue.remove();  // dequeue

                        for (int d = 0; d < 4; d++) {
                            int dX = dequeue.X + dx[d];
                            int dY = dequeue.Y + dy[d];

                            if (dX < 0 || dX >= M || dY < 0 || dY >= N) continue;  // 좌표의 유효성 검증

                            // if (field[dX][dY] == 1) {  // 유효한 좌표이고, 방문하지 않은 배추라면
                            if (field[dY][dX] == 1) {  // 유효한 좌표이고, 방문하지 않은 배추라면
                                queue.add(new Spot(dX, dY)); // enqueue
                                field[dY][dX] = -1; // 방문 표시
                            }
                        }
                    }
                }
            }
            output.append(count).append("\n");
        }
        System.out.println(output.toString());
    }
}

class Spot {
    int X;
    int Y;

    Spot(int X, int Y) {
        this.X = X;
        this.Y = Y;
    }
}

문제 해결

X좌표와 Y좌표 대입 위치 혼동으로 인해 발생한 IndexOutOfBoundsException 에러

최초 코드에서 IndexOutOfBoundsException 에러가 여기저기서 계속 발생했는데, 코드를 아무리 들여다 보아도 문제의 원인을 알아낼 수가 없었다. 그래서 결국엔 다른 사람들의 코드를 찾아 보아 원인을 알아냈다.

X좌표와 Y좌표의 잘못된 대입으로 IndexOutOfBoundsException 에러가 발생했던 것이다. 의심의 여지 없이 X좌표와 Y좌표를 (X,Y) 순서대로 대입해서 코드를 작성해 나갔는데, 그러면 안 됐다... 난 바보다ㅜ 이 실수는 나만 했을까 괜히 궁금해진다.

문제에서 다음과 같은 요구사항이 주어져 있다. 배추밭의 가로길이 M(1 ≤ M ≤ 50)과 세로길이 N(1 ≤ N ≤ 50), 그리고 배추가 심어져 있는 위치의 개수 K(1 ≤ K ≤ 2500) 앞으로 X,Y 좌표 대입에서 헷갈리면 문제 요구사항을 자세히 들여다 보고 힌트를 얻어야 겠다. 다시는 이러한 실수를 하지 않기 위해 그림도 한 번 그려보았다. 🙃

버그를 발생할 때마다 매번 구글링 해보면 같은 문제를 경험한 사람이 한둘이 아니다. 해결 좀 해쥬세요... 하 ㅠㅠ

캡스톤 디자인 수업으로 진행한 "AIoT 스마트 안전모" 프로젝트로 "AIoT Advantech AIoT Innoworks Project 2023"에서 최우수상, "2023 탄소중립 Innovation Academy 성과발표회"에서 최우수상을 수상했다.

한 학기 동안, 아니 실질적으로 기획 및 개발하는데 투자한 시간은 한 달도 안 될 것이다. 대략 한 달 동안 지민이, 민혜언니와 같이 라즈베리파이와 고군분투하며 고생한 기간에 대한 보상을 받게 되어서 정말 다행이다. 결과물이 좋았기 때문에 수상을 기대하긴 했다만,,,ㅎㅎ 이렇게 최우수상을 두 개나 받게 되어 기쁨도 배로 느껴진다.

문제 풀이

• 접근법 :BFS 모든 원소를 순회하면서, 익은 토마토를 시작점으로 BFS를 수행하여 최단 날짜를 구해나간다.

java 구현 코드

package ch08_BFS;

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

public class p7576_solved {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st;

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

        int M = Integer.valueOf(st.nextToken());
        int N = Integer.valueOf(st.nextToken());

        Queue<Position> queue = new LinkedList<>();

        int[][] tomatoes = new int[N][M];
        boolean[][] visited = new boolean[N][M];

        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < M; j++) {
                tomatoes[i][j] = Integer.valueOf(st.nextToken());

                if (tomatoes[i][j] == 1) {
                    queue.add(new Position(i, j));
                    visited[i][j] = true;    
                }        
            }
        }

        int[][] minDays = new int[N][M];

        int[] dx = {1,0,-1,0};
        int[] dy = {0,1,0,-1};

        while (!queue.isEmpty()) {
            Position dequeue = queue.remove();

            for (int d = 0; d < 4; d++) {
                int dX = dequeue.X + dx[d];
                int dY = dequeue.Y + dy[d];

                if ((dX >= 0 && dX < N) && (dY >= 0 && dY < M)) {

                    if (tomatoes[dX][dY] == 0) {
                        if (visited[dX][dY] == false) {
                            queue.add(new Position(dX, dY));

                            minDays[dX][dY] = minDays[dequeue.X][dequeue.Y] + 1;
                            visited[dX][dY] = true;
                        } else { // 이미 방문한 곳이면
                            if (minDays[dequeue.X][dequeue.Y] + 1 < minDays[dX][dY]) {
                                minDays[dX][dY] = minDays[dequeue.X][dequeue.Y] + 1;
                                queue.add(new Position(dX, dY));
                            }
                        }
                    }
                }
            }
        }

        int result = 0;  
        for (int i = 0; i < N; i++) {  
            for (int j = 0; j < M; j++) {
                if (tomatoes[i][j] == 0 && visited[i][j] == false) { 
                    System.out.println(-1);  
                    return;
                }
                else if (tomatoes[i][j] == 1 || tomatoes[i][j] == 0) {  
                    result = (minDays[i][j] > result) ? minDays[i][j] : result;
                }
            }
        }

        System.out.println(result);
        return;
    }

}

class Position {
    int X;
    int Y;

    Position(int X, int Y) {
        this.X = X;
        this.Y = Y;
    }
}

문제 해결

시간 초과 및 지저분한 코드

package ch08_BFS;

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

public class p7576 {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());  // NM
        int M = Integer.valueOf(st.nextToken());  // 상자의 가로
        int N = Integer.valueOf(st.nextToken());  // 상자의 세로

        char[][] tomato = new char[N + 2][M + 2];  // 토마토 상자 배열 생성

        // 토마토 상자 배열 값 세팅하기
        for (int i = 1; i <= N; i++) {
            st = new StringTokenizer(br.readLine());  // 하나의 행
            for (int j = 1; j <= M; j++) {
                tomato[i][j] = st.nextToken().charAt(0);
            }
        }

        int[] dx = {1,0,-1,0};  // 우상좌하
        int[] dy = {0,1,0,-1};

        Queue<Position> queue = new LinkedList<>();  // 큐 생성 
        int[][] minDays = new int[N + 2][M +2];  // 토마토가 익기까지 최단 날짜 저장하는 배열
        // int date = 0;  // 결괏값

        // 토마토 상자의 모든 칸을 순회
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= M; j++) {
                if (tomato[i][j] == '1') { // 익은 토마토이면

                    queue.add(new Position(i, j));  // 해당 위치를 enqueue

                    while (!queue.isEmpty()) {  // 큐가 빌 때까지 반복
                        Position tmp = queue.remove();  // dequeue 

                        for (int d = 0; d < 4; d++) {  // 인접한 칸에 대해 순회
                            int dX = tmp.X + dx[d];
                            int dY = tmp.Y + dy[d];

                            if ((dX > 0 && dX < N + 1) || (dY > 0 && dY < M + 1)) {  // 좌표 유효성 검증 
                                if (tomato[dX][dY] == '0') {  // 1. 안 익은 토마토가 있는데, 
                                    if (minDays[dX][dY] == 0) {  // 1-1. 첫 방문이면 
                                        minDays[dX][dY] = minDays[tmp.X][tmp.Y] + 1;  // 최단 거리 바로 저장하고
                                        queue.add(new Position(dX, dY));  // enqueue 
                                    }
                                    else  { // 1-2. 이미 방문했으면 
                                        if (minDays[tmp.X][tmp.Y] + 1 < minDays[dX][dY]) {  // 이미 저장되어 있는 최단 날짜와 비교해서,
                                            minDays[dX][dY] = minDays[tmp.X][tmp.Y] + 1;  // 최단 거리 갱신하고
                                            queue.add(new Position(dX, dY));  // enqueue 
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        int days = 0;  // 결괏값 
        for (int i = 1; i <= N; i++) {  // 토마토 상자의 모든 칸을 순회
            for (int j = 1; j <= M; j++) {
                if (tomato[i][j] == '0' && minDays[i][j] == 0) {  // 익지 못한 토마토가 있으면 
                    System.out.println(-1);  
                    return;
                }
                else if (tomato[i][j] == '1' || tomato[i][j] == '0') {  // 토마토가 존재하면
                    days = (minDays[i][j] > days) ? minDays[i][j] : days;  // 결괏값 갱신
                }
            }
        }
        System.out.println(days);
    }

}

class Position {
    int X;
    int Y;

    Position(int X, int Y) {
        this.X = X;
        this.Y = Y;
    }
}

시간 초과의 원인을 내 힘으로 찾아보려고 했으나, 도저히 모르겠어서 여러 문제풀이 글을 찾아보며 이 문제의 시간 초과의 해결 방법을 알아냈다. 평범하게 입출력 부분에서 해결할 수 있는 문제가 아니었다. 순회할 필요가 없는 부분까지 순회를 해버렸기 때문에 시간 초과가 발생한 것이었다. 문제가 발생한 위 코드에서는 입력을 받아 토마토 상자 배열에 값을 세팅한 후, 값이 1인 경우를 찾아내기 위해서 아래와 같이 모든 상자의 칸을 순회한다. 그러나 0인 경우는 순회할 필요가 없기 때문에 모든 칸에 대해서 반복문을 돌릴 필요가 없게 된다.

모든 칸에 대해서 반복문을 돌리지 않고 배열값이 1인 경우만 큐에 원소를 삽입한 후 BFS 작업을 진행하려면 다음과 같이 하면 된다.

for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < M; j++) {
                tomatoes[i][j] = Integer.valueOf(st.nextToken());

                if (tomatoes[i][j] == 1) {
                    queue.add(new Position(i, j));
                    visited[i][j] = true;    
                }        
            }
        }

        int[][] minDays = new int[N][M];

        int[] dx = {1,0,-1,0};
        int[] dy = {0,1,0,-1};

        while (!queue.isEmpty()) {
            Position dequeue = queue.remove();

            for (int d = 0; d < 4; d++) {
                int dX = dequeue.X + dx[d];
                int dY = dequeue.Y + dy[d];

                if ((dX >= 0 && dX < N) && (dY >= 0 && dY < M)) {

                    if (tomatoes[dX][dY] == 0) {
                        if (visited[dX][dY] == false) {
                            queue.add(new Position(dX, dY));

                            minDays[dX][dY] = minDays[dequeue.X][dequeue.Y] + 1;
                            visited[dX][dY] = true;
                        } else { // 이미 방문한 곳이면
                            if (minDays[dequeue.X][dequeue.Y] + 1 < minDays[dX][dY]) {
                                minDays[dX][dY] = minDays[dequeue.X][dequeue.Y] + 1;
                                queue.add(new Position(dX, dY));
                            }
                        }
                    }
                }
            }
        }

입력을 받아 배열에 값을 세팅하는 과정에서, 1을 만나면 바로 큐에 값을 삽입한다. 배열 값 세팅을 완료하면 큐가 빌 때까지 BFS 작업을 진행한다.

comment

풀이 날짜 : 2023/12/22 (금), 2023/12/27 (수)

231222 아직 알고리즘 초보인 내가 풀기엔 좀 어려운 문제였다. 코드로 구현하는 과정이 굉장히 오래걸리긴 했지만, 코드를 완성하고 출력값이 한 번에 제대로 나왔다는 점에서 뿌듯했다. 코드가 되게 지저분하긴 하지만 어쨌든..ㅎ 백준에 코드 제출한 결과 40% 쯤에서 시간초과가 발생했다. 내일 시간초과를 해결하고 지저분한 코드를 깔끔하게 다시 구성해서 풀어볼 계획이다.

코드로 구현을 해나가는 과정에서, 문제의 요구사항에서 놓친 부분을 하나씩 발견하게 되어서 코드를 재구성하게 되는 일이 자꾸 발생했다. 이 문제를 푸는데 오래 걸린 원인 중 하나가 바로 이 부분이다. 앞으로 문제를 읽을 때 요구사항들을 한 번에 제대로 캐치해내도록 주의해야겠다. 그리고 이 문제의 경우 예시 출력값에서도 하나의 요구사항을 얻어냈다. 이런 점들을 잊지 말고 문제를 잘~ 풀자 ! ++ 입력을 받을 때 처리할 수 있는 부분은 바로 처리를 해버리자.

231227 알고리즘 문제 하나를 며칠씩이나 붙잡고 있다보니까, 계속 자괴감에 빠진다. 알고리즘 공부 진도가 너무 더디다. 앞으로 핸드폰 하는 시간 좀 줄여서 이제는 진짜 독하게 공부해야 겠다... 이번에도 말만 그러지 말길 나중에 코딩테스트 볼 때 내 자신을 칭찬하는 날이 오길 기대하면서 열심히 공부하자 !

2024년 2월 3일 (토) 복습 코드

package review;

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

public class p7576 {

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

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        int M = Integer.parseInt(st.nextToken());  //가로
        int N = Integer.parseInt(st.nextToken());  //세로

        int[][] tomatoes = new int[N][M];

        int notTomatoeNum = 0;

        Queue<Point> queue = new LinkedList<>();
        boolean[][] visited = new boolean[N][M];
        int[][] minDays = new int[N][M];

        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());

            for (int j = 0; j < M; j++) {
                tomatoes[i][j] = Integer.valueOf(st.nextToken());

                if (tomatoes[i][j] == 1) {
                    queue.add(new Point(j, i));
                    visited[i][j] = true;
                    minDays[i][j] = 0;
                }
                else if (tomatoes[i][j] == 0) {
                    notTomatoeNum++;
                }
            }
        }

        int[] dx = {0, 0, -1, 1};
        int[] dy = {1, -1, 0, 0};

        int changedTomatoeNum = 0;

        int result = 0;

        while(!queue.isEmpty()) {
            Point dequeue = queue.remove();

            for (int d = 0; d < 4; d++) {
                int dX = dequeue.X + dx[d];
                int dY = dequeue.Y + dy[d];

                if (dX < 0 || dX >= M || dY < 0 || dY >= N) continue;

                if (tomatoes[dY][dX] == 0) {
                    if (visited[dY][dX] == false) {
                        queue.add(new Point(dX, dY));
                        visited[dY][dX] = true;
                        minDays[dY][dX] = minDays[dequeue.Y][dequeue.X] + 1;

                        changedTomatoeNum++;
                    }
                    else {  //visited[dY][dX] == true
                        minDays[dY][dX] = ((minDays[dequeue.Y][dequeue.X] + 1) < minDays[dY][dX]) 
                                ? (minDays[dequeue.Y][dequeue.X] + 1) : minDays[dY][dX];
                    }

                    result = (minDays[dY][dX] > result) ? minDays[dY][dX] : result;
                }
            }
        }

        if (changedTomatoeNum == notTomatoeNum) {
            System.out.println(result);
            return;
        }
        else {
            System.out.println(-1);
            return;
        }

    }

}

class Point {
    int X;
    int Y;

    Point(int X, int Y) {
        this.X = X;
        this.Y = Y;
    }
}

문제 풀이

• 접근법 : BFS 한 좌표로부터 인접한 좌표를 하나씩 방문해가면서 각 좌표의 최단거리를 구해낸다.

• 풀이 과정

  1. (1,1) 좌표를 큐에 삽입하고 최단거리로 0을 저장한다.
  2. 큐의 첫번째 원소를 꺼내고, 인접한 4개의 좌표에 대해 우상좌하 순으로 '3번' 작업을 수행한다.
  3. 해당 좌표가 갈 수 있는 경로이고, 아직 방문하지 않았으면(최단거리==0인 경우) 해당 좌표의 최단거리를 dequeue한 좌표의 최단거리 + 1로 저장하고 해당 좌표를 enqueue한다.
  4. '2번'부터 '3번'까지의 작업을 큐가 빌 때까지 반복한다.

java 구현 코드

package ch08_BFS;

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

public class p2178 {

    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.valueOf(st.nextToken());  // 세로 길이 n
        int m = Integer.valueOf(st.nextToken());  // 가로 길이 m 

        char[][] mazeArr = new char[n + 2][m + 2];  // 미로를 저장할 배열

        // 미로 배열 세팅하기
        for (int i = 0; i < n; i++) { 
            String input = br.readLine();

            for (int j = 0; j < m; j++) {
                mazeArr[i + 1][j + 1] = input.charAt(j);
            }
        }

        int[] dx = {1, 0, -1, 0};  // 우상좌하
        int[] dy = {0, 1, 0, -1};

        // BFS 
        Queue<Point> queue = new LinkedList<>();  // 큐 생성
        int[][] distance = new int[n + 2][m + 2];  // 각 좌표에서 (1,1)까지 최단거리 저장 배열

        distance[1][1] = 0;  // (0,0)의 최단거리 값 0으로 세팅 (생략 가능)
        queue.add(new Point(1, 1));  // (1,1) 좌표 enqueue

        while(!queue.isEmpty()) {  // queue가 빌 때까지 반복
            Point tmp = queue.remove();  // dequeue

            int tmpX = tmp.X;
            int tmpY = tmp.Y;

            int tmpDistance = distance[tmpX][tmpY];

            for (int i = 0; i < 4; i++) {  // 꺼낸 좌표의 우상좌하 순으로 탐색
                int dX = tmpX + dx[i];
                int dY = tmpY + dy[i];

                if (mazeArr[dX][dY] == '1' && distance[dX][dY] == 0) {  // 갈 수 있는 경로인데 아직 방문 안 했으면 
                    distance[dX][dY] = tmpDistance + 1;  // dequeue한 좌표의 최단거리에 1 더하기
                    queue.add(new Point(dX, dY));  // enqueue
                }
            }
        }

        System.out.println(distance[n][m] + 1);

    }

}

class Point {
    int X;
    int Y;

    Point(int X, int Y) {
        this.X = X;
        this.Y = Y;
    }
}

comment

풀이 날짜 : 2023/12/22 (금)

내년에 코딩테스트 응시하려면 12월에 남은 며칠동안 알고리즘 공부 진도를 빨리 나가야 하는데....자꾸 공부에 집중이 잘 안 된다. 아무래도 도파민 중독으로 한 곳에 집중을 제대로 못하는 것 같다. 오늘 오전은 집에서 뒹굴거리느라 시간을 낭비했지만 오후에 뒤늦게라도 정석에 온 내 자신에게 칭찬해주자 👏

일단 오늘 하루에 후회 없도록, 핸드폰 끄고 11시까지 열심히 달려야겠다.

문제 풀이

• 접근법 : BFS, Flood Fill 한 점에서 시작되는 각각의 그림을 BFS를 이용해 파악해낸다.

• 풀이 과정

  1. 모든 배열 원소에 대해 아래 과정을 반복한다.
  2. 원솟값이 만약 1이고 아직 방문하지 않았으면 큐에 원소(좌표)를 삽입하고, 방문했다는 표시를 남긴다.
  3. 큐가 비어있지 않다면, 첫 번째 원소를 꺼내고 해당 그림의 크기를 1 증가시킨다. 그리고 해당 원소의 인접한 원소에 대해 오른쪽, 위쪽, 왼쪽, 아래쪽 순서대로 '2번'을 반복 수행한다.
  4. '3번'을 큐가 빌 때까지 반복한다.
  5. '4번' 반복문에서 탈출하면 그림의 개수를 1 증가시킨다. ⇒ 하나의 원소로부터 시작된 한 그림을 파악해낸 것!

java 구현 코드

package ch08_BFS;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class p1926 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();  // 도화지의 세로 크기 n
        int m = sc.nextInt();  // 도화지의 가로 크기 m

        int[][] pictureArr = new int[n + 2][m + 2];  // 그림 배열
        int[][] visited = new int[n + 2][m + 2];  // 처리 여부 저장 배열

        int[] dx = {1, 0, -1, 0};  // 우 상 좌 하
        int[] dy = {0, 1, 0, -1};

        for (int i = 1; i <= n; i++) {  // 그림 배열값 세팅
            for (int j = 1; j <= m; j++) {
                pictureArr[i][j] = sc.nextInt();
            }
        }


        Queue<Pair> queue = new LinkedList<>();  // 큐 생성
        int count = 0;  // 그림의 개수
        int maxSize = 0;  // 그림의 최대 크기

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {

                if (pictureArr[i][j] == 1 && visited[i][j] == 0) {  // 시작 좌표가 그림이고, 아직 방문하지 않았으면
                    int size = 0;  // 그림의 크기

                    queue.add(new Pair(i, j));  // 큐에 삽입
                    visited[i][j] = 1;  // 방문 완료 갱신

                    while (!queue.isEmpty()) {  // 큐가 비어있지 않으면 (큐가 빌 때까지 반복)
                        Pair pair = queue.remove();  // 큐에서 front 좌표를 꺼내고
                        size++;  // 해당 그림의 크기 갱신

                        for (int d = 0; d < 4; d++) {  // 해당 좌표의 주변 좌표를 우상좌하 순으로 탐색 
                            int tmpX = pair.X + dx[d];  // 주변 좌표 : (tmpX, tmpY)
                            int tmpY = pair.Y + dy[d];

                            if (pictureArr[tmpX][tmpY] == 1 && visited[tmpX][tmpY] == 0) {  // 그림이고, 아직 방문하지 않았으면
                                queue.add(new Pair(tmpX, tmpY));  // 큐에 해당 좌표 삽입
                                visited[tmpX][tmpY] = 1;  // 방문 완료 갱신
                            }
                        }
                    }
                    count++;  // 그림의 개수 갱신
                    if (size > maxSize) maxSize = size;  // 그림의 최대 크기 갱신
                }
            }
        }

        System.out.println(count + "\n" + maxSize);

    }

}

class Pair {  // 좌표 값을 저장할 자료구조 Pair 
    int X;
    int Y;

    Pair(int x, int y) {
        this.X = x;
        this.Y = y;
    }
}

문제 해결

값 갱신의 잘못된 시점으로 버그 발생

size값이 자꾸 크게 나오는 버그가 발생했다. 한시간 넘게 똑같은 코드를 바라보고 있던 결과,,, visited 배열값 갱신 시점에 문제가 있음을 발견했다. 이전에 버그가 발생한 코드는 아래와 같다.

for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {

                if (pictureArr[i][j] == 1 && visited[i][j] == 0) {  // 시작 좌표가 그림이고, 아직 방문하지 않았으면
                    int size = 0;  // 그림의 크기

                    queue.add(new Pair(i, j));  // 큐에 삽입

                    while (!queue.isEmpty()) {  // 큐가 비어있지 않으면 (큐가 빌 때까지 반복)
                        Pair pair = queue.remove();  // 큐에서 front 좌표를 꺼내고

                        for (int d = 0; d < 4; d++) {  // 해당 좌표의 주변 좌표를 우상좌하 순으로 탐색 
                            int tmpX = pair.X + dx[d];  // 주변 좌표 : (tmpX, tmpY)
                            int tmpY = pair.Y + dy[d];

                            if (pictureArr[tmpX][tmpY] == 1 && visited[tmpX][tmpY] == 0) {  // 그림이고, 아직 방문하지 않았으면
                                queue.add(new Pair(tmpX, tmpY));  // 큐에 해당 좌표 삽입
                            }
                        }
                        size++;  // 해당 그림의 크기 갱신
                        visited[pair.X][pair.Y] = 1;  // 방문 완료 갱신
                    }
                    count++;  // 그림의 개수 갱신
                    if (size > maxSize) maxSize = size;  // 그림의 최대 크기 갱신
                }
            }
        }

큐에서 꺼낸 원소(좌표)를 a라 하자. 만약 visited[pair.X][pair.Y] = 1; 이 라인을 위 코드처럼 a의 인접한 원소 4개를 탐색 완료한 후에 수행하게 되면 a가 큐에 여러 번 들어가게 되어 size++; 라인이 필요 이상으로 수행되게 된다. 따라서, visited[pair.X][pair.Y] = 1; 라인을 큐에 원소를 삽입할 때 같이 수행해주어야 한다.

Comment

풀이 날짜 : 2023/12/20 (수)

바킹독 BFS 강의를 듣고 파이썬 샘플 코드를 참고하여 처음으로 스스로 구현한 BFS 문제이다. 알고리즘 문제를 단순히 코드로 구현하는 것에서 그치지 않고, 남에게 문제를 설명하고, 문제풀이 접근 방법과 내가 구현한 코드에 대해 설명할 수 있도록 실력을 키우는 것이 나의 알고리즘 공부 목표이다. 1월에는 알고리즘 스터디에 참여해볼 계획이다. 내 코드를 남들에게 공유해도 부끄럽지 않을 수 있게, 남은 12월 동안 얼른 개념 공부 끝내고 문제 많~이 풀어야겠다. 파이팅 !

Question #76 AWS 클라우드 사용의 장점은 무엇입니까? (2개를 선택하세요.) A. 필요에 따라 조정되는 컴퓨팅 용량 / 강화된 보안

Question #77 사용자가 Amazon S3에 객체를 저장하고 있습니다. 사용자는 규정 준수 의무를 충족하기 위해 개체에 대한 액세스를 제한해야 합니다. 이 요구 사항을 충족하려면 사용자가 무엇을 해야 합니까? A. S3 버킷의 객체에 태그를 지정합니다.

Question #80 회사에는 여러 부서가 있습니다. 각 부서에는 해당 애플리케이션에 대한 자체 AWS 계정이 있습니다. 회사는 지불을 단순화하기 위해 모든 AWS 비용을 단일 송장으로 원하지만 회사는 각 부서에서 발생하는 비용을 알고 싶어합니다. 이 기능을 제공하는 AWS 도구 또는 기능은 무엇입니까? A. Consolidated billing

Question #81 회사는 온프레미스에서 워크로드를 실행합니다. 이 회사는 AWS에서 대규모 애플리케이션을 실행하는 비용을 예측하려고 합니다. 회사에서 이 정보를 얻기 위해 사용할 수 있는 AWS 서비스 또는 도구는 무엇입니까? A. AWS Pricing Calculator VS Cost Explorer <- 기존 서비스에 대한 비용

Question #83 사용자에게 AWS 인프라, AWS 서비스, API 및 도구를 데이터 센터, 코로케이션 환경 또는 온프레미스 시설로 확장할 수 있는 기능을 제공하는 하이브리드 아키텍처를 지원하는 AWS 서비스 A. AWS Outposts

Question #87 Amazon VPC에서 인바운드 및 아웃바운드 트래픽에 대한 정보를 캡처하는 데 사용할 수 있는 AWS 서비스 또는 도구는 무엇입니까? A. VPC Flow Logs

Question #89 회사는 어떤 상황에서 IAM 역할 대신 IAM 사용자를 생성해야 합니까? (두 가지를 선택하세요.) A. B. 회사가 개인의 AWS 접근 자격 증명을 생성하는 경우 / 회사에서 IAM 그룹에 사용자를 추가해야 하는 경우

Question #94 다음 중 AWS 클라우드 아키텍처에 권장되는 설계 원칙은 무엇입니까? A. 워크로드를 세분화하여 모놀리식 아키텍처를 피하십시오.

Question #95 한 회사는 구성 요소가 정기적으로 업데이트되고 변경 사항이 되돌릴 수 있는 작은 증분으로 이루어질 수 있도록 AWS 워크로드를 설계하고 있습니다. 이 설계는 AWS Well-Architected 프레임워크의 어떤 요소를 지원합니까? A. 운영 우수성

Question #96 인바운드 및 아웃바운드 액세스를 제어하는 인스턴스 수준 방화벽 역할을 하는 것 A. Security Groups

Question #100 서브넷 수준에서 VPC 방화벽 역할을 하는 AWS 도구 또는 기능은 무엇입니까? A. Network ACL VS Security Groups (인스턴스 수준 방화벽)

Question #26 온프레미스 대신 AWS 클라우드에서 애플리케이션을 호스팅하기 위해 Amazon EC2 인스턴스를 사용하면 어떤 이점이 있습니까? (두 가지를 선택하세요.) A. EC2는 Amazon VPC, AWS CloudTrail 및 AWS Identity and Access Management(IAM)와 통합됩니다. / EC2에는 유연한 종량제 요금 모델이 있습니다.

Question #29 Amazon EC2 인스턴스의 방화벽 역할을 하는 AWS 서비스 또는 기능은 무엇입니까? A. Security group 보안 그룹

Question #41 AWS 공동 책임 모델에 따라 AWS의 책임은 무엇입니까? (2개 선택) A. 네트워크 인프라의 펌웨어를 업그레이드한다. / 엣지 로케이션의 물리적 보안을 유지한다.

Question #42 AWS 클라우드에서 사용되는 네트워크 ACL의 기능은 무엇입니까? (2개 선택) A. stateless 방식을 사용한다. / 트래픽 허용 여부를 결정할 때 가장 낮은 번호의 규칙부터 순서대로 처리한다.

Question #47 AWS 클라우드에서 종속 구성 요소 간의 장애를 격리해야 하는 필요성을 설명하는 아키텍처 설계 원칙은 무엇입니까? A. 느슨하게 결합된 구성 요소

Question #49 한 회사에서 애플리케이션의 여러 AWS 서비스에 대해 AWS 프리 티어를 사용하고 있습니다. 프리 티어 사용 기간이 만료되거나 애플리케이션 사용이 프리 티어 사용 한도를 초과하면 어떻게 됩니까? A. 프리 티어 사용량을 초과하는 사용량에 대해서는 표준 종량제 서비스 요금을 회사에서 청구합니다.

Question #50 한 회사가 최근 VPC에 Amazon RDS 인스턴스를 배포했습니다. 회사는 개인 회사 네트워크에 대한 트래픽을 제한하기 위해 상태 저장 방화벽을 구현해야 합니다. 네트워크 트래픽을 RDS 인스턴스로 직접 제한하기 위해 회사에서 사용해야 하는 AWS 서비스 또는 기능은 무엇입니까? A. Security Groups 보안 그룹

Question #59 한 회사가 다가오는 이벤트를 위해 많은 트래픽을 받을 것으로 예상되는 새로운 웹 스토어를 시작하려고 준비하고 있습니다. 웹 스토어는 AWS에서만 실행되며 회사에는 AWS Enterprise Support 계획이 있습니다. 이벤트 기간 동안 회사가 아키텍처 및 운영 지원을 확장하는 방법에 대한 지침을 제공하는 AWS 리소스는 무엇입니까? A. AWS Infarastructure Event Management (IEM)

Question #62 AWS 공유 책임 모델에 따라 AWS와 고객이 공유하는 IT 제어는 무엇입니까? (두 가지를 선택하세요.) A. 패치 관리, 클라우드 인식 및 교육

Question #64 제조 회사에는 인터넷 연결 속도가 느린 원격 사이트에서 실행되는 중요한 응용 프로그램이 있습니다. 회사는 워크로드를 AWS로 마이그레이션하려고 합니다. 애플리케이션은 대기 시간과 연결 중단에 민감합니다. 회사는 대기 시간을 최소화하면서 이 애플리케이션을 호스팅할 수 있는 솔루션을 원합니다. 이러한 요구 사항을 충족하기 위해 회사에서 사용해야 하는 AWS 서비스 또는 기능은 무엇입니까? A. AWS Outposts

Question #65 회사는 온프레미스 데이터 센터에서 AWS 클라우드의 VPC로 애플리케이션을 마이그레이션하려고 합니다. 이러한 애플리케이션은 온프레미스 리소스에 액세스해야 합니다. 이러한 요구 사항을 충족하는 조치는 무엇입니까? (두 가지를 선택하세요.) A. 온프레미스 장치와 VPC의 가상 프라이빗 게이트웨이 간에 VPN 연결을 생성합니다. / Amazon CloudFront 배포를 사용하고 온프레미스 리소스에 가까운 콘텐츠 전송을 가속화하도록 구성합니다.

Question #68 엣지 로케이션을 사용하는 AWS 서비스 A. AWS Global Accelerator

Qustion #70 액세스 정책을 확인하고 사용자가 안전하고 기능적인 정책을 설정하는 데 도움이 되는 실행 가능한 권장 사항을 제공하는 AWS 서비스 또는 기능은 무엇입니까? A. AWS IAM Access Analyzer

Qustion #72 소매 회사는 새로운 전자 상거래 플랫폼을 위한 고가용성 아키텍처를 구축해야 합니다. 이 회사는 여러 가용 영역에서 데이터를 복제하는 AWS 서비스만 사용하고 있습니다. 회사는 이 요구 사항을 충족하기 위해 어떤 AWS 서비스를 사용해야 합니까? (두 가지를 선택하세요.) A. Amazon Aurora, Amazon DynamoDB => Aurora, DynamoDB는 여러 가용 영역에서 데이터 복제 가능

AWS 클라우드 입문서 "당신이 지금 알아야 할 AWS" 를 읽고 정리한 글입니다.

EC2 서비스 요금

• 온디맨드 요금제 고정 금액으로 EC2의 컴퓨팅 파워를 시간당 또는 초당 비용으로 지불하게 된다. 온디멘드 요금제는 상대적으로 비용이 비싸기 때문에 개발용이나 테스트를 위한 인스턴스 그리고 단기간 혹은 예정되어 있지 않는 작업 등에 사용할 때 적합하다.
  1. 선결제 금액이나 장기 약정 없이 저렴하고 유연하게 Amazon EC2를 사용하기 원하는 사용자
  2. 단기에 갑작스럽게 예측할 수 없는 워크로드가 있으며, 중단되어서는 안 되는 애플리케이션
  3. Amazon EC2에서 처음으로 개발 또는 시험 중인 애플리케이션
     
• 예약 인스턴스 예약 인스턴스는 계약 기간에 따라 최대 75%까지 저렴한 비용으로 사용할 수 있는 요금제이다. 통상적으로 1년 혹은 3년 약정과 같이 일정 기간 동안 계약을 하는 요금제이다.
  1. 수요가 꾸준한 애플리케이션
  2. 예약 용량이 필요할 수 있는 애플리케이션
  3. 총 컴퓨팅 비용 절감을 위해 1년 또는 3년 동안 EC2를 사용하기로 약정할 수 있는 고객
     
• 전용 호스팅 전용 호스팅은 고객 전용의 물리적 EC2 가상 서버이다.
  1. 온디맨드로 구매 가능(시간당)
  2. 온디맨드 요금과 비교하여 최대 70% 할인된 예약 인스턴스로 구매 가능
     
• 스팟 인스턴스 스팟 인스턴스는 입찰 가격을 정해놓고 가장 비싼 요금을 입찰한 사람에게 컴퓨팅 파워를 제공하는 요금제이다.
  1. 시작 및 종료 시간이 자유로운 애플리케이션
  2. 컴퓨팅 가격이 매우 저렴 해야만 수익이 나는 애플리케이션
  3. 대량의 서버 용량 추가로 긴급히 컴퓨팅 파워가 필요한 사용자

AWS 클라우드 입문서 "당신이 지금 알아야 할 AWS" 를 읽고 정리한 글입니다.

AWS 인프라 구성 요소

• ** 리전 (Region) ✔️ ** AWS는 물리적으로 떨어진 지역에 여러 개의 클라우드 인프라를 운영하는데, 이 지역을 어원 그대로 리전(region)이라고 부른다. AWS는 전 세계 20여 곳의 리전을 제공하고 있고, 각 리전은 물리적으로 완전히 분리되어 있으며, AWS 콘솔 상에서도 완전히 다른 리소스로 구분한다.
  

• ** 가용 영역 (Availability Zone) ✔️ ** AWS 서비스가 리전들의 집합이라면, 리전은 가용 영역(Availability Zone)들의 집합니다. 여러 개의 가용 영역이 모여 리전을 구성한다. 가용 영역은 데이터 센터이다. 각 가용 영역은 실제 물리적으로는 완전히 독립되어 있지만, AWS 콘솔에서 리소스별로 구분하지는 않는다. 하나의 리전은 여러 개의 가용 영역으로 이루어져 있다. 이는 다시 말해, 서울 리전이라는 리전 아래 여러 개의 데이터 센터가 운영되고 있다는 의미이다. 가용 영역을 여러 곳에 두고 운영한다면, 하나의 가용 영역에 문제가 발생해도 단순한 변경만으로 가용 영역을 운영할 수 있다. 이러한 특징을 ** 가용성(Availability) **이라고 부른다.

  컴퓨터에서 가용성은 서버, 네트워크, 프로그램 등이 정상적으로 사용 가능한 정도를 나타낸다. 서비스 가동률로 이해하면 된다. 
  AWS가 높은 가용성을 자랑하는 이유는 2개 이상의 가용 영역을 사용하여 높은 가동률을 보장할 수 있기 때문이다.

  참고: 모든 AWS상의 서비스들은 ARN(Amazon Resource Number)이라는 번호가 붙는다.

• 에지 로케이션 (Edge Location) 에지 로케이션(Edge Location)은 리전에 속한 ‘리전 에지 캐시’를 통해 데이터 속도를 개선한다. 에지 로케이션은 CDN(Content Delivery Network)을 이루는 캐시 서버이다. CDN은 웹 콘텐츠를 전달하기 위한 최적화된 네트워크로서, 대표적인 클라우드 CDN 서비스로 AWS의 클라우드 프론트 등이 있다.

AWS 클라우딩 서비스

인스턴스는 AWS에 구축된 1대의 가상 서버를 의미한다. 
AWS 컴퓨팅 서비스는 인스턴스를 시작할 때 지정하는 유형에 따라, 인스턴스에 사용되는 호스트 컴퓨터의 하드웨어가 결정된다. 
각 인스턴스 유형은 서로 다른 컴퓨팅, 메모리, 스토리지 용량을 제공하는데, 이 용량에 따라 서로 다른 인스턴스 패밀리로 분류된다. 
인스턴스에서 실행하려는 애플리케이션 또는 소프트웨어의 요구사항에 따라 인스턴스 유형을 선택하게 된다.

• 컴퓨팅 클라우드 환경에서 컴퓨팅이란 가상 서버를 중심으로 컴퓨터 인프라를 이용하는 서비스를 말한다.

  • EC2 EC2는 ‘엘라스틱 컴퓨터 클라우드’(Elastic Compute Cloud)의 약자로, 종량제 형태로 과금이 되는 가상 서버라고 생각하면 된다.

  • 람다 AWS 람다는 특정한 이벤트를 통해 입력 인자가 발생하면 연산 과정으로 출력 인자를 바꾸는 이벤트 기반의 컴퓨팅 서비스이다. EC2와는 다르게 오직 소스코드만 사용하여 인프라에 대한 관리가 필요하지 않은 완전 관리형 컴퓨팅 서비스이다.
    

  • ECS ECS는 AWS에서 제공하는 도커 컨테이너 서비스이다.
    

  • 라이트세일
    
    

  • 빈스톡

  
  
  

• 스토리지 스토리지란 파일을 보관하거나 관리하는 저장 장소를 의미한다.

  • S3 (Simple Storage Service) 아마존 웹 서비스에서 가장 역사가 오래된 서비스이며, 다른 상용 클라우드에 비해 월등한 성능을 보여주는 스토리지 서비스이다. S3는 뛰어난 안정성과 보안이 완벽한 스토리지를 손쉽게 만들 수 있게 해주며 서비스 운영 시 생성되는 이미지, 동영상, 오디오 파일들을 저장할 수 있게 한다.
    

  • 글래시어 (Glacier) AWS(Amazon Web Services)의 Glacier는 저비용으로 데이터를 장기 보관(ex 백업, 아카이브 등)하는 데 사용되는 클라우드 기반의 스토리지 서비스이다. S3 서비스는 언제든 빠른 시간 내에 트래픽을 처리할 수 있게 만들어졌기 때문에 항상 리소스를 대기하는 상태로 유지한다. 저렴한 저장 비용을 자랑하고, S3에 비해서 트래픽 요금이 다소 높기 때문에 저장된 데이터의 사용 빈도가 낮은 경우에는 글래시어(Glacier) 서비스가 적합하다.
    

  • 스토리지 게이트웨이 (Storage Gateway) 스토리지 게이트웨이 서비스는 기존 온프로미스 환경과 AWS를 연결해주는 게이트웨이 서비스이다.
    

  • EBS (Elastic Block Storage) EBS는 EC2와 연결할 수 있는 저장 장치 서비스이다.

• 데이터베이스

  • RDS 전통적인 관계형 데이터베이스(RDBMS)를 구축하는 서비스이다.
    - **다이나모 DB (Dynamo DB) ✔️** 다이나모 DB는 No-SQL 기반의 완전 관리형 데이터베이스이다.
    - **엘라스틱 캐시 (Elasticache)** RDS와 다이나모 DB가 SSD 영역에서 입출력이 수행되는데 반해, 엘라스틱 캐시(Elasticache)는 메모리에 데이터를 저장하여 더욱 빠르게 입출력이 가능하다.
    - **Red Shift**
    

• 네트워크 AWS에서 아키텍처 3계층에 대한 서비스를 다루며, 간단히 인터넷 연결과 내부 인터넷(인프라)에 대한 서비스를 담당한다.

  • VPC VPC(Virtual Private Cloud)는 AWS에서 ‘가상 네트워크망’(VPN, Virtual Private Network) 구축 지원 서비스이다. 서비스 보안 수준을 결정하거나 EC2나 RDS와 같은 AWS 서비스들에 적합한 권한이 있는 사용자들만 접속할 수 있게 한다.
    

  • Route53 AWS에서 제공하는 DNS(Domain Name System) 서비스이다. 도메인을 AWS 리소스와 연결할 때 사용된다.
    

  • 클라우드 프론트 (CloudFront) ✔️

• 인공지능

  • 폴리
    

• 렉스
  

• 레코그니션
  
  

• 데이터 분석

  • 퀵사이트 (QuickSight)

    
    

  • 아테나 (Athena) ✔️

    AWS(Amazon Web Services)에서의 "서버리스"는 서버 관리에 대한 개발자의 부담을 줄이고 애플리케이션을 구축하고 실행하는 방식을 말합니다. 서버리스 컴퓨팅은 개발자가 서버 인프라를 프로비저닝하거나 관리하는 데 필요한 작업을 최소화하여 개발과 배포를 단순화합니다. 아테나는 서버리스 기반 SQL 쿼리 서비스이다. 서버리스 서비스이기 때문에 따로 구축해야 할 서버가 필요하지 않고, S3에 저장된 데이터를 SQL문을 통해 원하는 결과를 얻을 수 있다.

    
    

  • 클라우드 서치 (CloudSearch)

    
    

  • EMR

    
    

  • 키네시스 (Kinesis) ✔️ 키네시스 서비스는 실시간 데이터 처리를 위한 서비스이다. AWS 데이터베이스 서비스나 외부의 데이터를 실시간으로 분석하여 처리하고 결과를 보여준다.
    

    
    

• 개발자 도구

  • 코드 빌드

  • 코드 커밋

  • 코드 디플로이

  • 코드 파이프라인

• AWS 마켓플레이스

  AWS 마켓플레이스는 구매자가 AWS에서 실행되는 소프트웨어를 검색, 구매 및 빠르게 배포할 수 있는 온라인 스토어이다.

AWS 클라우드 입문서 "당신이 지금 알아야 할 AWS" 를 읽고 정리한 글입니다.

에지 컴퓨팅 (Ege Computing) IoT 기기나 네트워크 가장자리에서 데이터를 분산 처리하는 ‘분산 클라우드 컴퓨팅’ ⇒ 클라우드 컴퓨팅은 각종 디바이스에서 수집한 데이터를 멀리 떨어져 있는 데이터 센터에서 처리한 뒤, 이를 다시 기기로 송신하는 과정을 거치는 과정을 거친다. 이 과정에서 필연적으로 발생하는 지연 시간을 보완해주는 기술이 바로 ‘에지 컴퓨팅’이다.

클라우드 컴퓨팅 (Cloud Computing) 현재는 서버를 소유하는 것이 아니라, 필요할 때마다 사용하는 클라우드 컴퓨팅 환경으로 발전하고 있다. 클라우드 컴퓨팅은 컴퓨터의 각종 연산 및 처리를 개인 PC가 아닌 인터넷 공간, 다시 말해 클라우드에서 처리하는 방식을 말한다.

** 오토 스케일링 (Auto Scaling) ✔️ ** 트래픽 폭주에 맞춰 기업이 별도로 인프라를 확충하지 않아도 알아서 인프라를 늘렸다가, 트래픽이 줄어들면 이에 맞춰 인프라를 줄이는 자동 트래픽 증감 기술, ‘오토 스케일링’이 개발되어 기업이 더욱 편리하게 관리할 수 있게 해준다.

**온프레미스 (On-premise) ✔️ ** 기업이 자체적으로 데이터 센터를 보유하고 시스템 구축부터 운영까지, 모두 수행하는 형태

클라우드 서비스를 배포하는 방식 3가지

• 공용 클라우드(Public Cloud) 공용 클라우드를 사용할 경우 모든 하드웨어, 소프트웨어,및 기타 지원 인프라를 클라우드 공급자가 소유하고 관리한다. 사용자는 웹 브라우저를 사용해 서비스에 액세스하고 계정 관리만 하면 된다.
• 사설 클라우드(Private Cloud) 사설 클라우드는 단일 비즈니스 또는 조직에서 독점적으로 사용되는 클라우드 컴퓨팅 리소스를 의미한다. 서비스와 인프라가 개인 네트워크 환경에서 유지 및 관리되는 클라우드이다.
• 하이브리드 클라우드(Hybrid Cloud) 하이브리드 클라우드는 공용 클라우드와 사설 클라우드 사이 데이터와 응용 프로그램을 공유할 수 있는 기술로, 함께 연결된 공용 클라우드와 사설 클라우드를 결합하는 구조를 의미한다.

클라우드 컴퓨팅 서비스 유형

클라우드 서비스는 어떤 자원을 제공하느냐(중앙의 컴퓨팅 활용도)에 따라 이처럼 크게 3가지로 구분된다.

• IaaS(Infrastructure as a Service)
• PaaS(Platform as s Service)
• Saas(Software as a Service)

클라우드 핵심 기술

가상 서버
- 가상 서버는 하나의 물리적인 서버와 마찬가지로 개별 운영체제나 애플리케이션을 실행시킬 수 있다. 
- 가상 서버는 하나의 물리적 서버를 논리적으로 나누어 CPU, 메모리 등의 자원을 할당한 것이다. 
- AWS는 포털 화면에서 가상 서버를 설정하면 몇 분 만에 사용할 수 있고, 중지 · 다시 시작 · 삭제 등도 쉽게 제어할 수 있다. 
- AWS에는 대표적으로 EC2가 있으며, 가상 서버의 서비스 가격은 가상 CPU의 성능 및 메모리 용량 등에 따라 가격이 결정된다.

• 가상화 기술
  • 호스트 가상화 하드웨어 위에 기본이 되는 호스트 운영체제를 설치하고, 호스트 운영체제에 가상화 SW(하이퍼바이저)를 설치한다. 호스트 가상화는 가상화 SW 위에 게스트 운영체제를 작동시키는 가상화를 말한다. 호스트 운영체제 위에 게스트 운영체제를 작동시키기 때문에 필요 이상으로 CPU나 메모리 사용이 증가하는 오버헤드가 발생한다.
  • 하이퍼바이저 가상화 하드웨어에 가상화를 전담하는 SW인 하이퍼바이저를 배치해 HW와 가상 환경을 제어한다. 호스트가 없는 HW를 직접 제어하기 때문에 컴퓨팅 자원을 효율적으로 사용할 수 있다. 하지만 환경별로 다른 운영체제가 작동하기 때문에 가상 환경을 사용하기 위한 오버헤드가 발생한다.
  • 컨테이너 가상화 호스트 가상화, 하이퍼바이저 가상화처럼 운영체제를 여러 개 가동시키면 이것만으로도 많은 자원이 필요하다. 따라서 운영체제에 논리적인 영역(컨테이너)을 만들고, 애플리케이션을 작동하는 데 필요한 라이브러리와 애플리케이션 등을 컨테이너 안에 넣어, 마치 개별 서버처럼 사용할 수 있게 한 것이 바로 이 컨테이너 가상화이다. 최근 가상화 및 클라우드 컴퓨팅 영역에서 가장 각광받고 있는 것이 바로 도커(Docker)이다.

• 분산 처리 기술

• 서버리스 (Serverless)

• 로드 밸런싱 (Load Balancing) 로드 밸런싱은 컴퓨터 자원 분산 기술의 일종으로 둘 혹은 셋 이상의 중앙처리장치 혹은 저장 장치와 같은 컴퓨터 자원들의 작업을 나누는 것을 의미한다.

• 스케일 업과 스케일 아웃

  • 스케일 업(Scale-Up) 서버 자체의 성능을 업그레이드하여 처리 능력을 향상시키는 방법
  • 스케일 아웃(Scale-Out) 물리적으로 서버를 늘려서 시스템을 확장하는 방법 ⇒ 로드 밸런싱 기술이 필수

• 오토 스케일(Auto Scale) 오토 스케일은 서비스가 집중되었을 때 서버 CPU 및 메모리 사용량이 일정 사용량을 초과하면 자동으로 가상 서버 대수를 증감시키는 기능을 말한다.

• 데브옵스(DevOps) 개발팀(Development)과 운영팀(Operation) 간의 소통이 원활히 이루어질 수 있도록 하는 것

• 서비스 프로비저닝

AWS Artifact는 AWS에서 제공하는 서비스 중 하나로, 사용자들이 AWS 보안 및 규정 준수 관련 문서에 액세스할 수 있는 플랫폼입니다. 
AWS Artifact는 다양한 보안 및 규정 준수 문서를 제공하며, 이는 사용자들이 각종 감사, 규제, 보안 검토 및 인증을 위해 필요한 문서를 쉽게 찾고 다운로드할 수 있도록 합니다.

Qustion #14
회사는 Amazon S3를 사용하는 data lake를 만들 계획이다. 비용에 가장 큰 영향을 미치는 요소는 무엇입니까? A. S3 스토리지 계층 선택

Qustion #20
AWS 계정 루트 사용자 자격 증명을 사용해야 하는 작업 A. AWS Support 플랜 변경

Qustion #21 회사는 서로 다른 사용자의 수백 건의 요청을 동시에 처리해야 합니다. 회사는 운영상 효율적인 솔루션을 구축하기 위해 어떤 AWS 서비스 조합을 사용해야 합니까? A. Amazon Simple Queue Service(Amazon SQS) 및 AWS Lambda

Qustion #22 AWS 네트워크 내에서 VPC의 범위는 어떻게 됩니까? A. VPC는 AWS 리전 내의 모든 가용 영역에 걸쳐 있을 수 있습니다.

Qustion #23 다음 중 AWS Site-to-Site VPN 연결의 구성 요소는 무엇입니까? (두 가지를 선택하세요.) A. Virtual private gateway, Customer gateway