geolog

[CodeTree] Ch5.시뮬레이션 2 - dx dy technique

geologs — Tue, 9 Jun 2026 00:04:25 +0900

개념 : dx, dy 테크닉

2차원 좌표(배열)에서 특정 좌표에서 위, 아래, 오른쪽, 왼쪽으로 이동한 좌표를 구할 때 쓰이는 4방향 탐색 방식을 `dx, dy 테크닉`이라 합니다.

dy, dx 는 2차원 배열에서 4방향 탐색을 하는 것입니다. 따라서 수학 2차원 좌표에서 y가 + 되는 방향이, 2차원 배열에서는 인덱스가 감소하는 방향이 됩니다.

이때 시계방향으로 탐색할지, 반시계 방향으로 탐색할지에 따라 dy[4]배열의 값의 순서와 dx[4] 배열의 값의 순서가 달라집니다.

Warmup : 방향에 맞춰 이동

https://www.codetree.ai/ko/trails/complete/curated-cards/intro-move-in-direction/description

방향에 맞춰 이동 설명 | 코드트리

방향에 맞춰 이동을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

Warmup: 방향에 맞춰 이동

입출력

예제 설명 및 복잡도

내풀이

#include<bits/stdc++.h>
using namespace std;
#define distance aaaa
char direction;
int n, distance, ny, nx, y, x;
int dy[4] = {-1, 0, 1, 0};
int dx[4] = {0, 1, 0, -1};
int main() {
    // 방향 , 거리 
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n; 
    while(n--) {
        cin >> direction >> distance;

        if(direction== 'S') ny = y + distance * dy[0], nx = x + distance *dx[0];
        else if(direction == 'E') ny = y + distance *dy[1], nx = x + distance *dx[1];
        else if(direction == 'N') ny = y + distance *dy[2], nx = x + distance *dx[2];
        else ny = y + distance *dy[3], nx = x + distance *dx[3];
        y = ny, x = nx;
    }
    cout << x <<  " " << y << '\n';
    return 0;
}

해설코드

#include <iostream>

#define DIR_NUM 4

using namespace std;

int n, x, y;

// 동, 서, 남, 북 순으로 dx, dy를 정의합니다.
int dx[DIR_NUM] = {1, -1,  0, 0};
int dy[DIR_NUM] = {0,  0, -1, 1};

int main() {
    // 입력
    cin >> n;
    
    // 움직이는 것을 진행합니다.
    while(n--) {
        char c_dir; int dist;
        cin >> c_dir >> dist;
        
		// 각 방향에 맞는 번호를 붙여줍니다.
        int dir;
        if(c_dir == 'E')
            dir = 0;
        else if(c_dir == 'W')
            dir = 1;
        else if(c_dir == 'S')
            dir = 2;
        else
            dir = 3;
        
		// 주어진 방향대로 dist 거리만큼 이동했을 경우의
		// 위치를 구해줍니다.
        x += dx[dir] * dist;
        y += dy[dir] * dist;
    }
    
    cout << x << " " << y;
    return 0;
}

개념 : 방향회전을 위한 dx, dy 정의 방법

방향이 dx, dy 배열의 인덱스이기 때문에 방향이 항상 양수를 갖도록해야한다.

Warmup : 문자에 따른 명령 2

내풀이

#include<bits/stdc++.h>
using namespace std;
const int dy[4] = {0, -1, 0, 1};
const int dx[4] = {1, 0, -1, 0};
int y, x, ny, nx, dir_num = 3; 
string n; 
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n; 
    // 현재 방향이 북쪽인지가 중요한듯. 
    for(int i = 0; i < n.size(); i++) {
        if(n[i] == 'L') dir_num = (dir_num + 3) % 4; 
        else if(n[i] == 'R') dir_num = (dir_num + 1) % 4; 
        else{
            ny = y + dy[dir_num], nx = x + dx[dir_num]; // 이동 
            // cout << x << " : " << y <<  ", " << nx << " : " << ny << "\n";
            y = ny, x = nx; 
        } 
    }
    cout << x << " " << y << "\n";
    
    return 0;
}

실행시간

개념 : 격자에서의 dx dy

개념 : 조건에 따라 방향이 변하는 경우

https://www.codetree.ai/ko/trails/complete/curated-cards/intro-small-marble-movement/description

작은 구슬의 이동 설명 | 코드트리

작은 구슬의 이동을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

Warmup : 조건에 따라 방향이 변하는 경우

입출력

입출력예제 및 복잡도

내풀이

풀이 시간 : 30분

접근방법

#include<bits/stdc++.h>
using namespace std;
// 방향을 바꾸는데 1 만큼의 시간이 소요됨 
const int dy[4] = {-1, 0, 1, 0};
const int dx[4] = {0, 1, 0, -1};
int n, t, y, x, ny, nx, r, c, dir_num;
char d; 
// int arr[54][54];
int get_dir(char d) { // 방향을 주면 방향벡터 반환 
    if(d == 'D') return 2;
    else if(d == 'U') return 0; 
    else if(d == 'R') return 1;
    else if(d == 'L') return 3; 
}
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n  >> t; 
    cin >> r >> c >> d; // t초 후 위치한 격자의 칸 행 번호 출력 마지막에 +1 해줘야함.
    r--; c--;
    y = r, x = c;
    // t초마다 움직임을 변경
    dir_num = get_dir(d);
    while(t--) {
        // 방향을 바꿔야하는 때인지 좌표이동을 해도 되는 때인지를 구분하자
        ny = y + dy[dir_num]; nx = x + dx[dir_num];
        if(ny < 0 || ny >= n || nx < 0 || nx >= n) {
            // 격자 끝에 부딪히면 바꾼다. 
            dir_num = (dir_num + 2) % 4; continue;
        }
        y = ny; x = nx;
    }
    cout << y  + 1 << " " << x + 1;
    return 0;
}

실행결과

해설코드

#include <iostream>
#include <string>

#define ASCII_NUM 128
#define DIR_NUM 4

using namespace std;

int n, t;
int x, y, dir;
int mapper[ASCII_NUM];

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

bool InRange(int x, int y) {
    return 0 <= x && x < n && 0 <= y && y < n;
}

void Simulate() {
    while(t--) {
        int nx = x + dx[dir], ny = y + dy[dir];
        // 범위 안에 들어온다면 그대로 진행합니다.
        if(InRange(nx, ny)) {
            x = nx, y = ny;
        }
        // 벽에 부딪힌다면, 방향을 바꿔줍니다.
        else
            dir = 3 - dir;
    }
}

int main() {
    // 입력
    cin >> n >> t;
    
    // 각 알파벳 별 방향 번호를 설정합니다.
    mapper['R'] = 0;
    mapper['D'] = 1;
    mapper['U'] = 2;
    mapper['L'] = 3;
    
    char c_dir;
    cin >> x >> y >> c_dir;
    x--; y--; dir = mapper[c_dir];
    
    Simulate();
    
    cout << x + 1 << " " << y + 1;
    return 0;
}

개념 : 빙빙돌며 숫자 적기

https://www.codetree.ai/ko/trails/complete/curated-cards/intro-snail-number-square/description

빙빙 돌며 숫자 사각형 채우기 설명 | 코드트리

빙빙 돌며 숫자 사각형 채우기을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

내풀이

풀이시간 : 20분

접근방법

1. 숫자를 1씩 늘린 값을 2차원 배열에 시계방향으로 탐색하며 저장한다.

2. 2차원 배열을 2중 for문으로 탐색하지않고 2차원 배열에 저장될 숫자 범위를 오름차순으로 반복한다.

2중 for문으로 배열을 탐색하는 것(`for(int i = 0; i <n; i++) { for(int j = 0; j < m; j++) {}}`) 은 탐색 방향이 오른쪽(동쪽)으로만 탐색하는 것이기 때문에 동쪽 방향으로만 탐색하면 문제 조건인 `배열의 끝에 도달`하거나 `이미 방문한 곳`을 충족하지 못한다.
`for(int i =1 ; i < n * m; i++)`으로 반복하면 2차원 배열에 값을 기록한다.
`i <= n *m 등호가 들어가지 않는 이유`는 등호가 들어가면 i = n * m 일 때 arr[1][1] = 17이 저장되기 때문에 유효하지 않는 값이 저장되기 때문이다. 이는 앞서 다음 좌표(ny,nx) 기준으로 숫자를 기록하기 때문에 i = n * m = 16, a[1][1] = arr[2][1] + 1 = 16 + 1이 된다.

3. 다음 배열 원소(ny, nx)에 저장할 숫자는 현재 배열 원소(y,x) 값에 + 1한 값으로 저장한다.

dx, dy 테크닉 적용 방법

방향벡터 배열 dy[4], dx[4]는 위, 오른쪽, 아래, 왼쪽 순으로 가리킵니다. 문제에서 기본 방향은 오른쪽이었으니 현재 방향 인덱스를 의미하는 `dir_num = 1`로 설정합니다.

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

#include<bits/stdc++.h>
using namespace std;
int visited[104][104];
int arr[104][104];
const int dy[4] = {-1, 0, 1, 0};
const int dx[4] = {0, 1, 0, -1};
int ny, nx, y, x, n, m, dir_num = 1; 
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n >> m; // 행 열 
    // 1차원 탐색을 진행하면서 1을 늘려가야함. 
    arr[0][0] = 1; visited[0][0] = 1; 
    for(int i = 1; i < n * m; i++) {
        
        ny = y + dy[dir_num]; 
        nx = x + dx[dir_num];
        if(ny < 0 || ny >= n || nx < 0 || nx >= m || visited[ny][nx]){
            // 배열의 인덱스를 도달하거나 이미 방문한적이 있으면 방향을 바꾸고 다시 이동해야함.
            dir_num = (dir_num + 1) % 4; // 방향 바꿔야할 곳 
            ny = y + dy[dir_num];
            nx = x + dx[dir_num];    
        }
        arr[ny][nx] = arr[y][x] + 1; visited[ny][nx] = 1; 
        y = ny; x = nx; 

    }
    for(int i = 0; i < n;  i++) {
        for(int j = 0; j < m ;j++) {
            cout << arr[i][j] << ' ';
        }
        cout << '\n';
    }

    return 0;
}

실행 결과

해설코드

#include <iostream>

#define MAX_NUM 100
#define DIR_NUM 4

using namespace std;

int n, m;
int arr[MAX_NUM][MAX_NUM];

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

int curr_x, curr_y;  // 시작은 (0, 0) 입니다.
int dir;             // 0: 오른쪽, 1: 아래쪽, 2: 왼쪽, 3: 위쪽

bool InRange(int x, int y){
    return 0 <= x && x < n && 0 <= y && y < m;
}

int main() {
    // 입력:
    cin >> n >> m;

    // 처음 시작 위치에 초기값을 적습니다.
    arr[curr_x][curr_y] = 1;

    // n*m개의 숫자를 적어야 합니다. 
    for(int i = 2; i <= n * m; i++) { // 숫자 i를 어디에 적을지 결정합니다.
        // 현재 방향 dir를 기준으로 그 다음 위치 값을 계산합니다.
        int next_x = curr_x + dx[dir], next_y = curr_y + dy[dir];

        // 더 이상 나아갈 수 없다면
        // 시계방향으로 90'를 회전합니다.
        if(!InRange(next_x, next_y) || arr[next_x][next_y] != 0)
            dir = (dir + 1) % 4;

        // 그 다음 위치로 이동한 다음 배열에 올바른 값을 채워넣습니다.
        curr_x = curr_x + dx[dir]; curr_y = curr_y + dy[dir];
        arr[curr_x][curr_y] = i;
    }
    
    // 출력:
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) 
            cout << arr[i][j] << " ";
        cout << endl;
    }
    return 0;
}

Challenge : 되돌아오기

https://www.codetree.ai/ko/trails/complete/curated-cards/challenge-come-back/description

되돌아오기 설명 | 코드트리

되돌아오기을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

내풀이

풀이시간 : 10분

접근방법

배열을 선언할 필요 없이 방향 이동할 때 필요한 현재 방향을 의미하는 `dir_num 변수`를 조작하여 방향벡터 배열(dy, dx)을 이용해 위치를 이동합니다.
- 배열을 사용하지 않아도 되는 이유는 배열에 기록할 값이 필요 없기 때문입니다. 관성으로 배열을 선언한다면 메모리만 낭비됩니다.
입력받은 distance 만큼 한번에 이동하면 안됩니다. `ny = y + dy[dir_num] * distance` (X) 매초마다 처음 위치(0,0)으로 돌아왔는지 체크해야하기 때문입니다.

#include<bits/stdc++.h>
using namespace std;
#define distance aaaa
const int dy[4] = {-1, 0, 1, 0};
const int dx[4] = {0, 1, 0, -1};
char direction;
int distance, n, y, x, dir_num, y_, x_, t, ny, nx, state;
int get_dir(char d) {
    if(d == 'N') return 0;
    else if(d == 'E') return 1;
    else if(d == 'S') return 2;
    else return 3;
}
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n;
    y_ = y; x_ = x; 
    while(n--) {
        cin >> direction >> distance;
        dir_num = get_dir(direction);
        for(int i = 1; i <= distance; i++) {            
            t++;
            ny = y_ + dy[dir_num]; nx = x_ + dx[dir_num]; 
            if(ny == y && nx == x) {
                state = true; break;
            }
            y_ = ny, x_ = nx; 
        }
        if(state) break;
        // 매초마다 원래 위치로 돌아오는지 체크해야됨 한번에 distance만큼 이동하면 안됨. 그 중간에 만날 수 있기 때문에 
    }
    if( state) cout << t << '\n';
    else cout << -1 << "\n";

    return 0;
}

해설코드

#include <iostream>

#define DIR_NUM 4

using namespace std;

int n, x, y;

// 동, 서, 남, 북 순으로 dx, dy를 정의합니다.
int dx[DIR_NUM] = {1, -1,  0, 0};
int dy[DIR_NUM] = {0,  0, -1, 1};

// 답을 저장합니다.
int ans = -1;

