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

#include <iostream>
#include <vector>
#include <queue>

#define endl "\n"
#define MAX 25
using namespace std;

int r, c, k, w;
int map[MAX][MAX];
bool wallMap[MAX][MAX][4];

vector<pair<int, int>> searchPos;
vector<pair<pair<int, int>, int>> heater;
vector<pair<pair<int, int>, int>> wall;

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

int wdx[4][3] = { { -1, 0, 1 }, {-1, 0, 1 }, {1, 1, 1}, {-1, -1, -1} };
int wdy[4][3] = { { 1, 1, 1}, { -1, -1, -1 }, {-1, 0, 1 },{-1, 0, 1} };

void printMap(int A[][MAX]) {
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            printf("%2d ", A[i][j]);
        }
        cout << endl;
    }
    cout << "#######################################################" << endl;
}

void input() {
    cin >> r >> c >> k;
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            cin >> map[i][j];
            if (map[i][j] != 0 && map[i][j] != 5) {
                heater.push_back(make_pair(make_pair(i, j), map[i][j]));
            }
            else if (map[i][j] == 5) {
                searchPos.push_back(make_pair(i, j));
            }
            map[i][j] = 0;
        }
    }
    cin >> w;
    for (int i = 0; i < w; i++) {
        int a, b, c; cin >> a >> b >> c;
        wall.push_back(make_pair(make_pair(a, b), c));
    }
}

void settingWall() {
    for (int i = 0; i < w; i++) {
        int x = wall[i].first.first;
        int y = wall[i].first.second;
        int t = wall[i].second;

        if (t == 0) {
            wallMap[x][y][3] = true;
            wallMap[x - 1][y][2] = true;
        }
        else {
            wallMap[x][y][0] = true;
            wallMap[x][y + 1][1] = true;
        }
    }
}

bool check() {
    for (int i = 0; i < searchPos.size(); i++) {
        int x = searchPos[i].first;
        int y = searchPos[i].second;
        if (map[x][y] < k) return false;
    }
    return true;
}

int changeMydir(int d) {
    switch (d) {
    case 1:
        return 0;
    case 2:
        return 1;
    case 3:
        return 3;
    case 4:
        return 2;
    }
}

void copyMap(int A[][MAX], int B[][MAX]) {
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            A[i][j] = B[i][j];
        }
    }
}

bool checkWall(int x, int y, int nx, int ny, int d, int dir) {
    if (dir == 1) {
        if (wallMap[x][y][d] == false) return true;
    }
    else if(dir == 0){
        if (d == 0) {
            int upx = x - 1;
            int upy = y;
            if (wallMap[x][y][3] == false && wallMap[upx][upy][0] == false) return true;
        }
        else if (d == 1) {
            int upx = x - 1;
            int upy = y;
            if (wallMap[x][y][3] == false && wallMap[upx][upy][1] == false) return true;
        }
        else if (d == 2) {
            int dnx = x;
            int dny = y - 1;
            if (wallMap[x][y][1] == false && wallMap[dnx][dny][2] == false) return true;
        }
        else if (d == 3) {
            int dnx = x;
            int dny = y - 1;
            if (wallMap[x][y][1] == false && wallMap[dnx][dny][3] == false) return true;
        }
    }
    else if (dir == 2) {
        if (d == 0) {
            int upx = x + 1;
            int upy = y;
            if (wallMap[x][y][2] == false && wallMap[upx][upy][0] == false) return true;
        }
        else if (d == 1) {
            int upx = x + 1;
            int upy = y;
            if (wallMap[x][y][2] == false && wallMap[upx][upy][1] == false) return true;
        }
        else if (d == 2) {
            int dnx = x;
            int dny = y + 1;
            if (wallMap[x][y][0] == false && wallMap[dnx][dny][2] == false) return true;
        }
        else if (d == 3) {
            int dnx = x;
            int dny = y + 1;
            if (wallMap[x][y][0] == false && wallMap[dnx][dny][3] == false) return true;
        }
    }
    return false;
}

void addMap(int A[][MAX], int B[][MAX]) {
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            A[i][j] += B[i][j];
        }
    }
}

void spread(int x, int y, int d) {
    bool update[MAX][MAX] = { false, };
    d = changeMydir(d);
    x += dx[d];
    y += dy[d];
    if (x < 1 || y < 1 || x > r || y > c) return;

    queue<pair<pair<int, int>, int >> q;
    q.push(make_pair(make_pair(x, y), 5));

    while (q.empty() == 0) {
        int x = q.front().first.first;
        int y = q.front().first.second;
        int wind = q.front().second;
        q.pop();

        map[x][y] += wind;
        if (wind == 1) continue;

        for (int i = 0; i < 3; i++) {
            int nx = x + wdx[d][i];
            int ny = y + wdy[d][i];
            if (nx >= 1 && ny >= 1 && nx <= r && ny <= c) {
                if (update[nx][ny] == false && checkWall(x, y, nx, ny, d, i) == true) {
                    update[nx][ny] = true;
                    q.push(make_pair(make_pair(nx, ny), wind - 1));
                }
            }
        }
    }
}