// 지금까지 걸린 시간을 기록합니다.
int elapsed_time;

// dir 방향으로 dist 만큼 이동하는 함수입니다.
// 만약 시작지에 도달하면 true를 반환합니다.
bool Move(int dir, int dist) {
    while(dist--) {
        x += dx[dir];
        y += dy[dir];
        
        // 이동한 시간을 기록합니다.
        elapsed_time++;

        // 시작지로 다시 돌아오면,
        // 답을 갱신해줍니다.
        if(x == 0 && y == 0) {
            ans = elapsed_time;
            return true;
        }
    }
    
    return false;
}

int main() {
    // 입력
    cin >> n;
    
    // 움직이는 것을 진행합니다.
    while(n--) {
        char c_dir; int dist;
        cin >> c_dir >> dist;
        
		// 각 방향에 맞는 번호를 붙여줍니다.
        int dir;
        if(c_dir == 'E')
            dir = 0;
        else if(c_dir == 'W')
            dir = 1;
        else if(c_dir == 'S')
            dir = 2;
        else
            dir = 3;
        
        // 주어진 방향대로 dist 만큼 위치를 이동해봅니다.
        bool done = Move(dir, dist);
        
        // 시작 위치에 도달했다면, 종료합니다.
        if(done)
            break;
    }
    
    cout << ans;
    return 0;
}

Challenge : 되돌아오기 2

https://www.codetree.ai/ko/trails/complete/curated-cards/challenge-come-back-2/description

되돌아오기 2 설명 | 코드트리

되돌아오기 2을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

내풀이

풀이시간 : 15분

접근방법

#include <bits/stdc++.h>
using namespace std;
const int dy[4] = {-1, 0, 1, 0};
const int dx[4] = {0, 1, 0, -1};
string input;
bool state ;
int y, x, t, ny, nx, dir_num;
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> input;
    for(int i = 0; i < (int)input.size(); i++) {
 
        if(input[i] == 'L' ) dir_num = (dir_num + 3) % 4;
        else if(input[i] == 'R') dir_num = (dir_num + 1) % 4; 
        else if(input[i] == 'F') { // 이동 
            ny = y + dy[dir_num]; nx = x + dx[dir_num];
        }
        t++; 
        if(ny == 0 && nx == 0) { cout << t << "\n"; state = true;  break;}
        y = ny; x = nx; 
    }
    if(!state) cout << -1 << "\n";
    return 0;
}

실행결과

Challenge : 격자위의 편안한 상태

https://www.codetree.ai/ko/trails/complete/curated-cards/challenge-comfortable-state-on-the-grid/description

격자 위의 편안한 상태 설명 | 코드트리

격자 위의 편안한 상태을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

내풀이

풀이시간 : 20분

접근방법 : 색칠할 좌표(r,c)를 m번 받을 때마다 해당 좌표 기준 4방향 탐색하며 색칠한 곳이 3개일 때만 카운트

#include<bits/stdc++.h>
using namespace std;
const int dy[4] = {-1, 0, 1, 0};
const int dx[4] = {0, 1, 0 , -1};
int arr[104][104];
int n, m, r, c, ny, nx;
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n >> m; 
    while(m--) {
        cin >> r >> c ; // 행 열 
        r--; c--;
        arr[r][c] = 1; // 색칠한다. 

        int cnt = 0; 
        for(int k = 0; k < 4; k++) {
            ny = r + dy[k]; 
            nx = c + dx[k]; 
            if(ny < 0 || ny >= n || nx < 0 || nx > n) continue;
            if(arr[ny][nx] == 1) cnt++; 
        }
            
        if(cnt == 3) cout << 1 << "\n";
        else cout << 0 << "\n";

    } 
    return 0;
}

실행결과

해설코드

#include <iostream>
#include <string>

#define MAX_N 100
#define DIR_NUM 4

using namespace std;

int n, m;
int arr[MAX_N][MAX_N];

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

bool InRange(int x, int y) {
    return 0 <= x && x < n && 0 <= y && y < n;
}

int AdjacentCnt(int x, int y) {
    int cnt = 0;
    for(int i = 0; i < DIR_NUM; i++) {
        int nx = x + dx[i], ny = y + dy[i];
        if(InRange(nx, ny) && arr[nx][ny] == 1)
            cnt++;
    }
    
    return cnt;
}

int main() {
    // 입력
    cin >> n >> m;
    
    for(int i = 0; i < m; i++) {
		int x, y;
		cin >> x >> y;
		x--;
		y--;
		arr[x][y] = 1;
		// 해당 칸을 탐색합니다.
		if(AdjacentCnt(x, y) == 3)
			cout << 1 << endl;
		else
			cout << 0 << endl;
	}
	
    return 0;
}

Challenge : 거울에 레이저 쏘기 2

https://www.codetree.ai/ko/trails/complete/curated-cards/challenge-shoot-a-laser-in-the-mirror-2/description

거울에 레이저 쏘기 2 설명 | 코드트리

거울에 레이저 쏘기 2을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

Challenge : 빙빙 돌며 숫자 사각형 채우기 2

내풀이

풀이시간 : 20분

접근방법

이전 문제와 다르게 방향을 바꾸는 영역에서 ny, nx좌표를 바로 구하지 않았음. 대신 i를 차감하지 않아야 그 다음 좌표(ny,nx)로 이동할 수 있음

`빙빙돌며 숫자 사각형 채우기1` 코드 그대로 써도 정답이다. 회전 초깃값과 방향만 `dir_num = 2`, `(dir_num + 3) % 4`으로 수정하면 된다.

#include<bits/stdc++.h>
using namespace std;
int arr[104][104], visited[104][104];
int n, m , y, x, ny, nx, dir_num = 2;
const int dy[4] = {-1, 0, 1, 0};
const int dx[4] = {0, 1, 0, -1};
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n >> m; 
    arr[0][0] = 1, visited[0][0] = 1; 
    for(int i = 1; i < n * m; i++) {
        ny = y + dy[dir_num];
        nx = x + dx[dir_num];
        if(ny < 0 || ny >= n || nx < 0 || nx >= m || visited[ny][nx]){
            dir_num = (dir_num + 3) % 4; // 방향전환
            i--; // 방향 전환할 때는 차감이 되지 않도록한다.
            continue;
        } 
        arr[ny][nx] = arr[y][x] + 1; visited[ny][nx] = 1; 
        y = ny; x = nx; 
    }
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) cout << arr[i][j] << " "; 
        cout << '\n';
    }
    return 0;
}

[CodeTree] 5회차: 북마크로 틀린 문제, 삽질한 문제 복습하는 습관 만들기

geologs — Sun, 7 Jun 2026 01:02:08 +0900

북마크 관리방법

저는 다음과 같은 경우에 북마크에 저장한 후 다시 풀곤 했습니다.

설계 및 코드를 작성했으나 히든케이스 때문에 틀려서 못푼 경우
설계하는데 많은 시간이 소요된 경우 = 삽질이 오래 걸린 경우
실행결과 시간/공간복잡도가 동일언어 다른 풀이와 비교했을 때 높은 경우

북마크 종류도 너무 많으면 결국 관리가 안되어 저장된 문제들을 '다시' 풀지 않을 것이기 때문에 3가지 경우로만 나눴습니다.

그리고 가장 중요한 `'언제' 다시 북마크에 저장한 문제를 풀까? `정하는 것이었습니다. 7일 뒤에 다시 푸는 것을 기본으로 잡았습니다. 그래야 기존 풀이 방법을 고수하지 않고 다시 처음부터 설계하는 능력을 키울 수 있다고 생각했기 때문입니다.

북마크

북마크에 저장을 한 날 기준으로 7d일 뒤에 풀이할 때, 난이도 Easy, Medium, Hard 기준으로 평균 풀이시간 보다 무조건 짧게 풀 수 있어야 제대로 안다고 생각해 다시 풀지 않아도 되는 기준으로 잡았습니다.

코드트리 커리큘럼은 일단 갭체크로 부족한 부분을 점검하고 약점 유형을 추천해주는데, 저는 추천해준 약점 유형부터 쭉 격파하고 있습니다. 실제로 기업/부트캠프 코딩테스트를 치뤄보니 각각 다른 성향을 지니고 있지만 공통적으로 시뮬레이션과 완전탐색 유형에 약한 것을 느꼈습니다. 그래서 갭체크를 했을 때 생각만 했던 유형이 실제로 약점을 제대로 진단 받은 것 같아서 살짝 놀랐었습니다.

이번 주 완료

이번 주는 7일 연속 문제 풀기
Ch05 Lesson1, Lesson2 완료
Ch05 Lesson3 dx dy 테크닉 Warmup 완료, Challenge 4문제 완료

8일 연속학습

학습 내용 정리

https://geologs.tistory.com/48

[CodeTree] Ch5.시뮬레이션 2 - 배열 기록

`배열 기록`은 계속 유지해야하는 정보를 배열에 저장하는 유형을 의미한다. 배열 기록 유형 - 21. 시간에 따른 위치 - 매 초마다 위치를 배열에 저장. 인덱스 : 시간, 값 : 위치 2. 남은 횟수 배열로

geologs.tistory.com

https://geologs.tistory.com/50

[CodeTree] Ch5.시뮬레이션 2 - dx dy technique

개념 : dx, dy 테크닉2차원 좌표(배열)에서 특정 좌표에서 위, 아래, 오른쪽, 왼쪽으로 이동한 좌표를 구할 때 쓰이는 4방향 탐색 방식을 `dx, dy 테크닉`이라 합니다. dy, dx 는 2차원 배열에서 4방향 탐

geologs.tistory.com

다음 주 목표

Ch05 완료
Ch06 완전탐색 1, 2 완료

코드트리 청약 챌린지 진행중입니다!

http://www.codetree.ai

3년 만에 돌아온, 코드트리 청약 통장 챌린지 | 코드트리

매주 학습 납입하고 7주 만기 채우면 코드트리 8월까지 무료. 매주 추첨권을 모아 맥북·에어팟·애플워치 응모까지. 신청 인원에 따라 조기마감될 수 있어요.

www.codetree.ai

[CodeTree] Ch5.시뮬레이션 2 - 배열 기록

geologs — Fri, 5 Jun 2026 12:10:12 +0900

`배열 기록`은 계속 유지해야하는 정보를 배열에 저장하는 유형을 의미한다.

배열 기록 유형 - 2

1. 시간에 따른 위치 - 매 초마다 위치를 배열에 저장. 인덱스 : 시간, 값 : 위치

2. 남은 횟수 배열로 기록하기

개념 : 시간에 따른 위치

A, B가 1초에 1m씩 움직입니다.
A는 9초 동안 앞으로 움직이다가, 3초간 뒤로 오고, 다시 5초간 앞으로 움직입니다.
B는 2초간 뒤로 갔다가, 앞으로 2초 갔다가, 1초간 뒤로 오고, 다시 12초간 앞으로 움직입니다.
A, B가 움직임을 시작한 이후에 다시 만나게 되는 시간은 몇 초 뒤일까요?

A,B의 시간에 따른 동선을 일직선 상에 표시하면 다음과 같습니다.

이때 A, B가 몇 초후에 최초로 만나는지를 구하고자 합니다.

주의할 점은 A, B가 위치상 같을 때만 조건이 아니라 시간과 위치가 동시에 같을 때여야 합니다. 다른 시점에 같은 위치를 방문한 겻은 최초로 만난 시간이 아니기 때문입니다.

방법 -2

1. 1초씩 시뮬레이션하면서 A, B의 위치를 동시에 확인

이게 왜 복잡한 방법인가? : 매초마다 A와 B의 이동 기록을 추적해야함.

2. A의 시간에 따른 이동을 배열에 저장하고, B의 시간에 따른 이동 기록을 배열에 저장

배열의 인덱스가 시간(초)이고, 그 안에 저장되는 값이 위치입니다.`a[시간] = 위치`

위의 도식에서는 일직선의 축이 위치가 마치 배열의 인덱스처럼 나타납니다. 위치를 인덱스로 잡지 않는 이유는 A, B가 오른쪽, 왼쪽 양방향으로 이동하면서 위치는 중복이 될 수 있기 때문입니다. 시간은 계속 증가하기 때문에 인덱스가 겹치지 않아 a[시간] = 위치가 됩니다.

A의 시간에 따른 위치를 기록하고 B의 시간에 따른 위치를 기록한 뒤, 0 초 부터 1초씩 증가시키면서 값이 최초로 같을 때 배열의 인덱스가 최초 만나는 시각이 됩니다.

Warm up : 만나는 그 순간

Warm up 만나는 그 순간

입출력

예시 설명 및 복잡도

내 풀이

접근방법

A와 B 각각 시간의 흐름에 따른 이동 위치를 1차원 배열에 저장한다. a[시간] =위치
현재 시간, 현재 위치를 저장하는 변수를 각각 두고, A, B가 t초만큼 d방향으로 이동할 때 시간을 누적하여 총 이동 시간을 구한다.
A, B의 총 이동 시간 중 최소 시간으로 두 사람의 이동 기록 배열을 탐색한다.
e.g A는 총 10초간 이동, B는 2초간 이동했다면 2초까지만 동일 시각에 동일 위치에 있는지 확인한다. 3초 부터는 B가 이동하지 않았으므로 절대 A와 만날 수 없기 때문이다.

놓친 지점

최대 이동시간은 1,000이 아니라 1,000,000초이다.
- 조건의 범위가 1 <= t <= 1000, 1 <= n, m <= 1000이므로 최대 1000번 동안 각각 1000초를 이동한 것이 최댓값이 된다. 1000번 * 1000 초 = 1000초 인 것이다.
- A, B의 시간의 흐름에 따른 이동 위치를 기록한 배열의 크기가 1000이되면 런타임에러가 난다. `arr_a[1000]` 에서 `arr_a[1'000'004]`로 수정해야한다.

#include<bits/stdc++.h>
using namespace std;
int arr_a[1'000'004];
int arr_b[1'000'004]; 
int cur_time, cur_pos, n, m, t, t_a, t_b; 
char d; 
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n >> m; 
    // A의 시간에 따른 위치를 기록한다. 
    while(n--) {
        cin >> d >> t ;
        // cout << "d = " << d << " , t = " << t << "\n";
        t_a += t;
        while(t--) {
            cur_time++; 
            if(d == 'R'){
                arr_a[cur_time] = ++cur_pos;
            }
            else arr_a[cur_time] = --cur_pos; 
        }
    }
    cur_time = 0, cur_pos = 0; 
    while(m--) {
        cin >> d >> t ;
        t_b += t;
        
        while(t--) {
            cur_time++; 
            if(d == 'R'){
                arr_b[cur_time] = ++cur_pos;
            }
            else arr_b[cur_time] = --cur_pos; 
        }
    }
    bool state = false; 
    // 둘의 이동 시간 중 작은 시간 만큼 탐색을 한다. 

    t = min(t_a, t_b);
    for(int i = 1; i <= t; i++) { // i = 0일 때는 아직 움직이지 않았기 때문에 1부터 시작 
        if(arr_a[i] == arr_b[i]) {
            cout << i << "\n"; state = true; break;
        }
    }
    if(!state) cout << -1 << "\n"; // 둘다 만나지 않는 경우 예외처리
    return 0;
}

실행 결과

개념 : 남은 횟수를 배열로 기록하기

3명의 사람 A, B, C가 각각 숫자 5, 10, 8을 생각하고 있습니다.
각 사람은 처음 3개의 사탕을 가지고 있고, 5번의 질문에 대해 조건을 만족할 때마다 사탕을 하나씩 잃게 됩니다.
가장 빨리 사탕이 사라지게 되는 사람은 누구일까요?
5개의 질문 목록은 다음과 같습니다.

1. 숫자가 3 이상인 경우
2. 숫자가 5 이하인 경우
3. 숫자가 7 이상인 경우
4. 숫자가 2 이상 8 이하인 경우
5. 숫자가 10 미만인 경우

Warmup : 벌금은 누구에게

https://www.codetree.ai/ko/trails/complete/curated-cards/intro-who-will-pay/description

벌금은 누구에게 설명 | 코드트리

벌금은 누구에게을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

Warmup: 벌금은 누구에게

입출력 및 복잡도

내풀이

접근 방법

매 시행 (벌칙에 걸린 학생의 번호를 확인)마다 학생들의 벌점을 확인한다(시뮬레이션)
학생들의 벌점 상태를 배열에 기록(저장)한다.
총 시행 횟수 (m) 시행 결과 벌칙에 걸린 학생이 없다면 ( arr[i] < k), -1을 출력한다.

#include<bits/stdc++.h>
using namespace std;
int arr[104]; 
int n, m, k, target;
bool state = false; 
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    // 최초로 벌금을 내게 되는 학생 
    cin >> n >> m >> k ;
    for(int i = 0; i < m; i++) { // 10^8 복잡도 안넘음 
        cin >> target; // 벌칙에 걸린 학생의 번호 
        arr[target]++;
        // 벌칙에 걸린 학생이 있는지 확인 
        for(int j = 1; j <=n; j++) {
            if(arr[j] >= k) { 
                cout << j << "\n"; state= true; 
                break; 
            }
        }
        if(state) break;
    }
    if(!state) cout << -1 << "\n";
    return 0;
}

실행 결과

해설코드

#include <iostream>

#define MAX_N 100
#define MAX_M 10000

using namespace std;

int n, m, k;
int penalized_person[MAX_M];
int penalty_num[MAX_N + 1];

int main() {
    // 입력
    cin >> n >> m >> k;
    for(int i = 0; i < m; i++)
        cin >> penalized_person[i];
    
    // 각 패널티 횟수를 세서,
    // 최초로 K번 이상 벌칙을 받는 사람을 추적합니다.
    int ans = -1;
    for(int i = 0; i < m; i++) {
        int target = penalized_person[i];
        penalty_num[target]++;
        
        if(penalty_num[target] >= k) {
            ans = target;
            break;
        }
    }
    
    cout << ans;
    return 0;
}

Challenge : 선두를 지켜라

https://www.codetree.ai/ko/trails/complete/curated-cards/challenge-keep-the-lead/description

선두를 지켜라 설명 | 코드트리

선두를 지켜라을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

Challenge 선두를 지켜라

입출력 예제

예제 설명 및 복잡도

내풀이

이 문제의 경우 아래 3가지를 고민하는데 많은 시간이 들었습니다.

배열에 어떤 값을 저장하는가
선두 결정과 선두 바뀜의 차이
선두 바뀜 판정 방법

풀이 시간 : 5시간

접근 방법

배열에 매초마다 위치기록
변수에 선두를 저장하고, 배열을 탐색하면서 추월하는 순간을 카운팅

1) 1 차원 배열에 매 초마다 어느 위치에 있는지 기록

거리, 속도, 시간

문제에서 "주어지는 특정 속도로 특정 시간만큼 이동"한다고 했습니다. 그러면 결국 선두가 뒤바뀌는 것을 알기 위해서는 특정 시각에 각각의 위치를 알아야합니다.

문제에서는 속도와 시간을 주었지 "위치"는 제공하지 않았기 때문에, 거리/속도/시간 공식에 따라 거리를 구해야합니다.

여기서 구한 거리를 배열의 값으로 저장합니다.

거리, 속도, 시간

예시) 속도 4 (m/h)를 1시간동안 이동한다.

1시간 후의 거리 = 속도 4 (m/h) * 시간 1 h = 4 m 입니다.

시간은 1시간씩 선형적으로 증가하기 때문에 거리에 대한 공식 x(t) = v * t 를 만들 수 있습니다.

코드 적용

 for(int i = 0; i < m; i++) {
        cin >> v >> t; 
        for(int j = 1; j <= t; j++) {
            arr_b[cur_time + j] = arr_b[cur_time] + v * j; 
        }
        cur_time += t; 
    }

틀린 이해)

필자는 1시간 동안 1/4m 만큼 이동한다고 잘못 이해했습니다.

선두가 바뀐 것을 판정하는 방법

가정 1) 두 사람이 같은 위치일 때 앞뒤 차이를 곱하여 추월 여부 판정

A,B의 시간에 따른 위치 값을 구간에 따라 표현한 1차 함수로 나타냅니다.

A 에 대한 함수 f(t), B에 대한 함수 g(t)일 때 (t는 시간을 의미하며 자연수이다), {f(t - 1) - g( t- 1 )} * {f(t + 1) - g( t + 1) } < 0 이면 선두가 바뀌었다라고 판정합니다.

반례) 연속으로 같은 값이 나온 후 선두가 바뀌는 것을 판정하지 못합니다.

테스트케이스 1에서 t = 3, 4일 때 A와 B의 값이 각각 6, 7 로 같은 값을 가지기 때문입니다. 2초, 5초의 값으로 선두가 바뀌는 것을 판정해야합니다.

여기서 더이상 방법이 떠오르지 않아 질문을 했습니다

[가정1]의 문제점

1. 두 사람의 위치가 같지 않아도, 추월이 일어날 수 있습니다.

1초 -> 2초로 넘어갈 때 A는 1초에서 3이고, 2초에서 10이라고 하면, B가 1초에서 1이고 2초에서 13이면 둘이 만나지 않더라도 추월이 일어날 수 있습니다.

2. 연속으로 두 사람의 위치가 같은 경우 대소 비교하기 어려움

3. 선두가 바뀌는 것 != 선두가 결정되는 것 (주의사항)

문제를 보면 "단, 두 사람이 공동으로 선두를 지키는 경우, 어느 한 쪽이 앞서가기 전까지는 선두가 바뀌지 않았다고 판단합니다."라고 되어있습니다. 즉 둘이 1초, 2초, 3초 같은 위치인 경우 아직 선두가 결정되지 않은 것입니다.
4초에서 A가 10, B가 20인경우 B가 선두로 처음 결정된 것이지 선두가 바뀐것이 아닙니다.

2) 올바른 접근방법 : 현재 앞서고 있는 사람이 누구인지 배열 변수에 기록

동점이 되는 시점을 찾아서 앞뒤를 비교하기보다, 매 초마다 "현재 앞서고 있는 사람이 누구인지" 를 변수에 기록하며 과거의 선두와 비교하는 방식이 훨씬 간단하고 확실합니다.

[참고] 토론 글 답변 받은 내용입니다. 즉, 앞서 배운 배열 기록이 활용되는 부분이었습니다. 선두인 사람을 배열에 기록하는 것이 핵심이었습니다.

#include<bits/stdc++.h>
#define MAX 1'000'004
using namespace std;
int arr_a[MAX], arr_b[MAX], arr[MAX];
int n, m, cur_time, v,t, cnt, sum_time; 
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n >> m; // 시행 횟수 
    // A의 매초마다 이동거리 
    for(int i = 0; i < n; i++) {
        cin >> v >> t; 
        sum_time += t; 
        for(int j = 1 ; j <= t; j++) {
            arr_a[cur_time + j] = arr_a[cur_time ] + v * j;  // 이전 거리에서 누적해서 더해야함. 
        }
        cur_time += t; 
    }

    // B의 매초마다 이동거리
    cur_time = 0;
    for(int i = 0; i < m; i++) {
        cin >> v >> t; 
        for(int j = 1; j <= t; j++) {
            arr_b[cur_time + j] = arr_b[cur_time] + v * j; 
        }
        cur_time += t; 
    }


    // 매초마다 현재 앞서고 있는 사람이 누구인지 변수에 기록하자. 
    // 과거의 선두와 비교하는 방식 
    for(int i = 1; i <= sum_time; i++) {
        if(arr_a[i] > arr_b[i]) arr[i] = 1; // a가 더 빠르면 1, b가 빠른 경우 2
        else if(arr_a[i] < arr_b[i]) arr[i] = 2; 
        else arr[i] = 3; // 같은 값을 가질 때, 선두가 바뀌지 않음 
    }

    int head = -1; 
    // 선두가 결정되면 head의 값이 할당됨 3은 선두라고 할 수 없음 
    for(int i = 1; i <= sum_time; i++) {
        // 3에서 2 or 1로 바뀐 것은 선두가 결정되었다고 하는거지 선두가 바뀌었다고 하지 않는다. 
        // 첫 선두 정하기 
        if(head == -1 && arr[i] != 3) head = arr[i];  // 첫선두가 정해질거임 
        if(head != -1  && arr[i] != 3 && head != arr[i]) {
            cnt++; head = arr[i]; // 선두 교체 
        }

    }

    cout << cnt << '\n';
    return 0;
}

실행시간

해설코드

나의 풀이와 다른점

해설은 매초마다 서있는 위치를 기록할 때 이전 초 기준으로 속도 만큼 더함.
필자는 입력받은 시점의 시각 기준으로 offset으로 v*t를 더함

#include <iostream>

#define MAX_T 1000000

using namespace std;

int n, m;
int pos_a[MAX_T + 1], pos_b[MAX_T + 1];

int main() {
    // 입력
    cin >> n >> m;
    
    // A가 매 초마다 서있는 위치를 기록
    int time_a = 1;
    for(int i = 0; i < n; i++) {
        int v, t;
        cin >> v >> t;
        
        while(t--) {
            pos_a[time_a] = pos_a[time_a - 1] + v;
            time_a++;
        }
    }
    
    // B가 매 초마다 서있는 위치를 기록
    int time_b = 1;
    for(int i = 0; i < m; i++) {
        int v, t;
        cin >> v >> t;
        
        while(t--) {
            pos_b[time_b] = pos_b[time_b - 1] + v;
            time_b++;
        }
    }
    
    // A와 B 중 더 앞서 있는 경우를 확인합니다.
    // A가 리더면 1, B가 리더면 2로 관리합니다.
    int leader = 0, ans = 0;
    for(int i = 1; i < time_a; i++) {
        if(pos_a[i] > pos_b[i]) {
            // 기존 리더가 B였다면
            // 답을 갱신합니다.
            if(leader == 2)
                ans++;
            
            // 리더를 A로 변경합니다.
            leader = 1; 
        }
        else if(pos_a[i] < pos_b[i]) {
            // 기존 리더가 A였다면
            // 답을 갱신합니다.
            if(leader == 1)
                ans++;
            
            // 리더를 B로 변경합니다.
            leader = 2; 
        }
    }
    
    cout << ans;
    return 0;
}

Challenge : 좌우로 움직이는 로봇

Challenge 좌우로 움직이는 로봇

입출력

내풀이

풀이 시간 : 1시간

접근 방법

A, B 로봇이 각각 매초 마다 이동하는 위치를 배열에 기록
두 로봇이 같은 시각에 같은 위치에 있을 때, 이전 시간에 두 로봇의 위치가 동일한지 판정 후 카운팅

실수한 부분

char 타입 문자를 int로 선언하여 if(d == 'R') 을 수행하지 못함
이동이 종료하고 위치가 유지되어야함. 마지막 위치값으로 배열의 나머지 값을 초기화해야함

TIP

두 로봇 A,B를 같은 시각에 한번에 이동을 처리하기 보다는 A 움직임 처리 후 B 움직임을 처리하는 것이 간편하다

매초 마다 어느 위치에 있었는지 기록하고 1초부터 쭉 탐색을 하며 시간과 위치가 동시에 일치살 때를 구한다.