void spreadWind() {
    for (int i = 0; i < heater.size(); i++) {
        int x = heater[i].first.first;
        int y = heater[i].first.second;
        int d = heater[i].second;
        spread(x, y, d);
    }
}

void controlTemperature() {
    int tempMap[MAX][MAX] = { 0, };
    for (int x = 1; x <= r; x++) {
        for (int y = 1; y <= c; y++) {
            for (int i = 0; i < 2; i++) {
                int dir = i == 0 ? 0 : 2;
                int nx = x + dx[dir];
                int ny = y + dy[dir];
                if (nx >= 1 && ny >= 1 && nx <= r && ny <= c) {
                    if (wallMap[x][y][dir] == false) {
                        pair<int, int> maxCoord, minCoord;
                        if (map[x][y] > map[nx][ny]) {
                            maxCoord = { x, y };
                            minCoord = { nx, ny };
                        }
                        else {
                            maxCoord = { nx, ny };
                            minCoord = { x, y };
                        }

                        int diff = abs(map[x][y] - map[nx][ny]);
                        diff /= 4;
                        tempMap[maxCoord.first][maxCoord.second] -= diff;
                        tempMap[minCoord.first][minCoord.second] += diff;
                    }
                }
            }
        }
    }
    addMap(map, tempMap);
}

void decreaseTemperature() {
    for (int i = 1; i <= c; i++) {
        if (map[1][i] > 0) map[1][i]--;
        if (map[r][i] > 0) map[r][i]--;
    }
    for (int i = 2; i < r; i++) {
        if (map[i][1] > 0) map[i][1]--;
        if (map[i][c] > 0) map[i][c]--;
    }

}

void solution() {
    settingWall();
    int chocolate = 0;
    while (1) {
        if (chocolate > 100) {
            break;
        }
        spreadWind();
        controlTemperature();
        decreaseTemperature();
        chocolate++;

        if (check() == true) {
            break;
        }
    }
    cout << chocolate << endl;
}

void solve() {
    input();
    solution();
}

int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    solve();

    return 0;
}

사용자를 인증하고 토큰을 발급함

토큰

1. access token : 사용자 정보 기반의 API 호출에 쓰임
2. refresh token : 일정기간동안 사용자 인증 절차를 거치지 않고도 엑세스 토큰을 갱신하도록 해줌

• 토큰 발행 절차 1) 카카오계정 인증 2) 사용자 동의 (이미 동의한 경우, 건너뛰기) 3) Authorization Code - 인가코드 발급 4) 인가코드로 OAuthToken - 토큰 발급

[1] 카카오 로그인

1. 카카오톡으로 로그인 카톡에 연결된 계정 및 인증정보 사용

2. 카카오 계정으로(웹 브라우저로) 로그인 직접 계정정보 입력

3. 인증을 완료한 뒤, 사용자에게 앱 이용 관련 동의를 요청하는 동의 화면을 출력합니다. 동의 화면에서 사용자가 모든 필수 항목에 동의하고 [동의하고 계속하기]를 선택하면 Android SDK는 인가 코드 및 토큰 발급을 진행하여 카카오 로그인을 완료합니다.

[2] 토큰 존재여부 확인

기존에 발급받은 엑세스토큰 or 리프레시토큰 존재 여부를 bool로 확인

• hasToken()의 API 결과가 False ➡️ 토큰 없음 ➡️ 로그인 필요
• hasToken()의 API 결과가 True ➡️ 엑세스토큰 유효성 확인 ➡️ 성공시 엑세스토큰 반환, 실패시 재로그인 필요

[3] 카카오 로그아웃

• API 요청 성공여부 상관 없이, SDK에서 토큰 삭제하면 됨

[4] 사용자 정보

• 동의 시 회원번호, 이메일, 닉네임, 프로필사진 가져올 수 있음

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

문제

부동산 투자로 억대의 돈을 번 상도는 최근 N×N 크기의 땅을 구매했다. 상도는 손쉬운 땅 관리를 위해 땅을 1×1 크기의 칸으로 나누어 놓았다. 각각의 칸은 (r, c)로 나타내며, r은 가장 위에서부터 떨어진 칸의 개수, c는 가장 왼쪽으로부터 떨어진 칸의 개수이다. r과 c는 1부터 시작한다.