#include<bits/stdc++.h>
#define MAX 2'000'000 // 최대 이동 거리를 정확히 모르겠음. 
using namespace std;
int n, m, t, cur_time =1, cnt, sum_a, sum_b;
int arr_a[MAX], arr_b[MAX];
char d;
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n >> m; 
    // A의 시간에 따른 이동위치 기록 
    for(int i = 1; i <= n; i++) {
        cin >> t >> d; 
        if(d == 'R') {
            for(int j = 0; j < t ;j++) {
                arr_a[cur_time] = arr_a[cur_time - 1] +1;
                cur_time++;
            }
        }else {
            for(int j = 0; j < t ;j++) {
                arr_a[cur_time] = arr_a[cur_time - 1] -1 ;
                cur_time++;
            }
        }
    }
    fill(&arr_a[cur_time], &arr_a[0] + MAX, arr_a[cur_time -1]); // 마지막 종료 후 마지막 위치값으로 나머지 초기화 
    // B의 시간에 따른 이동위치 배열에 기록 
    cur_time = 1; 
    for(int i = 1; i <= m; i++) {
        cin >> t >> d; 
        if(d == 'R') {
            for(int j = 0; j < t ;j++) {
                arr_b[cur_time] = arr_b[cur_time - 1] +1;
                cur_time++;
            }
        }else {
            for(int j = 0; j < t ;j++) {
                arr_b[cur_time] = arr_b[cur_time - 1] - 1;
                cur_time++;
            }
        }
    }
    fill(&arr_b[cur_time], &arr_b[0] + MAX, arr_b[cur_time -1]);

    // 배열을 탐색하면서 같은 값을 가질 때를 찾고  직전과 다른 위치인 경우 카운팅
    for(int i = 1; i <= MAX; i++) {
        if(arr_b[i] != 0 && arr_a[i] != 0 && arr_a[i] == arr_b[i] && arr_a[i-1] != arr_b[i-1]){
            cnt++;
        }  
    }
    cout << cnt << "\n";
    return 0;
}

해설코드

나의 풀이와 다른 점

두 로봇의 수행시간이 각각 다를 수 있기 때문에 각 로봇의 수행시간을 구하고 그 중 최댓값을 가지는 시간 만큼만 배열을 순회한다.
필자는 MAX = 2,000,000까지 배열을 모두 탐색하기 때문에 상대적으로 시간이 더 걸린다.

#include <iostream>

#define MAX_T 1000000

using namespace std;

int n, m;
int pos_a[MAX_T  + 1], pos_b[MAX_T + 1];

int main() {
    // 입력
    cin >> n >> m;
    
    // A가 매 초마다 서있는 위치를 기록
    int time_a = 1;
    for(int i = 0; i < n; i++) {
        char d; int t;
        cin >> t >> d;
        
        while(t--) {
            if(d == 'R')
                pos_a[time_a] = pos_a[time_a - 1] + 1;
            else
                pos_a[time_a] = pos_a[time_a - 1] - 1;
            
            time_a++;
        }
    }
    
    // B가 매 초마다 서있는 위치를 기록
    int time_b = 1;
    for(int i = 0; i < m; i++) {
        int t; char d;
        cin >> t >> d;
        
        while(t--) {
            if(d == 'R')
                pos_b[time_b] = pos_b[time_b - 1] + 1;
            else
                pos_b[time_b] = pos_b[time_b - 1] - 1;
            
            time_b++;
        }
    }
	
	
	if(time_a < time_b) {
		for(int i = time_a; i < time_b; i++) {
			pos_a[i] = pos_a[i - 1];
		}
	}
	else if(time_a > time_b) {
		for(int i = time_b; i < time_a; i++) {
			pos_b[i] = pos_b[i - 1];
		}
	}
    
    // 새롭게 만나는 횟수를 구합니다.
    int cnt = 0;
	int time_max = 0;
	if(time_a < time_b)
		time_max = time_b;
	else
		time_max = time_a;
	
    for(int i = 1; i < time_max; i++) {
        if(pos_a[i] == pos_b[i] && pos_a[i - 1] != pos_b[i - 1])
            cnt++;
    }
    
    cout << cnt;
    return 0;
}

Challenge : 악수와 전염병의 상관관계 2

https://www.codetree.ai/ko/trails/complete/curated-cards/challenge-correlation-between-shaking-hands-and-infectious-diseases2/description

악수와 전염병의 상관관계 2 설명 | 코드트리

악수와 전염병의 상관관계 2을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

Challenge : 악수와 전염병의 상관관계2

제한 조건 및 출력

입출력예제

복잡도 제한사항

내풀이

풀이시간 : 1시간

접근 방법

시간, 개발자A, B의 값을 하나로 담는 구조체 정의하여, 시간을 오름차순 정렬
배열에는 매 시행(T)마다 개발자마다 감염시킬 수 있는 횟수를 저장해야함 `hs[104]`
감염여부를 `contag[104]`에 저장
테이스케이스를 시간의 오름차순으로 정렬한 결과를 2명이 감염된 상태인지 아닌지 경우의 수를 나눠 탐색

실수한 부분

감염가능(악수 가능) 횟수를 저장하는 hs[] 에 fill() K로 초기화 해야함.

#include <bits/stdc++.h>
using namespace std;
struct contagion{
    int t, x, y;
};
bool compare(contagion a, contagion b ) {
    return a.t < b.t;
}
int N, K, P, T;
int t[250];
int x[250];
int y[250];
int hs[104]; // 개발자의 악수할 수 있는 횟수 
int contag[104];
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> N >> K >> P >> T;
    contag[P] = 1; 
    fill(&hs[0], &hs[0] + 104, K);  // 최대 2번 
    vector<contagion> v; 
    for (int i = 0; i < T; i++) {
        cin >> t[i] >> x[i] >> y[i];
        v.push_back({t[i], x[i], y[i]});
    }
    // 시간을 기준으로 오름차순 정렬해야함. 
    int t_ = 0, x_ = 0, y_ = 0;
    sort(v.begin(), v.end(), compare);
    for(auto i : v) {
        t_ = i.t; x_ = i.x; y_ = i.y;

        if(contag[x_] == 1 && contag[y_] == 1) {
            if(hs[x_] > 0) hs[x_]--;
            if(hs[y_] > 0) hs[y_]--;

        }else if(contag[x_] == 1 && contag[y_] == 0) {
            if(hs[x_] > 0 ) hs[x_]--, contag[y_] = 1; 
        }
        else if(contag[y_] == 1 && contag[x_] == 0) {
            if(hs[y_] > 0 ) hs[y_]--, contag[x_] = 1; 
        }

    }
    for(int i = 1; i <= N; i++) {
        cout << contag[i];
    }


    return 0;
}

실행결과

해설코드

#include <iostream>
#include <algorithm>

#define MAX_N 100
#define MAX_T 250

using namespace std;

int n, k, p, t;
int shake_num[MAX_N + 1];
bool infected[MAX_N + 1];

// 악수의 정보를 나타내는 클래스 선언
class Shake{
    public:
        int time;
        int person1;
        int person2;
        Shake(int time, int person1, int person2) {
            this->time = time;
            this->person1 = person1;
            this->person2 = person2;
        }
		Shake(){}
};

// Custom Comparator
bool Cmp(const Shake &a, const Shake &b) {
    // 시간을 기준으로 오름차순으로 정렬합니다.
    return a.time < b.time;
}

int main() {
    // 입력
    cin >> n >> k >> p >> t;
	infected[p] = true;
	
	Shake shakes[MAX_T];
	
    for(int i = 0; i < t; i++) {
		int time, person1, person2;
        cin >> time >> person1 >> person2;
		// Shake 객체를 생성해 넣어줍니다.
		shakes[i] = Shake(time, person1, person2);
	}
	
	// custom comparator를 활용한 정렬
    sort(shakes, shakes + t, Cmp);
    
    // 각 악수 횟수를 세서,
    // K번 초과로 악수를 했을 시 전염시키지 않습니다.
    for(int i = 0; i < t; i++) {
        int target1 = shakes[i].person1;
		int target2 = shakes[i].person2;
		
		// 감염되어 있을 경우 악수 횟수를 증가시킵니다.
        if(infected[target1])
			shake_num[target1]++;
		if(infected[target2])
			shake_num[target2]++;
		
		// target1이 감염되어 있고 아직 K번 이하로 악수했다면 target2를 전염시킵니다.
		if(shake_num[target1] <= k && infected[target1])
			infected[target2] = true;
		
		// target2가 감염되어 있고 아직 K번 이하로 악수했다면 target1을 전염시킵니다.
		if(shake_num[target2] <= k && infected[target2])
			infected[target1] = true;
    }
    
    for(int i = 1; i <= n; i++) {
		if(infected[i])
			cout << 1;
		else
			cout << 0;
	}
	
    return 0;
}

Test : 선두를 지켜라 3

https://www.codetree.ai/ko/trails/complete/curated-cards/test-keep-the-lead-3/description

선두를 지켜라 3 설명 | 코드트리

선두를 지켜라 3을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

Test : 선두를 지켜라 3

입출력

예제 설명 및 복잡도

내풀이

풀이 1) 두 사람의 시간에 따른 위치를 매초 마다 선두인 것을 결과 배열에 기록

풀이시간 : 40분

실수한 부분

1. 공간복잡도 초과

배열의 인덱스는 시간이 변수인데, 위치의 최댓값을 고려해서 1,000,000,000 (= 10^9)으로 생각함. 시간 (T)의 최댓값* 횟수(N,M)의 최댓값 = 1,000,000이 올바름
10^9을 넘을 수 있으니 타입을 long long으로도 바꿈. 이로인해 A, B의 시간에 따른 위치 배열과 선두만 기록하는 배열 총 3개만 해도 메모리가 24GB 나오는 공간복잡도 초과 문제가 발생함

2. typedef <기존 타입> <새로운 별명타입>;

define과 헷갈려서 앞에 #을 넣지않고, 콤마(;)를 생략했음

#include<bits/stdc++.h>
#define MAX 1'000'000 // 시간대별 위치를 기록, 위치가 MAX 의 범위가 아님. 시간임 1000 회 * 1000초

using namespace std;

int N, M, cnt;
int v[1000], t[1000];
int v2[1000], t2[1000];
int arr_a[MAX], arr_b[MAX], res[MAX];
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> N >> M;
    int time_a = 1;
    for (int i = 0; i < N; i++) {
        cin >> v[i] >> t[i];
        // 시간에 따른 A의 위치 기록 
        // t초동안 1초씩 v만큼 더하면됨 
        for(int j = 0; j < t[i] ; j++) {
            arr_a[time_a] = arr_a[time_a -1] + v[i] ;
            time_a++;
        }
    }
    int time_b = 1; 
    for (int i = 0; i < M; i++) {
        cin >> v2[i] >> t2[i];
        // 시간에 따른 B의 위치 기록
        for(int j = 0; j < t2[i]; j++) {
            arr_b[time_b] = arr_b[time_b -1 ] + v2[i];
            time_b++;
        }
    }
  
    // 1 : A, 2 : B , 3 : A, B
    for(int i = 1; i < time_a; i++) {
        if(arr_a[i] == arr_b[i]) res[i] = 3; 
        else if(arr_a[i] < arr_b[i]) res[i] = 2;
        else res[i] = 1;
    }
    for(int i = 1; i < time_a; i++) {
        if(res[i] != res[i-1]) cnt++;
    }
    cout << cnt << '\n';

    return 0;
}

실행결과

풀이 2) 결과 배열없이 매초마다 두 사람의 위치를 비교하여 현재 선두를 찾고, 이전 선두와 다른지 비교

풀이시간 : 1시간

장점

결과배열을 저장하는 배열이 없어져 메모리가 1MB 줄어듦
다시 결과 배열을 탐색하지 않아도 되어 시간이 1ms 줄어듦

실수한 부분

이전 선두(leader)값과 현재 선두(cur)의 값이 다를 때 개수를 카운팅(cnt++)하는데, 이때 새로운 선두를 현재 선두로 업데이트 하지않아 매우 큰 cnt 값이 생김
`leader = cur` 이 필요했음
A와 B의 위치를 시간순으로 비교할 때 첫 선두는 카운팅에 포함(Cnt = 1) 해야하는데, 미포함해야한다고 생각해서 조건문이 늘어남.

#include<bits/stdc++.h>
#define MAX 1'000'000 // 시간대별 위치를 기록, 위치가 MAX 의 범위가 아님. 시간임 1000 회 * 1000초
using namespace std;
int N, M, cnt=1;
int v[1000], t[1000];
int v2[1000], t2[1000];
int arr_a[MAX], arr_b[MAX];
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> N >> M;
    int time_a = 1;
    for (int i = 0; i < N; i++) {
        cin >> v[i] >> t[i];
        // 시간에 따른 A의 위치 기록 
        // t초동안 1초씩 v만큼 더하면됨 
        for(int j = 0; j < t[i] ; j++) {
            arr_a[time_a] = arr_a[time_a -1] + v[i] ;
            time_a++;
        }
    }

    int time_b = 1; 
    for (int i = 0; i < M; i++) {
        cin >> v2[i] >> t2[i];
        // 시간에 따른 B의 위치 기록
        for(int j = 0; j < t2[i]; j++) {
            arr_b[time_b] = arr_b[time_b -1 ] + v2[i];
            time_b++;
        }
    }

    // 1 : A, 2 : B , 3 : A, B
    int leader = 0, cur = 0; 
    if(arr_a[1] == arr_b[1]) leader = 3 ;
    else if(arr_a[1] < arr_b[1]) leader = 2;
    else leader = 1;

    for(int i = 2; i < time_a; i++) {
        if(arr_a[i] > arr_b[i]) cur = 1;
        else if(arr_a[i] < arr_b[i]) cur= 2;
        else cur = 3; 
        if(cur != leader) cnt++, leader = cur; // 리더를 현재인 값으로 업데이트 

    }

    cout << cnt<< '\n';

    return 0;
}

실행결과

해설코드

#include <iostream>

#define MAX_T 1000000

using namespace std;

int n, m;
int pos_a[MAX_T + 1], pos_b[MAX_T + 1];

int main() {
    // 입력
    cin >> n >> m;
    
    // A가 매 초마다 서있는 위치를 기록
    int time_a = 1;
    for(int i = 0; i < n; i++) {
        int v, t;
        cin >> v >> t;
        
        while(t--) {
            pos_a[time_a] = pos_a[time_a - 1] + v;
            time_a++;
        }
    }
    
    // B가 매 초마다 서있는 위치를 기록
    int time_b = 1;
    for(int i = 0; i < m; i++) {
        int v, t;
        cin >> v >> t;
        
        while(t--) {
            pos_b[time_b] = pos_b[time_b - 1] + v;
            time_b++;
        }
    }
    
    // A와 B 중 더 앞서 있는 경우를 확인합니다.
    // A가 리더면 1, B가 리더면 2, 둘 다 리더면 3으로 관리합니다.
    int leader = 0, ans = 0;
    for(int i = 1; i < time_a; i++) {
        if(pos_a[i] > pos_b[i]) {
            // 조합이 바뀌었다면
            // 답을 갱신합니다.
            if(leader != 1)
                ans++;
            
            // 리더를 A로 변경합니다.
            leader = 1; 
        }
        else if(pos_a[i] < pos_b[i]) {
            // 조합이 바뀌었다면
            // 답을 갱신합니다.
            if(leader != 2)
                ans++;
            
            // 리더를 B로 변경합니다.
            leader = 2; 
        }
        else {
            // 조합이 바뀌었다면
            // 답을 갱신합니다.
            if(leader != 3)
                ans++;
            
            // 리더를 둘 다로 변경합니다.
            leader = 3;
        }
    }
    
    cout << ans;
    return 0;
}

[CodeTree] Ch5.시뮬레이션 2 - 최장 연속 부분 수열

geologs — Mon, 1 Jun 2026 16:40:35 +0900

DP(Dynamic Programming)의 유형인 LCS(Longest Common Subsequence) 최장 공통 부분 수열과 다른 유형입니다.

최장 연속 부분 수열은 구현 시뮬레이션 문제입니다.

개념 : 숫자가 동일한 연속 부분 수열

수열이 (2, 2, 7, 7, 7, 7, 5, 7, 7) 다음과 같이 주어졌을 때, 연속해서 나오는 같은 숫자를 한 묶음이라 보면,

(2, 2), (7, 7, 7, 7), (5), (7, 7) 총 4개 묶음이 나옵니다.

새로운 묶음이 생겨나는 순간에 개수를 세줍니다.

새로운 묶음이 생겨나는 기준은 이웃한 이전 원소의 값과 현재의 값이 다를 때입니다. a[i] != a[i -1]

|| OR 연산자

if( A || B)에서 A가 true이면 뒤의 B는 계산하지 않고 바로 {} 명령문들을 실행합니다. 따라서 A 에는 에러가 발생하지 않을 조건을 두어야합니다.

Warmup : 연속되는 수 2

Warmup 연속되는 수 2

입출력 및 복잡도

https://www.codetree.ai/ko/trails/complete/curated-cards/intro-continuous-number2/description

연속되는 수 2 설명 | 코드트리

연속되는 수 2을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

내풀이

풀이 1 : 배열 인덱스 1번째부터 탐색

놓친 부분

모든 숫자가 같을 때, 연속된 개수를 ret(최종값)에 업데이트를 하지 않음
숫자의 개수가 최소 1개일 때 예외케이스 누락 -> 1일 때는 for반복문으로 이웃 비교를 하면 인덱스 에러가 발생함.

해설코드와 다른점

해설 코드는 수열의 0번째부터 시작하여 if문에 i == 0일 때 a[i-1] 이전값을 참조하는 것을 막음. (인덱스 에러 방지)

풀이 2 : 배열 인덱스 0번째부터 탐색

#include<bits/stdc++.h>
using namespace std;
int n, ret = -1e9, arr[1004], cnt=1;
int main() {
    cin >> n;
    for(int i = 0; i < n; i++) {
        cin >> arr[i];
    }
    for(int i = 0; i < n; i++) {
        if(i == 0 || arr[i] != arr[i - 1]) {
            ret = max(ret, cnt); cnt = 0;
        }
        cnt++; // 연속으로 같은 숫자를 더한다 
    }
    // 모두 다 같을 때 처리하는 방법 
    ret = max(ret, cnt);
    cout << ret << '\n';
    return 0;
}

해설코드

#include <iostream>
#include <algorithm>

#define MAX_N 1000

using namespace std;

int n;
int arr[MAX_N];

int main() {
    // 입력
    cin >> n;
    for(int i = 0; i < n; i++)
        cin >> arr[i];
    
    // 연속하여 동일한 숫자가 나오는 횟수를 구해보며,
    // 그 중 최댓값을 갱신합니다.
    int ans = 0, cnt = 0;
    for(int i = 0; i < n; i++) {
		// Case 1
        if(i >= 1 && arr[i] == arr[i - 1])
            cnt++;
		// Case 2
        else
            cnt = 1;
        
        ans = max(ans, cnt);
    }
    
    cout << ans;
    return 0;
}

Challenge : 연속되는 수 3

Challenge 연속되는 수3

입출력 및 복잡도

https://www.codetree.ai/ko/trails/complete/curated-cards/challenge-continuous-number3/description

연속되는 수 3 설명 | 코드트리

연속되는 수 3을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

`증가하는 연속 부분 수열`

연속하는 부분 수열 중 원소의 숫자가 계속 증가하는 수열

내풀이

앞에서 배운 틀을 유지하되, "원소의 숫자가 증가하는 수열"만 적용해 코드를 작성했더니 해설코드와 똑같이 나왔습니다.

개념설명과 쌍을 이루는 기본문제와 여러 Challenge문제가 변형이 잘 되는 것 같습니다.

#include<bits/stdc++.h>
using namespace std;
int n, arr[1004], cnt, ret = -1e9;
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >>  n; 
    for(int i = 0; i < n; i++) {
        cin >> arr[i];
    }
    for(int i = 0; i < n; i++) {
        if(i >= 1 && arr[i] > arr[i-1]) cnt++;
        else cnt = 1;
        ret = max(ret, cnt);
    }
    cout << ret;
    return 0;
}

Challenge : 연속되는 수 4

입출력 및 복잡도

내풀이

#include<bits/stdc++.h>
using namespace std;
int n, arr[1004], cnt, ret = -1e9;
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >>  n; 
    for(int i = 0; i < n; i++) {
        cin >> arr[i];
    }
    for(int i = 0; i < n; i++) {
        if(i >= 1 && arr[i] > arr[i-1]) cnt++;
        else cnt = 1;
        ret = max(ret, cnt);
    }
    cout << ret;
    return 0;
}

해설코드

#include <iostream>
#include <algorithm>

#define MAX_N 1000

using namespace std;

int n;
int arr[MAX_N];

int main() {
    // 입력
    cin >> n;
    for(int i = 0; i < n; i++)
        cin >> arr[i];
    
    // 연속하여 동일한 숫자가 나오는 횟수를 구해보며,
    // 그 중 최댓값을 갱신합니다.
    int ans = 0, cnt = 0;
    for(int i = 0; i < n; i++) {
		// Case 1
        if(i >= 1 && arr[i] > arr[i - 1])
            cnt++;
		// Case 2
        else
            cnt = 1;
        
        ans = max(ans, cnt);
    }
    
    cout << ans;
    return 0;
}

Test : T를 초과하는 연속 부분 수열

Test: T를 초과하는 연속 부분 수열

입출력 및 복잡도

내풀이

풀이시간 1시간

접근 방법

현재 탐색하는 원소가 T보다 큰 경우와 T보다 작거나 같은 경우로 나눠 연속 부분 수열을 구한다

막힌 지점

이전 문제들처럼 이전 요소간의 비교가 필요하다고 생각해, arr[i] > t && arr[i-1] > t 일 때 cnt++ 하는 코드 작성. 이는 이전 요소가 arr[i] 현재 탐색하는 시점일 때 cnt++한 것을 중복으로 세어 정답보다 많은 값이 나오게 됨
현재 탐색하는 원소가 t 보다 큰 것을 카운팅하는 것이 목적이고, 이전 요소가 t보다 큰 것은 확인할 필요가 없음. 현재 탐색하는 원소가 t보다 작거나 같을 때 카운팅을 초기화 하면 됨

놓친 지점

테스트 케이스 `4 1 3 3 3 3` 일 때, 이전 문제처럼 첫 카운트 변수 (cnt )를 1로 초기화 하면 안됨.
- 이전에는 조건이 숫자이기만 하면 1개는 카운팅 되었고, 이 문제는 T보다 클 때만, 연속 부분 수열이 되기 때문

#include <bits/stdc++.h>
using namespace std;
int n, t, arr[1004], cnt , ret= -1e9;
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n >> t; 
    for(int i = 0; i< n; i++) cin >> arr[i];

    for(int i = 0; i < n; i++) {
        if(arr[i] > t) {
            cnt++;
        }
        else cnt = 0;
        ret = max(ret, cnt);
    }

    cout << ret << '\n';
    return 0;
}

해설코드

#include <iostream>
#include <algorithm>

#define MAX_N 1000

using namespace std;

int n, t;
int arr[MAX_N];

int main() {
    // 입력
    cin >> n >> t;
    for(int i = 0; i < n; i++)
        cin >> arr[i];
    
    // 연속하여 t보다 큰 숫자가 나오는 횟수를 구해보며,
    // 그 중 최댓값을 갱신합니다.
    int ans = 0, cnt = 0;
    for(int i = 0; i < n; i++) {
		// Case 1
        if(arr[i] > t)
            cnt++;
		// Case 2
        else
            cnt = 0;
        
        ans = max(ans, cnt);
    }
    
    cout << ans;
    return 0;
}

코드트리 청약 챌린지 진행중입니다!

같이 코테 꾸준히 공부해봅시다

https://www.codetree.ai/ko/no-free-lunch-2026/?ref=T38PMZ

3년 만에 돌아온, 코드트리 청약 통장 챌린지 | 코드트리

www.codetree.ai

[CodeTree] 4회차: 코테 꾸준히 하고자 하는 습관을 지켜주는 환경 (feat. 학습 리마인더 알림톡)

geologs — Mon, 1 Jun 2026 15:30:30 +0900

학습 독려 : 학습 리마인더 알림톡

이번 주에는 자격증 시험이 2개나 겹쳐 있어서 코드트리를 꾸준히 하지 못했습니다. 저는 꾸준하게 하던 걸 중단하고 다시 시작하는데 많은 에너지가 소요되는 편입니다. 꾸준하게 할 때의 수준까지 도달하는데 얼마나 걸릴지 모르기 때문에 부담감이 생기기 때문입니다.

코드트리의 장점은 며칠 연속으로 문제를 꾸준히 풀었는지 기록하는 스트릭이 중단되면, 학습 텐션을 유지하는데 필요한 시간을 카카오톡 알림톡으로 학습 라마인드를 해줍니다. 원래 텐션으로 돌아가는데 생각한 시간은 1시간 넘을 줄 알았는데 생각보다 적은 학습 유지시간이 보이면 가볍게 1문제라도 풀게 되는 것 같습니다.

나만의 꾸준함을 만드는 방법

기상 후 컴퓨터 키면 바로 코드트리 화면이 보이게한다

기상 후 컴퓨터 화면 잠금 해제 시 보이는 화면을 코드트리로 합니다. 저는 평소에 기상 후 바로 이부자리를 정리하는 습관이 있습니다. 습관이 잡히니 시도하는데 에너지가 쓰이지 않고 깨끗해진 자리를 보면서 기분은 금방 좋아져서 꾸준히 하게 됩니다.

그래서 이와 비슷하게 일어나자 마자 아무 생각없이 보이는 화면이 코트트리이면 오늘의 정해진 학습 분량을 문제 풀 때마다 보여주니, 이것만 해도 퀘스트를 깨는 느낌이 납니다. 한 문제 더 풀까? 문제는 풀지 않더라도 개념 설명이라도 볼까? 라는 마음이 생겼습니다.

목표

현재는 하루 30분 기준이 목표 기준치인데 1주 스트릭을 연속으로 채우면 조금씩 늘려서 더 많은 문제를 꾸준히 할 수 있는 능력치를 기르고 싶습니다.

청약 챌린지에 참여하는 다른 사람의 우수 후기를 본다

코드트리 청약 챌린지에 참여하게 되면 매주 우수 학습 후기를 선정합니다. 학습 후기를 읽으면서 다른 사람들의 학습 방법, 진행 상태 등을 확인할 수 있어 꿀팁들도 알아갈 수 있었습니다.

열심히 하는 분들의 글을 읽으면 저도 더욱 더 꾸준히 노력해야겠다는 생각이 들었습니다. 또한 실력이 좋은 분들도 참여하는 만큼 학습 자료들이 좋다는 방증을 한다고 생각했습니다.

주마다 선정된 우수학습 후기

이번 주 회고 및 다음 주 목표

이번 주 완료한 것

Ch4.시뮬레이션 완료, Ch5. 시뮬레이션2 최장연속 부분 수열
배운 개념 및 푼 문제 블로그 정리

다음 주 목표

다음 주는 시험 일정이 없으니 목표를 크게 잡아보겠습니다.

1. 7일 동안 매일 스트릭 채우기

2. 하루 1개 Lesson 완료 - Ch7. 완전탐색2 까지

학습 내용 정리

트레일을 진행하면서 남긴 학습 기록은 다음을 참고해주세요

https://geologs.tistory.com/43

[CodeTree] Ch4. 시뮬레이션1 - 사각형 칠하기

코드 트리 청약 챌린지 진행 중입니다! 관심 있으신 분들은 같이 참여해보세요 https://www.codetree.ai/ko/no-free-lunch-2026/?ref=T38PMZ 3년 만에 돌아온, 코드트리 청약 통장 챌린지 | 코드트리매주 학습 납

geologs.tistory.com

https://geologs.tistory.com/47

[CodeTree] Ch5.시뮬레이션 2 - 최장 연속 부분 수열