상도는 전자통신공학과 출신답게 땅의 양분을 조사하는 로봇 S2D2를 만들었다. S2D2는 1×1 크기의 칸에 들어있는 양분을 조사해 상도에게 전송하고, 모든 칸에 대해서 조사를 한다. 가장 처음에 양분은 모든 칸에 5만큼 들어있다.

매일 매일 넓은 땅을 보면서 뿌듯한 하루를 보내고 있던 어느 날 이런 생각이 들었다.

나무 재테크를 하자!

나무 재테크란 작은 묘목을 구매해 어느정도 키운 후 팔아서 수익을 얻는 재테크이다. 상도는 나무 재테크로 더 큰 돈을 벌기 위해 M개의 나무를 구매해 땅에 심었다. 같은 1×1 크기의 칸에 여러 개의 나무가 심어져 있을 수도 있다.

이 나무는 사계절을 보내며, 아래와 같은 과정을 반복한다.

봄에는 나무가 자신의 나이만큼 양분을 먹고, 나이가 1 증가한다. 각각의 나무는 나무가 있는 1×1 크기의 칸에 있는 양분만 먹을 수 있다. 하나의 칸에 여러 개의 나무가 있다면, 나이가 어린 나무부터 양분을 먹는다. 만약, 땅에 양분이 부족해 자신의 나이만큼 양분을 먹을 수 없는 나무는 양분을 먹지 못하고 즉시 죽는다.

여름에는 봄에 죽은 나무가 양분으로 변하게 된다. 각각의 죽은 나무마다 나이를 2로 나눈 값이 나무가 있던 칸에 양분으로 추가된다. 소수점 아래는 버린다.

가을에는 나무가 번식한다. 번식하는 나무는 나이가 5의 배수이어야 하며, 인접한 8개의 칸에 나이가 1인 나무가 생긴다. 어떤 칸 (r, c)와 인접한 칸은 (r-1, c-1), (r-1, c), (r-1, c+1), (r, c-1), (r, c+1), (r+1, c-1), (r+1, c), (r+1, c+1) 이다. 상도의 땅을 벗어나는 칸에는 나무가 생기지 않는다.

겨울에는 S2D2가 땅을 돌아다니면서 땅에 양분을 추가한다. 각 칸에 추가되는 양분의 양은 A[r][c]이고, 입력으로 주어진다.

K년이 지난 후 상도의 땅에 살아있는 나무의 개수를 구하는 프로그램을 작성하시오.

핵심

• 땅크기 NxN

• 칸 좌표 (r, c), 1부터 시작

  (1,1)  (1,2)
  (2,1)  (2,2)

• 모든 칸을 조사

• 초기 나무 M개, 한 칸에 여러개 가능

• 초기양분 5

• 봄

  • 양분-=나이 ➡️ 나이++
  • 자기 칸의 양분만 먹을수 있음, 어린 나무부터, 양껏 못먹으면 죽음

• 여름

  • 양분 += (죽은나무 나이)/2
  • 소수점 버림

• 가을

  • if (나이%5 == 0) ➡️ 번식
  • 번식 == 인접 8칸에 나이가 1인 나무 생김

• 겨울

  • 땅 양분 += A[r][c]

• K년 후 남은 나무 갯수 구하기

입력

첫째 줄에 N, M, K가 주어진다.

둘째 줄부터 N개의 줄에 A배열의 값이 주어진다. r번째 줄의 c번째 값은 A[r][c]이다.

다음 M개의 줄에는 상도가 심은 나무의 정보를 나타내는 세 정수 x, y, z가 주어진다. 처음 두 개의 정수는 나무의 위치 (x, y)를 의미하고, 마지막 정수는 그 나무의 나이를 의미한다.

제한

• 1 ≤ N ≤ 10
• 1 ≤ M ≤ N2
• 1 ≤ K ≤ 1,000
• 1 ≤ A[r][c] ≤ 100
• 1 ≤ 입력으로 주어지는 나무의 나이 ≤ 10
• 입력으로 주어지는 나무의 위치는 모두 서로 다름

풀이

📍 접근

• 배열의 모든 요소를 방문하고, 모든 요소에서 작업을 해줘야 함 ➡️ 그래프 탐색까지 할 필요 없음. 그냥 반복문 돌려야 됨.
• 그럼 땅 MAP은 정수배열로, 그 땅의 양분 저장
• alive_tree는 deque로, 살아있는 나무의 (x, y, z)를 저장 ➡️ 나이가 어린 나무부터 양분을 먹기때문에 deque로
• dead_tree도 deque로, 죽은 나무의 (x, y, z)를 저장
• 겨울에 인접 8개 칸 방문 해야되니까 dx, dy도 선언

📍 풀이

• 계절별로 함수 나누자
• Solution 함수에서 K년을 난다
• main 함수에서 살아있는 나무를 세어 출력한다

📍 코드

#include <algorithm>  // for sort deque
#include <deque>
#include <iostream>
using namespace std;
#define MAX 11

int N, M, K;
int A[MAX][MAX];
int MAP[MAX][MAX];
deque<int> alive_tree[MAX][MAX];
deque<int> dead_tree[MAX][MAX];
int ans;

// 위쪽부터 시계방향으로 인근 8칸 이동
int dx[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};

void Spring() {
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            // 이 땅에 살아있는 나무 갯수 trees
            int trees = alive_tree[i][j].size();
            while (trees--) {
                int age = alive_tree[i][j].front();
                alive_tree[i][j].pop_front();
                if (age > MAP[i][j]) {
                    // 죽어
                    dead_tree[i][j].push_back(age);
                    continue;
                }
                MAP[i][j] -= age;
                alive_tree[i][j].push_back(age + 1);
            }
        }
    }
}

void Summer() {
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            // 이 땅에 죽어있는 나무 갯수 dtrees
            int dtrees = dead_tree[i][j].size();
            while (dtrees--) {
                int age = dead_tree[i][j].front();
                dead_tree[i][j].pop_front();
                MAP[i][j] += (age / 2);
            }
        }
    }
}

void Breeding(int x, int y) {
    for (int i = 0; i < 8; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        if (nx <= N && ny <= N && nx >= 1 && ny >= 1) {
            alive_tree[nx][ny].push_front(1);
        }
    }
}

void Fall() {
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            // 이 땅에 살아있는 나무 갯수 trees
            int trees = alive_tree[i][j].size();
            for (int k = 0; k < trees; k++) {
                int age = alive_tree[i][j][k];
                if (age % 5 == 0) {
                    Breeding(i, j);
                }
            }
        }
    }
}

void Winter() {
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            MAP[i][j] += A[i][j];
        }
    }
}

void Solution() {
    // 첫번째 봄이 오기 전에 alive_tree 나이순 정렬 해줘야됨
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            sort(alive_tree[i][j].begin(), alive_tree[i][j].end());
        }
    }

    // K년 나기
    while (K--) {
        Spring();
        Summer();
        Fall();
        Winter();
    }

    // 살아남은 나무 세기
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            ans += alive_tree[i][j].size();
        }
    }
}

void Input() {
    int x, y, z;
    cin >> N >> M >> K;
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            cin >> A[i][j];
            MAP[i][j] = 5;
        }
    }
    for (int i = 0; i < M; i++) {
        cin >> x >> y >> z;
        alive_tree[x][y].push_back(z);
    }
}

int main() {
    // 입력
    Input();
    Solution();

    cout << ans << endl;
}

설치 방법

// 요약

1. /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. brew tap AdoptOpenJDK/openjdk

3. brew install --cask adoptopenjdk8

➡️ STEP 0

맥 터미널에 들어간다. command+spacebar 단축키로 Spotlight 창을 열어 '터미널' 검색해서 찾는다.

➡️ STEP 1. Homebrew 설치

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

위 코드를 입력한다. 좀 기다리면

==> Checking for `sudo` access (which may request your password)...
Password:

이런 게 뜨는데, 맨처음 환경설정할 때 지정한 컴퓨터 비밀번호 입력하면 된다.

뭔가 진행되다가

Press RETURN to continue or any other key to abort:

이런 줄이 나온다. 아무 키나 눌러주면 된다. 엔터키같은 거!

📍 +) Homebrew 설치 확인

brew help

위 코드를 입력해서 다음 이미지와 같은 안내문구가 제대로 나오면 설치된 것

➡️ STEP 2. openJDK 설치

brew tap AdoptOpenJDK/openjdk
brew install --cask adoptopenjdk8

위 명령어를 입력한다. 중간에 Password 치라고 한번 더 나오니 앞에서 했던 것과 똑같이 입력해 주자.

➡️ STEP 3. 환경변수(경로) 지정

/usr/libexec/java_home -v 1.8

여기까지 완료했으면 openJDK 1.8 설치 완료.

📍 +) JDK 설치 확인 (버전 확인)

java -version

이 명령어를 입력했을 때 다음과 같은 대답이 나오면 openJDK 1.8 버전이 잘 설치된 것이다.

openjdk version "1.8.0_292"
OpenJDK Runtime Environment (AdoptOpenJDK)(build 1.8.0_292-b10)
OpenJDK 64-Bit Server VM (AdoptOpenJDK)(build 25.292-b10, mixed mode)