DP(Dynamic Programming)의 유형인 LCS(Longest Common Subsequence) 최장 공통 부분 수열과 다른 유형입니다.최장 연속 부분 수열은 구현 시뮬레이션 문제입니다. 개념 : 숫자가 동일한 연속 부분 수열수열이 (2,

geologs.tistory.com

코드트리 청약 챌린지 진행중입니다!

같이 코테 꾸준히 공부해봅시다

https://www.codetree.ai/ko/no-free-lunch-2026/?ref=T38PMZ

3년 만에 돌아온, 코드트리 청약 통장 챌린지 | 코드트리

www.codetree.ai

청약 챌린지 관련한 내용은 다음을 참고해주세요

https://geologs.tistory.com/38

[CodeTree 후기] 코드트리 청약 챌린지 참여 - 2회차 : 갭체크

백준 알고리즘 사이트가 종료되고 매일 꾸준히 알고리즘 문제를 푸는 습관을 기르고자 찾아보던 중 코드 트리의 청약 챌린지를 알게 되었습니다. 코드트리란?CodeTree도 백준 처럼 알고리즘 문제

geologs.tistory.com

[CodeTree] Ch4. 시뮬레이션1 - 사각형 칠하기

geologs — Tue, 26 May 2026 11:13:38 +0900

코드 트리 청약 챌린지 진행 중입니다!

관심 있으신 분들은 같이 참여해보세요

https://www.codetree.ai/ko/no-free-lunch-2026/?ref=T38PMZ

3년 만에 돌아온, 코드트리 청약 통장 챌린지 | 코드트리

www.codetree.ai

사각형 칠하기 1

좌표상 사각형 넓이 구하는 방법

좌표상의 좌표 2개를 주고 좌표 안의 사각형 넓이를 구할 때는 좌표를 2차원 격자(배열)로 바꾸고, 좌표 안의 격차일 때 1 값을 저장해 넓이를 구한다.

(x1, y1), (x2, y2) 좌표 영역의 사각형을 2차원 격자로 바꿀 때 오른쪽 상단의 좌표를 (x2 -1, y2-1)을 해야한다.

(2,5), (4, 8) 좌표 영역을 2차원 배열로 만들면, 오른쪽 그림처럼 [2행 5열], [2행 6열], [2행 7열], [3행 5열], [3행 6열], [3행 7열]의 넓이가 1인 정사각형을 카운팅하는 것이기 때문이다.

또한 좌표의 범위가 -100 <= x <= 100이라서 배열의 인덱스가 음수가 된다. 인덱스 에러 방지를 위해 범위의 최솟값을 오프셋을 더한다.

e.g. x = -100 -> x + 100 = -100 + 100 = 0 으로 평행이동하는 것과 같다.

사각형 칠하기 기본 개념

기본 설명에서는 90도 회전한 2차원 배열을 만들었지만, 나의 경우 y(행) -> x(열) 좌표로 탐색하는 것이 익숙했기에 해설과 달리 코드를 작성했다.

문제

사각형 총 넓이 2

입력 출력

https://www.codetree.ai/ko/trails/complete/curated-cards/intro-total-width-of-a-rectangle2/description

사각형의 총 넓이 2 설명 | 코드트리

사각형의 총 넓이 2을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

내 코드

해설코드는 기본적으로 x1 < x2, y1 < y2를 가정하고 있어 대소 비교를 하는 코드가 없음
C++에서 <bits/stdc++.h>를 사용하면 모든 라이브러리를 가져오기 때문에 전역변수 명인 y1 변수명이 존재합니다. 따라서 #define으로 임의의 문자열로 대체해야합니다.

#include<bits/stdc++.h>
using namespace std;
#define y1 aaaa

int N, ret, mxx, mxy, mnx, mny;
int x1[10], y1[10];
int x2[10], y2[10];
int offset = 100; 
int arr[204][204];
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> N;

    for (int i = 0; i < N; i++) {
        cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
        x1[i] += offset;
        x2[i] += offset;
        y1[i] += offset;
        y2[i] += offset;
        if(x1[i] > x2[i]) {
            mxx = x1[i]; mnx = x2[i];
        }
        else mxx = x2[i], mnx = x1[i];
        if(y1[i] > y2[i]) mxy = y1[i], mny = y2[i];
        else mxy = y2[i], mny = y1[i];

        for(int j = mny; j <= mxy - 1; j++ ) {
            for(int k = mnx; k <= mxx -1; k++) {
                arr[j][k] = 1; 
            }
        }
    }

    for(int i = 0; i < 204; i++ ) {
        for(int j = 0; j < 204; j++) {
            if(arr[i][j] == 1) ret++; 
        }
    }

    cout << ret << "\n";
    return 0;
}

채점 결과

해설 코드

#include <iostream>

#define MAX_N 10
#define MAX_R 200
#define OFFSET 100

using namespace std;

int n;
int x1[MAX_N], y1[MAX_N];
int x2[MAX_N], y2[MAX_N];

int checked[MAX_R + 1][MAX_R + 1];

int main() {
    // 입력
    cin >> n;
    
    for(int i = 0; i < n; i++) {
        cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
        
        // OFFSET을 더해줍니다.
        x1[i] += OFFSET;
        y1[i] += OFFSET;
        x2[i] += OFFSET;
        y2[i] += OFFSET;
    }
    
    // 직사각형을 칠해줍니다.
    // 격자 단위로 진행하는 문제이므로
    // x2, y2에 등호가 들어가지 않음에 유의합니다.
    for(int i = 0; i < n; i++)
        for(int x = x1[i]; x < x2[i]; x++)
            for(int y = y1[i]; y < y2[i]; y++)
                checked[x][y] = 1;
    
    // 직사각형 넓이의 총 합을 구합니다.
    int area = 0;
    for(int x = 0; x <= MAX_R; x++)
        for(int y = 0; y <= MAX_R; y++)
            if(checked[x][y])
                area++;
    
    cout << area;
    return 0;
}

사각형 칠하기2 : 여러 직사각형의 넓이 구하기

이 문제의 경우 여러 사각형을 나타내는 좌표 중에서 가장 작은 x좌표, y좌표와 가장 큰 x좌표, y좌표 영역을 탐색하면서 M 사각형을 제외한 사각형의 넓이를 구하면 된다.

각 사각형 간의 영역을 구분하기 위해 이전과 다르게 1, 2 다르게 표기한다.

https://www.codetree.ai/ko/trails/complete/curated-cards/intro-area-of-non-overlapping-rectangle/description

겹치지 않는 사각형의 넓이 설명 | 코드트리

겹치지 않는 사각형의 넓이을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

겹치지 않는 사각형의 넓이 구하기

입출력

내 코드

주어진 좌표마다 Offset을 더해야하고, 사각형마다 영역을 표기하는 반복문에서 중복되는 코드가 많이 발생했다.

이는 가독성에서는 함수로 인자만 전달해 처리하는 것이 좋아보인다. 하지만 함수 호출은 비용이 들기 때문에 여기서는 하지 않았다.

해설코드 피드백

사각형별로 좌표 변수를 다 선언할 필요 없음. 배열의 크기가 3인 배열 4개를 활용 x1[3], x2[3], y1[3], y2[3]
배열에 사각형 좌표를 저장하면 이중 for문과 offset 더하는 부분이 1개로 축약됨

#include<bits/stdc++.h>
#define offset 1000

using namespace std;
int ax1, ay1, ax2, ay2, bx1, bx2, by1, by2, mx1, mx2, my1, my2; 
int ret, mnx, mxx, mny, mxy; 
int checked[2004][2004]; 
int main() {
    ios_base::sync_with_stdio(false);
    cin >> ax1 >> ay1 >> ax2 >> ay2;
    cin >> bx1 >> by1 >> bx2 >> by2; 
    cin >> mx1 >> my1 >> mx2 >> my2;

    ax1 += offset;  ax2 += offset; ay1 += offset; ay2 += offset;
    bx1 += offset; bx2 += offset;  by1 += offset; by2 += offset;
    mx1 += offset; mx2 += offset; my1 += offset; my2 += offset;

    mnx = min(ax1, bx1);
    mxx = max(ax2, bx2);
    mny = min(ay1, by1);
    mxy = max(ay2, by2);

    for(int y = ay1 ; y < ay2; y++) {
        for(int x = ax1; x < ax2; x++) {
            checked[y][x] = 1;
        }
    }
    for(int y = by1 ; y < by2; y++) {
        for(int x = bx1; x < bx2; x++) {
            checked[y][x] = 2;
        }
    }

    for(int y = my1 ; y < my2; y++) {
        for(int x = mx1; x < mx2; x++) {
            checked[y][x] = 0;
        }
    }
    for(int y = mny; y < mxy; y++) {
        for(int x = mnx; x < mxx; x++) {
            if(checked[y][x]) ret++;
        }
    }
    cout << ret << "\n";
    return 0;
}

실행결과

해설코드

#include <iostream>

#define N 3
#define MAX_R 2000
#define OFFSET 1000

using namespace std;

int x1[N], y1[N];
int x2[N], y2[N];

int checked[MAX_R + 1][MAX_R + 1];

int main() {
    // 입력
    for(int i = 0; i < N; i++) {
        cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
        
        // OFFSET을 더해줍니다.
        x1[i] += OFFSET;
        y1[i] += OFFSET;
        x2[i] += OFFSET;
        y2[i] += OFFSET;
    }
    
    // 직사각형에 주어진 순으로 1, 2, 3 번호를 붙여줍니다.
    // 격자 단위로 진행하는 문제이므로
    // x2, y2에 등호가 들어가지 않음에 유의합니다.
    for(int i = 0; i < N; i++)
        for(int x = x1[i]; x < x2[i]; x++)
            for(int y = y1[i]; y < y2[i]; y++)
                checked[x][y] = i + 1;
    
    // 1, 2, 3 순으로 붙였는데도
    // 아직 숫자 1, 2로 남아있는 영역의 넓이를 구합니다.
    int area = 0;
    for(int x = 0; x <= MAX_R; x++)
        for(int y = 0; y <= MAX_R; y++)
            if(checked[x][y] == 1 || checked[x][y] == 2)
                area++;
    
    cout << area;
    return 0;
}

Challenge 1 : 색종이의 총 넓이

https://www.codetree.ai/ko/trails/complete/curated-cards/challenge-the-total-area-of-colored-paper/description

색종이의 총 넓이 설명 | 코드트리

색종이의 총 넓이을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

Challenge 2 : 잔해물을 덮기 위한 사각형의 최소 넓이

https://www.codetree.ai/ko/trails/complete/curated-cards/challenge-minimum-area-of-rectangle-to-cover-debris/description

잔해물을 덮기 위한 사각형의 최소 넓이 설명 | 코드트리

잔해물을 덮기 위한 사각형의 최소 넓이을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

Challenge2 : 잔해물을 덮기 위한 사각형의 최소 넓이

입출력 예제

복잡도

개인적인 평가

코드를 작성하는 것보다 풀이 방법을 떠올리는데 시간이 많이 소요됨
겹치는 영역이 첫번째 직사각형의 가로/세로 부분을 모두 겹치는 것도 아니어서 어떻게 덮는 게 최소 직사각형인지 방법을 떠올리는 것이 어려움.

내풀이

풀이시간 : 4시간

접근방법

각각 사각형의 양끝 좌표를 기준으로 2차원 배열에 첫번째 사각형은 1, 두번째 사각형은 2로 색칠(저장)한다.
첫번째 사각형 영역을 탐색하며 두번째 사각형과 겹치지 않는 "첫번째 사각형 영역" 1인 영역 중 좌표(인덱스) x의 최소/최댓값, y의 최소/최댓값을 구한다.
두번째 사각형이 첫번째 사각형의 모든 영역을 덮어쓴 경우와 아닌 경우를 나누어 첫번째 사각형의 넓이를 덮을 최소 넓이를 구한다.

실수한 부분

벡터에 첫번째 사각형의 영역 중 겹치지 않은 부분의 좌표만 저장하고, sort()로 정렬할 때 맨 마지막 원소의 (y, x)일 때 y는 가장 큰 값일지언정 x는 큰 값이 들어가는 것이 아님.

    for(int i = 0; i < MAX; i++) {
        for(int j = 0; j < MAX; j++) {
            if(arr[i][j] == 1 || arr[i][j] == 3) v.push_back({j,i}); // x, y좌표 
        }
    }
    sort(v.begin(), v.end()); // v[(int)v.size() - 1]

맞춘 풀이

해설코드와 다른 점

해설코드는 두 사각형이 겹친 부분에 3이란 다른 값을 넣지 않음, 겹친 부분은 두번째 사각형이 마지막으로 칠하는 상태로 둠
- 이걸 적용하면 3중 for문에서 조건문이 제거됨. 실행시간이 4ms, 메모리 1ms 감소됨

#include<bits/stdc++.h>
using namespace std;
#define y1 aaaa
#define OFFSET 1000
#define MAX 2004
int mxx[2], mxy[2],mnx[2], mny[2]; 
int x1[2],x2[2], y1[2], y2[2];
int arr[MAX][MAX];
vector<pair<int,int>> v; 
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    for(int i = 0; i < 2; i++) {
        cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
        x1[i] += OFFSET; y1[i] += OFFSET; x2[i] += OFFSET; y2[i] += OFFSET;
    }

    // 2차원 좌표에 각 사각형의 영역을 색칠한다. 
    for(int i = 0; i < 2; i++) {
        mxy[i] = max(y1[i], y2[i]); mny[i] = min(y1[i], y2[i]);
        mxx[i] = max(x1[i], x2[i]); mnx[i] = min(x1[i], x2[i]);
        for(int j = mny[i]; j < mxy[i]; j++) {
            for(int k = mnx[i]; k < mxx[i]; k++) {
                if(arr[j][k] != 0)  arr[j][k] = 3; // 두 사각형이 겹치는 영역 : 3
                else arr[j][k] = i + 1; // 1 : A, 2 : B
            }
        }
    }

    int mxx_ = -1e9, mxy_ = -1e9, mnx_ = 1e9, mny_ = 1e9;
    for(int i = mny[0]; i < mxy[0]; i++) { // i = y 
        for(int j = mnx[0]; j < mxx[0]; j++) { // j = x
            if(arr[i][j] == 1 ) {
                if(j > mxx_ ) mxx_ = j; 
                if(j < mnx_) mnx_ = j; 
                if(i > mxy_) mxy_ = i;
                if(i < mny_) mny_ = i;  
            }
        }
    }
    if(mxx_ == -1e9 ||  mxy_ == -1e9 ||  mnx_ == 1e9 ||  mny_ == 1e9) cout << 0 << "\n";
    else cout << (mxx_ - mnx_ + 1) * (mxy_ - mny_ + 1) << "\n" ; 

    



    return 0;
}

실행결과

해설코드

#include <iostream>
#include <algorithm>

#define N 2
#define MAX_R 2000
#define OFFSET 1000

using namespace std;

int x1[N], y1[N];
int x2[N], y2[N];

int checked[MAX_R + 1][MAX_R + 1];

int main() {
    // 입력
    for(int i = 0; i < N; i++) {
        cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
        
        // OFFSET을 더해줍니다.
        x1[i] += OFFSET;
        y1[i] += OFFSET;
        x2[i] += OFFSET;
        y2[i] += OFFSET;
    }
    
    // 직사각형에 주어진 순으로 1, 2 번호를 붙여줍니다.
    // 격자 단위로 진행하는 문제이므로
    // x2, y2에 등호가 들어가지 않음에 유의합니다.
    for(int i = 0; i < N; i++)
        for(int x = x1[i]; x < x2[i]; x++)
            for(int y = y1[i]; y < y2[i]; y++)
                checked[x][y] = i + 1;
    
    // 1, 2 순으로 붙였는데도
    // 아직 숫자 1로 남아있는 곳들 중 최대 최소 x, y 값을 전부 계산합니다.
    int min_x = MAX_R, max_x = 0, min_y = MAX_R, max_y = 0;
    bool first_rect_exist = false;
    for(int x = 0; x <= MAX_R; x++)
        for(int y = 0; y <= MAX_R; y++)
            if(checked[x][y] == 1) {
                first_rect_exist = true;
                min_x = min(min_x, x);
                max_x = max(max_x, x);
                min_y = min(min_y, y);
                max_y = max(max_y, y);
            }
    
    // 넓이를 계산합니다.
    int area;
    // Case 1. 첫 번째 직사각형이 전혀 남아있지 않다면 넓이는 0입니다.
    if(!first_rect_exist)
        area = 0;
    // Case 2. 첫 번째 직사각형이 남아있다면, 넓이를 계산합니다.
    else
        area = (max_x - min_x + 1) * (max_y - min_y + 1);

    cout << area;
    return 0;
}

Test : 계속 중첩되는 사각형 설명

https://www.codetree.ai/ko/trails/complete/curated-cards/test-continuously-overlapping-squares/description

계속 중첩되는 사각형 설명 | 코드트리

계속 중첩되는 사각형을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

문제

입출력 및 복잡도

내 코드

풀이 논리

사각형 칠하기 개념 두번째 문제처럼 사각형 별로 좌표에 해당하는 영역을 2차원 배열에 표기
사각형이 빨간색 -> 파란색 -> 빨간색 .. 반복되니까 모듈러 연산자로 영역을 구분

놓친 부분

빨간색, 파란색 번갈아가며 색칠하되, 마지막으로 색칠된 것은 파란색이 아닐 수도 있음
테스트 케이스가 번갈아가면서 색이 바뀌니까 모듈러 연산자(나머지 연산자)로 사각형 별로 영역을 표기해줘야함.

해설 코드 차이점

해설 좌표를 기반으로 사각형 영역 표기할 때 if문으로 쓰지 않고 삼항 연산자(? : )를 이용해 간단히 표현함
- i % 2 ? 2 : 1
해설은 OFFSET 적용을 입력받을 때 진행하여, 목적별로 분리가 잘 됨.

#include<bits/stdc++.h>
#define OFFSET 100
#define y1 aaaa
#define MAX 204
using namespace std;
int checked[MAX][MAX];
int x1[MAX], y1[MAX], ret;
int x2[MAX], y2[MAX];
int n; 
int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n; 
    for(int i = 0; i < n; i++) {
        cin >>  x1[i] >> y1[i] >> x2[i] >> y2[i];
    }

    for(int i = 0; i < n; i++ ) {
        x1[i] += OFFSET; y1[i] += OFFSET;
        x2[i] += OFFSET; y2[i] += OFFSET;
        for(int j = y1[i]; j < y2[i]; j++) {
            for(int k = x1[i]; k < x2[i]; k++) {
                // if(checked[j][k]) checked[j][k] = 3; 
                if(i % 2 == 0) checked[j][k] = 2;
                else checked[j][k] = i % 2; 
            }
        }
    }

    for(int i  = 0; i < MAX; i++) {
        for(int j = 0; j < MAX; j++) {
            if(checked[i][j] % 2 == 1) {
                // cout << i << " : " << j << "\n";
                ret++;
            }
        }
    }
    cout << ret << "\n"; 


    return 0;
}

실행 결과

해설 코드

#include <iostream>

#define MAX_N 10
#define MAX_R 200
#define OFFSET 100

using namespace std;

int x1[MAX_N], y1[MAX_N];
int x2[MAX_N], y2[MAX_N];

int checked[MAX_R + 1][MAX_R + 1];

int main() {
    // 변수 선언 및 입력
    int n;
    cin >> n;
    for(int i = 0; i < n; i++) {
        cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
        
        // OFFSET을 더해줍니다.
        x1[i] += OFFSET;
        y1[i] += OFFSET;
        x2[i] += OFFSET;
        y2[i] += OFFSET;
    }
    
    // 직사각형에 주어진 순으로 1, 2 번호를 붙여줍니다.
    // 격자 단위로 진행하는 문제이므로
    // x2, y2에 등호가 들어가지 않음에 유의합니다.
    for(int i = 0; i < n; i++)
        for(int x = x1[i]; x < x2[i]; x++)
            for(int y = y1[i]; y < y2[i]; y++)
                checked[x][y] = i % 2 ? 2 : 1;
    
    // 숫자 2로 남아있는 영역의 넓이를 구합니다.
    int area = 0;
    for(int x = 0; x <= MAX_R; x++)
        for(int y = 0; y <= MAX_R; y++)
            if(checked[x][y] == 2)
                area++;
    
    cout << area;
    return 0;
}

[CodeTree] 3회차: Trail2.시뮬레이션1 약점 학습 후기

geologs — Fri, 22 May 2026 10:54:58 +0900

처음 갭체크를 통해 약점 유형인 시뮬레이션부터 시작을 했습니다.

간단 후기

레슨은 기본 개념 -> Challenge -> Test 순으로 개념을 적용할 수 있는 문제를 제공합니다.

레슨을 3개 진행해보니,

기본 개념에서 정의 및 여러 풀이 방법 소개, 최선 풀이 이유, 시각화 제공
Challenge는 개념 1개를 알면 그 1개를 적용해서 풀 수 있는 문제를 제공하고,
Test는 앞에 여러 개념을 배웠다면 이걸 한 번에 활용한 문제를 제공한 느낌을 받았습니다.

또한 배우지 않은 내용을 알아야 풀 수 있는 문제가 아니라서 문제를 이해할 때, 풀 때 부담감(스트레스)가 적었습니다.

Lesson 소개

1. 기본 개념

먼저 시뮬레이션의 유형인 1.날짜와 시간에 대한 개념을 먼저 소개를 합니다.

이전에 백준 실버 후반 ~ 브론즈 상위 문제에서 시간 계산을 하는 문제를 풀었던 적이 있습니다. 이때 모든 시간, 분을 체크하는 방식만 떠올리고 차이를 먼저 떠올리고 다른 풀이 방법을 생각하지는 않았었는데요. 여기서는 목표 시간과 문제에서 주어진 시간의 차이를 구하는 것이 연산이 적어 빠르다는 개념을 소개해서 좋았습니다.

-> 여러 풀이 방법을 심플하게 설명하고 시각화한 부분이 이해하는데 도움이 되었습니다.

기본 개념

흐른 시간 계산 방법

2. Challenge

Challenge 부분은 기본 개념에서 소개한 개념 설명과 코드 예제 방식을 그대로 적용하지만, 입출력을 조건에 맞게 변형하는 것이 추가됩니다.

Challenge 문제

3. Test

Test문제인데요 이는 앞의 개념이 2개 이상이라면 이를 둘다 활용해야하는 문제가 제공됩니다.

Test 문제

4. 토론 : 빠른 답변 제공 ⭐️

문제를 풀다가 이해가 가지 않을 때, 맞왜틀 등 토론에 글을 작성하면 코드트리 관계자분들이 빠르게 답변을 달아주십니다!

요즘 AI가 답변을 잘해주긴 합니다만, 코딩테스트를 공부할 때는 AI에게 질문하다가 정답을 강제로 알게 되는 불상사(?)가 발생할 수 있어 토론 탭을 이용하는 것이 좋다고 생각합니다.

토론에 작성된 모든 글에 답변이 달려있어 저와 동일한 문제를 겪었던 분들 글을 참고해 문제를 스스로 끝까지 풀 수 있었습니다.

저도 토론 탭을 통해 질문을 했었는데 늦어도 1시간 안에 답변 받은 것 같습니다.

단점은 이미지가 첨부가 안되는 것인데 마크 다운 형식으로 질문글을 올려야해서 외부에 올라간 이미지인 경우 url만 붙여넣으면 이미지 첨부가 가능합니다.

토론 탭에서는 마크다운 문법을 지원하고 있습니다. 마크다운에서 이미지는 다음과 같이 첨부가 가능합니다.

![대체 텍스트](이미지 링크)

별도의 저장소에 이미지를 업로드하신 뒤 위의 문법에 따라 URL을 통해 이미지를 첨부해주실 수 있습니다

토론 글

토론 질문글 답변

5. 히든 케이스, 실제답, 내 코드 출력값 제공 ⭐️

제출한 코드가 틀렸을 때 히든 테스트 케이스, 내코드의 출력값과 실제 답을 알려줘서 디버깅하기 용이합니다.

제가 풀었던 코딩테스트 사이트들은 히든 케이스를 명시적으로 제공하지 않습니다. 그 이유는 실제 코딩테스트에서도 예시 몇 개만 제공하지 히든 케이스는 직접 예외 케이스를 찾아야하기 때문입니다.

실제 코딩테스트에서는 히든 케이스까지 직접 찾아야 하지만, 막 입문한 입장에서는 이렇게 히든 케이스가 제공된다는 점이 꾸준히 공부하는 습관을 만드는 디딤돌이 되는 것 같습니다.

히든 테스트케이스

6. 해설 코드 제공 ⭐️

해설 코드와 문제 풀이 의도를 제공하는 것이 정말 좋은 점이라 생각합니다.

보통 문제를 맞춰도 이게 좋은 풀이일까? 내가 배운 개념을 제대로 적용한 것일까? 라는 의문을 품고, 이상적인 답을 찾는데 많은 시간을 보낸 적이 있었는데요.

의도랑 해설코드를 제공해줘서 사고 과정을 교정할 수 있고, 더 효율적인 풀이 or 범용적인 풀이를 해설 코드를 통해 알아갈 수 있어 좋았습니다. 해설 코드에 대한 시간복잡도를 제공해줘서 내 풀이에 대한 시간복잡도를 비교해 더 좋은 풀이인지 체크할 수 있었습니다.

해설

해설코드

토론 기능 적극 활용한 문제 : 흰검 칠하기

https://www.codetree.ai/ko/trails/complete/curated-cards/challenge-painting-white-black/description

흰검 칠하기 설명 | 코드트리

흰검 칠하기을 통해 문제 요구사항과 입력·출력 예시를 꼼꼼히 확인해 정확한 풀이 전략을 세워보세요.

www.codetree.ai

아래 문제를 풀 때 "현재 위치 타일 포함 총 x칸 타일을 연속하게 칠함"에서 저는 현재 위치 타일은 미포함하게 구간을 잡는 바람에 정답과 작은 차이가 계속 났었습니다. 30분정도 고민해도 무엇이 문제인지 몰라서, 해설을 보지 않고 작성한 코드와 이해가 안가는 부분을 토론에 질문을 남겼습니다.

체감상 30분~ 1시간 후에 답변이 달렸고 "현재 위치 타일 포함"을 하면 된다는 답변을 받고 문제를 풀 수 있었습니다. AI를 통해 문제점을 찾을 수 있지만, 문제, 입력값, 출력값을 직접 제공해야하는 불편과 히든케이스는 고려하지 못한다는 점 때문에 토론을 이용한 것이 유용했습니다.

직접 문제를 풀었지만, 수행시간과 메모리가 높아 북마크로 저장해두고 다음에 다시 풀어보려고합니다.

그 외 좋은 기능

그 외 문제 풀이 외에 좋다고 생각한 기능들은 다음과 같습니다

목표 달성 경험치바

매일 목표를 달성하면 자동적으로 경험치가 채워지는게 눈에 보여서 더 열심히 하게 됩니다. 문제를 풀고 바로 다음 문제를 또 풀고 싶어지더라고요.

테스트케이스 입력시 정답 값은 자동 생성

보통 테스트케이스 입력값과 정답(출력값)을 직접 찾아야하는데 입력값만 조건에 맞게 제공하면 자동으로 정답값을 만들어 줘서 테스트 하기 편했습니다.

다음 목표

아직 시뮬레이션1의 모든 파트를 끝내지 못했는데요, 다음 미션까지 시뮬레이션1, 2를 끝내는 것이 목표입니다. 더 할 수 있다면 완전탐색까지 진행하고 싶습니다.

[CodeTree 후기] 코드트리 청약 챌린지 참여 - 2회차 : 갭체크

geologs — Mon, 18 May 2026 01:21:39 +0900

백준 알고리즘 사이트가 종료되고 매일 꾸준히 알고리즘 문제를 푸는 습관을 기르고자 찾아보던 중 코드 트리의 청약 챌린지를 알게 되었습니다.

코드트리란?

CodeTree도 백준 처럼 알고리즘 문제를 푸는 사이트이지만, 단계적으로 문제와 해설코드를 제공합니다. 체계적으로 배우고자 하는 분들에게 추천합니다. 대신 무료가 아닌 유료입니다. 제휴 대학이면 무료로 이용할 수 있지만, 아니더라도 대학 계정 인증을 통해 할인된 금액으로 정기권을 구매할 수 있습니다.

코테 청약 통장 챌린지

3년만에 코테 청약 통장 챌린지를 진행하고 있습니다. 이는 7주간 유료로 제공되는 코드트리 서비스를 무료로 이용할 수 있는 이벤트 입니다. 매주 학습 인증 시 통장 만기일(7주)까지 모든 콘텐츠를 '무료'로 이용할 수 있습니다. 무료로 꾸준히 공부할 수 있으니 추천합니다.

총 6회 납입 시 무료 사용 연장(8월 31일까지) 제공합니다. 9월에 2학기 개강을 하니 방학 때 코테 실력을 기르고자 하는 학생 혹은 하반기 코테 노리는 취준생 분들이 적합할듯 합니다.

언제든지 참여가 가능합니다.

https://www.codetree.ai/ko/no-free-lunch-2026/?ref=T38PMZ

3년 만에 돌아온, 코드트리 청약 통장 챌린지 | 코드트리

www.codetree.ai

완주를 하지 않고 청약 통장만 만들어도 맥북, 애플워치, 스타벅스 상품권 등 경품 추천까지 가능하다니 만들어만 놔도 좋을 것 같습니다.

갭체크 후기

Gap Check로 현재 저의 위치를 확인하는 과정을 거쳤는데요, 본인이 작성한 코드 기반으로 본인이 어느 파트에서 부족한지 확인할 수 있었습니다. 총 문제는 4문제를 풀었습니다.

문제를 고르기 전에 현재 상태에 따라 제공되는 문제의 유형이 다른데요, 저는 현재 어느 파트를 공부하고 있다는 선지를 골랐습니다. 그리고 그에 대한 문제가 나왔고 못푼 문제가 나오면 다음 문제는 난이도를 조절해서 나오더라구요. 그래서 현재 상태를 파악하면서 못풀어서 낙심하는 감정이 덜 했던 것 같습니다.

풀면서 좋았던 점은

1. 제한 시간이 나와있다. 못풀면 다음 문제로 이동

- 백준이나 프로그래머스의 경우 문제를 내가 얼만큼 고민했는지 절대적인 시간을 체크하지 못해 맞출때까지, 혹은 답지를 볼 때까지 계속 푸는 경우가 있었기 때문에 저는 이 부분이 유독 마음에 들었습니다.

2. 무엇이 부족한지 알려준다.

- 평소 코테 문제를 풀면서 문제 이해를 '빠르고' '정확하게' 못한다는 느낌이 들었는데 그 유형이 시뮬레이션인 것을 알게되었습니다.

3. UI가 간편하다.

4. 예제에 대한 설명이 있다.

약 7주간 열심히 해보도록 하겠습니다.

[Claude Code] 1. Claude Code 설치, Command, Plan Mode, 토큰 관리, 세션 관리 + Whisper Flow 소개

geologs — Thu, 19 Mar 2026 18:12:22 +0900

Intro

저는 CLI를 활용해 AI가 코드를 직접 작성해주고 관리하는 것을 처음 시작해봅니다. 그 이유는 그동안 코드는 개발자가 직접 짰을 때 더 견고해진다고 느꼈고, 배울 때는 최대한 AI를 활용하는 것을 자제해야 생각하는 힘, 사고가 길러진다고 생각했습니다.

하지만 취업 준비를 하면서 채용 공고를 많이 보면서 AI를 활용할 수 있는 능력이 중요하고 요구하고 있구나를 느끼면서 다른 비전공생, 전공생보다 가산점이 되려면 적극적으로 활용하되, 생각을 멈추지 말자는 결론에 다다르게 되었습니다. 그래서 할거면 제대로 하자는 마인드로 클로드 코드에 관해 질적으로 좋은 콘텐츠들을 찾고 배우면서 기록하고자 이 글을 시작하게 되었습니다.

'시작은 미약하지만 그 끝은 창대하리라'라 생각하며 Claude Code부터 시작해 AI를 잘 활용하는 순간까지 담아보겠습니다.

1. 클로드 코드 설치

Mac OS 일반 Terminal에 입력하면 됩니다. brew를 이용하면 Claude Code가

curl -fsSL https://claude.ai/install.sh | bash

2. 클로드 코드 커맨드

/init

클로드 코드 CLAUDE.md 파일을 만들어주는 역할

CLAUDE.md

1. Claude Code 에서 프로젝트의 컨텍스트, 코딩 컨벤션, 명렁어 규칙 등을 정의해두는 설정파일

2. Claude가 프로젝트를 이해하고 일관된 방식으로 코드를 작성하도록 안내하는 "프로젝트 지침서" 역할

3. 컨텍스트 관리 도구

AI Agent 특징

컨텍스트 관리가 중요하다.

왜? CLAUDE.md는 매 대화 시작 시 자동으로 컨텍스트에 로드되기 때문에, 반복적으로 프로젝트 규칙이나 선호사항을 설명할 필요 없이 제한된 컨텍스트 윈도우를 효율적으로 활용할 수 있게 해줌.

즉, 토큰 낭비를 줄이면서도 Claude가 항상 프로젝트 맥락을 파악한 상태에서 작업을 시작하도록 보장하는 핵심 컨텍스트 관리 도구

3. Plan Mode ⭕️ 중요

1. Claude가 바로 코드를 작성하지 않고 먼저 구현 계획을 세우고 사용자와 확인하는 단계를 거치게 함으로써,

2. 잘못된 방향으로 대량의 토큰을 소비하는 것을 방지하고 정확한 결과물을 얻을 확률을 높여주는 비용·품질 최적화 전략

Plan Mode에서 세운 구현 계획은 Claude가 수정할 권한이 없음. 구현 계획 세운 다음 Edit On Mode 로 가자.

cf. Edit On Mode

바로 코드를 고쳐줌. 빨라보이지만, AI가 잘못 알아듣고 더 많은 파일을 고칠 확률이 높음. Plan Mode를 쓰자.

4. 토큰 관리 ⭕️ 중요

/context

60%이상 채워진 상태에서 계속 대화를 이어나가면 AI가 환각을 일으켜 비효율적인 대화가 됨. -> 컨텍스트를 정리해야함.

/context - 현재 컨텍스트의 카테고리별 사용량

컨텍스트 정리 방법 -2

/clear

지금까지 나눈 대화를 리셋시켜줌. 초반 대화 시작했을 때의 상태로 돌아감.

컨텍스트를 완전히 초기화하여 새 작업을 깨끗한 상태에서 시작할 수 있게 해줌.

/compact

현재 대화 내용을 요약해 컨텍스트 윈도우 사용량을 줄여줌

모든 대화를 없애진 않고, 어느 정도 이해한 상태에서 대화를 이어나가고 싶은 경우

5. 세션관리

병렬 처리

아래와 같이 여러 Claude Code를 실행시킨 후 여러 서브 에이전트를 실행시키는 것을 병렬적으로 처리한다라고 함.

이렇게 하나의 Claude Code 창은 하나의 세션을 가지는데, 여러 세션을 가진 경우 '관리'를 할 줄 알아야 함.

병렬 처리

세션 관리 명령어

claude --continue

내가 방금 끝냈던 Claude의 세션이 불러와 짐

claude --resume

지금까지 Claude와 나눴던 대화의 history 보여줌

단점 : 어떤 내용을 다뤘는지 바로 알기 힘듦.

해결책 : /rename <세션명> ⭕️ TIP

Claude와 대화를 하다가 직접 대화명을 지정하는 명령어.

e.g /rename <db_schema_update>

claude --resume했을 때 <db_schema_update>로 보여 원하는 대화를 빠르게 찾을 수 있음.

claude --resume

Git

버전 관리. Claude Code가 코드를 잘못 수정했을 때 즉시 이전 상태로 되돌릴 수 있는 안정망 역할을 함.

AI 와 협업할 때 자주 커밋하는 습관이 작업 손실 방지

Whisper Flow ⭕️ 추천

STT(Speak To Text) 기능 . 직접 타자 치지 않고 말로 Claude 에게 시킬 내용 작성 가능.

참고 영상

필요한 부분을 목차를 나눠 핵심만 빠르게 알려주시는 것이 좋아 영상의 내용을 정리했습니다.

실리콘벨리 메타 시니어 개발자분이시라 더 신뢰성 있습니다.

Claude Code 완벽 가이드 | 설치부터 실전 팁까지

https://www.youtube.com/watch?v=VQeug8daU9k&list=PLCaxhZL8UZLVFjbghVC4VTpD1mzsHDxyv

[백준] 6234번 : 용돈 관리 (도식화 -> 로직 -> 코드)

geologs — Wed, 11 Mar 2026 17:19:28 +0900

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

용돈 관리 문제의 경우 번역이 모호한 것이 있어 문제 이해를 하는데 오래 걸렸습니다.

금액의 경우 총 4가지 종류가 있습니다.

1. 통장 금액

2. 인출 금액 K

3. 현우가 하루 당 사용할 금액 a[i]

4. 잔액 = 인출 금액 K - 현우가 하루 사용할 금액 a[i]

TIP

여기서 1. 통장 금액의 경우 금액이 무한정라고 생각해야 문제가 이해가 됩니다.

목표

M번 인출할 수 있을 때 인출 금액 K의 최솟값을 구해야합니다.

도식화

예시를 통해 문제를 이해해봅시다.

1) N = 2일 동안 M = 3 번 인출할 수 있고, 인출 금액(K)가 500원일 때, 현우가 2일 동안 100원, 400원이 필요하다면

1일 때 인출된 금액 500원에서 100원을 소비하고 남은 금액이 400원이 됩니다. 이 남은 금액을 가지고 다음 날 사용할 금액에서 빼야합니다.

인출을 1번 했을 때, 모든 요일의 금액을 충당할 수 있기 때문에 조금 더 인출된 금액을 상향 시킬 수 있겠죠? 물론 2일차일 때 이미 남은 금액(400원)으로 2일차에서 필요한 금액 400원을 충당할 수 있지만 다시 인출을 할 수 있습니다. 그래서 M = 2를 맞출 수 있습니다.

인출 금액 K = 500원을 더 작게 만들어 봅시다. K = 400원으로 낮춘다면

1일 때 인출된 금액 400원에서 1일차에 100원을 소비하고 남은 금액은 300원이 됩니다. 남은 금액 300원으로는 2일차의 400원을 충당할 수 없습니다. 그러면 2일차 당일에 인출을 1회 합니다. 그럼으로써 실제로 인출한 횟수는 2회가 됩니다.

주의사항은 인출된 금액은 한번 더 인출한다고 해서 누적되지 않습니다.

지문에서 " 모자라게 되면 남은 금액은 통장에 집어넣고 다시 K원을 인출한다. " 라고 명시되어있기 때문입니다. 이 말은 인출 금액 K 400 원으로 남은 금액 300원을 담는 변수를 초기화 해야하는 것을 의미합니다.

그럼 인출 금액 400원으로 2번 인출이 가능해집니다. 하지만 이것이 최소 금액인지는 정확히 모릅니다.

로직

인출 금액이 가질 수 있는 값의 범위를 구해서 시작값부터 끝 값까지 for 반복문으로 선형 탐색하면서 최소 인출 금액 K를 구할 수 있습니다. 하지만 [시작값, 끝값] 범위가 10억을 넘어간다면 O(N)시간 초과가 발생합니다. 매우 큰 범위의 탐색을 하는 경우 "이분 탐색"을 하면 O(logN)의 복잡도로 줄어들게 됩니다.

주의 사항

- 이분 탐색으로 탐색할 범위는 입력으로 받은 현우의 사용 금액이 아닙니다. -> 정렬이 필요없는 이유

이분탐색 문제임에도 ‘현우가 이용할 금액’이 저장된 배열을 정렬하지 않는 이유는 이미 lo, hi가 탐색하는 배열은 등차가 1인 수열이므로 정렬을 할 필요가 없기 때문입니다.

→ low, high가 탐색하는 배열에 저장된 값이 어떤 값인지 확인

low와 high가 탐색하는 배열은 입력으로 받은 ‘현우가 이용할 금액’이 저장된 배열이 아니라 d = 1 인 등차수열입니다.

이분 탐색에 필요한 low, high 의 범위를 구해봅시다.

1. low

low = max(현우가 입력받은 사용금액) 입니다. 문제에서 '인출 금액 K < 하루 사용 금액 a[i] '인 경우 "남은 금액이 그날 사용할 금액보다 많더라도 남은 금액은 통장에 집어넣고 다시 K원을 인출할 수 있다." 라고 했기 때문입니다. n일차에 1번 인출 금액 K원을 가지고 현우가 n일차에 필요한 금액을 "무조건 차감"하게 됩니다.

2. high

high = 10000 vs. high = 1,000,000,000 (10억)중 무엇일까요?

정답은 high = 10억 입니다.

high = 10,000 이 틀린 이유

최악의 경우를 고려할 때 m 의 값을 고려해야합니다. 금액의 범위의 상한선이 되는 것이 아닙니다. (1 ≤ 금액 ≤ 10,000) m = 1 번 인출, n = 100,000일, 현우가 n일 동안 10,000원씩 필요하다면 총 1,000,000,000원이 인출금액이어야 성립합니다.

코드

#include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
ll a[100'004], n, m, ret = 1e18, mx = -1e18;
bool check(ll e_val) {
    int temp = e_val; 

    ll cnt = 0;
    for(ll i = 0; i < n; i++) {
        if(a[i] > e_val) { // 하루 가용 금액(K)로 사용 불가능한 경우 
            cnt++; 
            e_val = temp; 
        }
        // 하루 가용 금액(K)로 소비가 가능한 경우 
            e_val -= a[i]; 
        
    }
    cnt++;
    return cnt <= m; 
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
    cin >> n >> m; 
    for(ll i = 0; i < n; i++) {
        cin >> a[i];
        mx = max(a[i], mx);
    }

    ll lo = mx;
    ll hi = 1'000'000'004; 

    while(lo <= hi) {
        ll mid = (lo + hi) / 2; 

        if(check(mid)) {
            hi = mid -1; 
            ret = min(ret, mid);

        }
        else {
            lo = mid + 1; 
        } 
    }

    cout << ret << '\n';
    return 0;
}

실행결과