자료구조 예상문제2 - 미로찾기문제

IT 프로그래밍/자료구조

자료구조 예상문제2 - 미로찾기문제

기술1 2024. 12. 15. 10:25

문제 1: 연결된 컴포넌트 크기 계산

설명:
주어진 이미지를 입력받아 연결된 컴포넌트의 크기를 계산하고, 크기를 오름차순으로 출력하라. 각 테스트 케이스마다 연결된 컴포넌트들의 크기를 출력하되, 크기는 오름차순으로 출력한다.

입력 형식

첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
각 테스트 케이스마다 첫 번째 줄에 이미지 크기 N이 주어진다. (1 ≤ N ≤ 50)
그 다음에는 N개의 줄에 0과 1로 이루어진 이미지가 주어진다.

출력 형식

각 테스트 케이스마다 연결된 컴포넌트의 크기를 오름차순으로 출력한다.

C++ 코드

#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>

using namespace std;

int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1}; // 8방향
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};

bool inBounds(int x, int y, int N) {
    return x >= 0 && x < N && y >= 0 && y < N;
}

int dfs(int startX, int startY, vector<vector<int>>& image, vector<vector<bool>>& visited, int N) {
    stack<pair<int, int>> s;
    s.push({startX, startY});
    visited[startX][startY] = true;
    int size = 0;

    while (!s.empty()) {
        auto [x, y] = s.top();
        s.pop();
        size++;

        for (int i = 0; i < 8; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (inBounds(nx, ny, N) && !visited[nx][ny] && image[nx][ny] == 1) {
                visited[nx][ny] = true;
                s.push({nx, ny});
            }
        }
    }

    return size;
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N;
        cin >> N;

        vector<vector<int>> image(N, vector<int>(N));
        vector<vector<bool>> visited(N, vector<bool>(N, false));
        vector<int> componentSizes;

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> image[i][j];
            }
        }

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (image[i][j] == 1 && !visited[i][j]) {
                    int size = dfs(i, j, image, visited, N);
                    componentSizes.push_back(size);
                }
            }
        }

        sort(componentSizes.begin(), componentSizes.end());
        for (int size : componentSizes) {
            cout << size << " ";
        }
        cout << endl;
    }

    return 0;
}

문제 1: 미로에서 출구 찾기입력 형식
- 첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
- 각 테스트 케이스마다 첫 번째 줄에 미로의 크기 N이 주어진다. (1 ≤ N ≤ 50)
- 그 다음에는 N개의 줄에 0과 1로 이루어진 미로가 주어진다.
  - 0은 길을 나타내고, 1은 벽을 나타낸다.
  - 출발점과 출구는 항상 0으로 주어진다.
출력 형식
- 각 테스트 케이스마다 출구까지의 최단 경로의 길이를 출력하라.
설명:
주어진 미로에서 출구(1)까지의 최단 경로를 구하라. 출발점은 미로의 왼쪽 상단 (0, 0)이고, 출구는 미로의 오른쪽 하단 (N-1, N-1)이다. 경로가 존재하면 경로의 길이를 출력하고, 경로가 없으면 -1을 출력한다.

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

using namespace std;

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

bool inBounds(int x, int y, int N) {
    return x >= 0 && x < N && y >= 0 && y < N;
}

int bfs(int N, vector<vector<int>>& maze) {
    queue<pair<int, int>> q;
    vector<vector<bool>> visited(N, vector<bool>(N, false));
    q.push({0, 0});
    visited[0][0] = true;
    int steps = 0;

    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; i++) {
            auto [x, y] = q.front();
            q.pop();

            if (x == N-1 && y == N-1) {
                return steps;
            }

            for (int i = 0; i < 4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];
                if (inBounds(nx, ny, N) && !visited[nx][ny] && maze[nx][ny] == 0) {
                    visited[nx][ny] = true;
                    q.push({nx, ny});
                }
            }
        }
        steps++;
    }

    return -1; // 출구에 도달할 수 없는 경우
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N;
        cin >> N;

        vector<vector<int>> maze(N, vector<int>(N));
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> maze[i][j];
            }
        }

        int result = bfs(N, maze);
        cout << result << endl;
    }

    return 0;
}

문제 2: 미로에서 출구까지의 경로 출력

설명:
주어진 미로에서 출구(1)까지의 경로를 출력하라. 경로는 상, 하, 좌, 우로만 이동할 수 있다. 출발점은 미로의 왼쪽 상단 (0, 0)이고, 출구는 미로의 오른쪽 하단 (N-1, N-1)이다. 경로가 존재하지 않으면 -1을 출력하라.

C++ 코드

#include <iostream>
#include <vector>
#include <queue>
#include <tuple>
#include <stack>

using namespace std;

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

bool inBounds(int x, int y, int N) {
    return x >= 0 && x < N && y >= 0 && y < N;
}

vector<pair<int, int>> bfs(int N, vector<vector<int>>& maze) {
    queue<pair<int, int>> q;
    vector<vector<bool>> visited(N, vector<bool>(N, false));
    vector<vector<pair<int, int>>> parent(N, vector<pair<int, int>>(N, {-1, -1}));
    q.push({0, 0});
    visited[0][0] = true;

    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();

        if (x == N-1 && y == N-1) {
            vector<pair<int, int>> path;
            while (parent[x][y] != make_pair(-1, -1)) {
                path.push_back({x, y});
                tie(x, y) = parent[x][y];
            }
            path.push_back({0, 0});
            reverse(path.begin(), path.end());
            return path;
        }

        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (inBounds(nx, ny, N) && !visited[nx][ny] && maze[nx][ny] == 0) {
                visited[nx][ny] = true;
                parent[nx][ny] = {x, y};
                q.push({nx, ny});
            }
        }
    }

    return {}; // 출구에 도달할 수 없는 경우
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N;
        cin >> N;

        vector<vector<int>> maze(N, vector<int>(N));
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> maze[i][j];
            }
        }

        vector<pair<int, int>> path = bfs(N, maze);
        if (path.empty()) {
            cout << -1 << endl;
        } else {
            for (auto [x, y] : path) {
                cout << "(" << x << ", " << y << ") ";
            }
            cout << endl;
        }
    }

    return 0;
}

문제 3: 미로에서 벽을 피하는 경로 탐색

설명:
주어진 미로에서 벽을 피하는 경로를 탐색하라. 출발점은 미로의 왼쪽 상단 (0, 0)이고, 출구는 미로의 오른쪽 하단 (N-1, N-1)이다. 경로가 존재하지 않으면 -1을 출력한다. 경로를 찾을 수 있으면 경로를 출력하라.

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

using namespace std;

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

bool inBounds(int x, int y, int N) {
    return x >= 0 && x < N && y >= 0 && y < N;
}

int bfs(int N, vector<vector<int>>& maze) {
    queue<pair<int, int>> q;
    vector<vector<bool>> visited(N, vector<bool>(N, false));
    q.push({0, 0});
    visited[0][0] = true;

    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();

        if (x == N-1 && y == N-1) {
            return 1;
        }

        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (inBounds(nx, ny, N) && !visited[nx][ny] && maze[nx][ny] == 0) {
                visited[nx][ny] = true;
                q.push({nx, ny});
            }
        }
    }

    return 0; // 경로가 없을 경우
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N;
        cin >> N;

        vector<vector<int>> maze(N, vector<int>(N));
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> maze[i][j];
            }
        }

        int result = bfs(N, maze);
        cout << result << endl;
    }

    return 0;
}

문제 4: 미로에서 벽을 최소화하는 경로 탐색

설명:
주어진 미로에서 벽을 최소화하여 출구(1)까지 가는 경로를 찾아라. 벽을 피하는 경로의 개수와 해당 경로에서 지나갈 벽의 개수를 구하라. 경로가 없으면 -1을 출력하라.

C++ 코드

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

using namespace std;

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

bool inBounds(int x, int y, int N) {
    return x >= 0 && x < N && y >= 0 && y < N;
}

int bfs(int N, vector<vector<int>>& maze) {
    queue<pair<pair<int, int>, int>> q; // (x, y), 벽의 수
    vector<vector<int>> dist(N, vector<int>(N, -1));
    dist[0][0] = 0;
    q.push({{0, 0}, 0});

    while (!q.empty()) {
        auto [coords, walls] = q.front();
        auto [x, y] = coords;
        q.pop();

        if (x == N-1 && y == N-1) {
            return walls;
        }

        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (inBounds(nx, ny, N) && dist[nx][ny] == -1) {
                dist[nx][ny] = walls + (maze[nx][ny] == 1);
                q.push({{nx, ny}, dist[nx][ny]});
            }
        }
    }

    return -1; // 경로가 없으면 -1
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N;
        cin >> N;

        vector<vector<int>> maze(N, vector<int>(N));
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> maze[i][j];
            }
        }

        int result = bfs(N, maze);
        cout << result << endl;
    }

    return 0;
}

문제 1: 최소 벽 제거로 출구로 가는 경로 찾기

설명:
주어진 미로에서 출구(1)까지 가는 경로 중 최소한의 벽을 제거하여 갈 수 있는 경로를 찾으세요. 벽을 제거하는 데 드는 비용은 1입니다. 출발점은 미로의 왼쪽 상단 (0, 0)이고, 출구는 미로의 오른쪽 하단 (N-1, N-1)입니다. 벽을 제거하는 데 드는 최소 비용을 구하되, 경로가 없으면 -1을 출력하세요.

입력 형식

첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
각 테스트 케이스마다 첫 번째 줄에 미로의 크기 N이 주어진다. (1 ≤ N ≤ 100)
그 다음에는 N개의 줄에 0과 1로 이루어진 미로가 주어진다.
- 0은 길을 나타내고, 1은 벽을 나타낸다.
- 출발점과 출구는 항상 0으로 주어진다.

출력 형식

각 테스트 케이스마다 출구까지 가는 경로에서 제거해야 하는 최소 벽의 개수를 출력한다. 경로가 없으면 -1을 출력한다.

해결 힌트

BFS + 벽 제거: BFS를 사용하여, 벽을 제거한 횟수를 기록하면서 탐색한다.
우선순위 큐(Priority Queue)나 다익스트라 알고리즘을 활용하여 최소 벽 제거 횟수를 찾는다.

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

using namespace std;

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

bool inBounds(int x, int y, int N) {
    return x >= 0 && x < N && y >= 0 && y < N;
}

int minWallRemoval(int N, vector<vector<int>>& maze) {
    vector<vector<int>> dist(N, vector<int>(N, -1)); // -1로 초기화 (방문 안함)
    queue<pair<int, int>> q;
    dist[0][0] = 0;
    q.push({0, 0});
    
    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();

        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (inBounds(nx, ny, N)) {
                int newDist = dist[x][y] + (maze[nx][ny] == 1); // 벽을 만날 경우 1 증가
                if (dist[nx][ny] == -1 || dist[nx][ny] > newDist) {
                    dist[nx][ny] = newDist;
                    q.push({nx, ny});
                }
            }
        }
    }

    return dist[N-1][N-1]; // 출구까지의 최소 벽 제거 횟수
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N;
        cin >> N;

        vector<vector<int>> maze(N, vector<int>(N));
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> maze[i][j];
            }
        }

        int result = minWallRemoval(N, maze);
        cout << result << endl;
    }

    return 0;
}

문제 3: 미로에서 여러 출구를 동시에 찾기 (멀티 출구 탐색)

설명:
주어진 미로에서 여러 개의 출구를 동시에 찾는 경로를 탐색하라. 출발점은 미로의 왼쪽 상단 (0, 0)이고, 여러 출구 중 하나로 가장 빠르게 갈 수 있는 경로를 찾아라. 출구는 1로 표시된 지점들이며, 출구는 여러 개 존재한다.

입력 형식

첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
각 테스트 케이스마다 첫 번째 줄에 미로의 크기 N과 출구의 개수 K가 주어진다. (1 ≤ N ≤ 100, 1 ≤ K ≤ 10)
그 다음에는 N개의 줄에 0과 1로 이루어진 미로가 주어진다.
- 0은 길을 나타내고, 1은 출구를 나타낸다.
- 출발점은 항상 (0, 0), 출구는 미로 안에 여러 곳에 있다.

출력 형식

각 테스트 케이스마다 가장 빠르게 갈 수 있는 출구까지의 경로 길이를 출력하라. 경로가 없다면 -1을 출력한다.

해결 힌트

BFS + 멀티 출구: BFS를 확장하여 여러 개의 출구를 동시에 탐색한다.

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

using namespace std;

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

bool inBounds(int x, int y, int N) {
    return x >= 0 && x < N && y >= 0 && y < N;
}

int findShortestExit(int N, vector<vector<int>>& maze, vector<pair<int, int>>& exits) {
    queue<pair<int, int>> q;
    vector<vector<int>> dist(N, vector<int>(N, -1));
    dist[0][0] = 0;
    q.push({0, 0});

    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();

        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (inBounds(nx, ny, N) && maze[nx][ny] != 1 && dist[nx][ny] == -1) {
                dist[nx][ny] = dist[x][y] + 1;
                q.push({nx, ny});
            }
        }
    }

    int minDist = -1;
    for (auto [ex, ey] : exits) {
        if (dist[ex][ey] != -1) {
            if (minDist == -1 || dist[ex][ey] < minDist) {
                minDist = dist[ex][ey];
            }
        }
    }

    return minDist;
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N, K;
        cin >> N >> K;

        vector<vector<int>> maze(N, vector<int>(N));
        vector<pair<int, int>> exits;

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> maze[i][j];
                if (maze[i][j] == 1) {
                    exits.push_back({i, j});
                }
            }
        }

        int result = findShortestExit(N, maze, exits);
        cout << result << endl;
    }

    return 0;
}

문제 1: 미로에서 여러 장애물 회피하며 제한된 이동 횟수로 출구로 가기

설명:
주어진 미로에서 출발점(0, 0)에서 출구(N-1, N-1)까지 이동할 때, 최대 이동 횟수가 제한되어 있으며, 장애물을 피하면서 경로를 찾아야 합니다. 이때 장애물은 벽(1)으로 표시되며, 벽을 피하면서 출구로 가는 최단 경로를 구해야 합니다. 단, 제한된 이동 횟수 내에 출구에 도달할 수 없으면 -1을 출력합니다.

입력 형식

첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
각 테스트 케이스마다 첫 번째 줄에 미로의 크기 N과 최대 이동 횟수 K가 주어진다. (1 ≤ N ≤ 100, 1 ≤ K ≤ 500)
그 다음에는 N개의 줄에 0과 1로 이루어진 미로가 주어진다.
- 0은 길을 나타내고, 1은 벽을 나타낸다.
- 출발점은 항상 (0, 0), 출구는 항상 (N-1, N-1)이다.

출력 형식

각 테스트 케이스마다, 최대 이동 횟수 K 내에 출구까지 도달할 수 있으면 그 최단 경로를 출력한다. 경로가 없다면 -1을 출력한다.

해결 힌트

BFS + 이동 횟수 제한: BFS를 사용하여 경로를 탐색하되, 이동 횟수를 체크하면서 진행한다.
큐를 활용한 상태 추적: 큐에 x, y, 남은 이동 횟수를 넣어 탐색한다.

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

using namespace std;

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

bool inBounds(int x, int y, int N) {
    return x >= 0 && x < N && y >= 0 && y < N;
}

int findPath(int N, int K, vector<vector<int>>& maze) {
    queue<tuple<int, int, int>> q; // (x, y, 남은 이동 횟수)
    vector<vector<vector<int>>> dist(N, vector<vector<int>>(N, vector<int>(K + 1, -1))); // dist[x][y][남은 이동 횟수]
    
    dist[0][0][K] = 0;
    q.push({0, 0, K});
    
    while (!q.empty()) {
        auto [x, y, remainingMoves] = q.front();
        q.pop();

        if (x == N - 1 && y == N - 1) {
            return dist[x][y][remainingMoves]; // 출구에 도달하면 최단 경로 반환
        }

        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (inBounds(nx, ny, N) && maze[nx][ny] == 0) {
                if (remainingMoves > 0 && dist[nx][ny][remainingMoves - 1] == -1) {
                    dist[nx][ny][remainingMoves - 1] = dist[x][y][remainingMoves] + 1;
                    q.push({nx, ny, remainingMoves - 1});
                }
            }
        }
    }

    return -1; // 출구에 도달할 수 없다면 -1
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N, K;
        cin >> N >> K;

        vector<vector<int>> maze(N, vector<int>(N));
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> maze[i][j];
            }
        }

        int result = findPath(N, K, maze);
        cout << result << endl;
    }

    return 0;
}

문제 2: 미로에서 포탈을 통해 출구로 가기

설명:
주어진 미로에서 출발점(0, 0)에서 출구(N-1, N-1)까지 가는 경로를 찾으세요. 다만, 미로에는 포탈이 존재합니다. 포탈을 사용하면 현재 위치에서 다른 지정된 위치로 순간이동할 수 있습니다. 포탈은 벽(1) 위에 존재하며, 포탈을 사용할 때는 이동 횟수가 추가되지 않습니다. 이 문제에서는 포탈을 이용한 최단 경로를 구하세요.

입력 형식

첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
각 테스트 케이스마다 첫 번째 줄에 미로의 크기 N과 포탈의 개수 P가 주어진다. (1 ≤ N ≤ 100, 1 ≤ P ≤ 10)
그 다음에는 N개의 줄에 0과 1로 이루어진 미로가 주어진다. 포탈 위치는 1로 표시되며, 0은 일반 경로를 나타낸다.
마지막으로 P개의 줄에 포탈의 위치 (x1, y1)과 연결된 다른 포탈 위치 (x2, y2)가 주어진다.

출력 형식

각 테스트 케이스마다 출발점(0, 0)에서 출구(N-1, N-1)까지 가는 경로 중 최단 경로를 출력한다. 포탈을 사용할 수 있다면 그를 고려한 경로를 찾는다.

해결 힌트

BFS + 포탈 활용: BFS를 사용하여 출발점에서 출구까지 가는 경로를 찾고, 포탈이 있는 위치에 도달하면 그 포탈로 순간이동한다.
포탈의 이동 횟수는 카운트하지 않음: 포탈을 사용해도 이동 횟수는 증가하지 않는다.

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

using namespace std;

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

bool inBounds(int x, int y, int N) {
    return x >= 0 && x < N && y >= 0 && y < N;
}

int findPathWithPortals(int N, vector<vector<int>>& maze, unordered_map<pair<int, int>, pair<int, int>>& portals) {
    queue<pair<int, int>> q; // (x, y)
    vector<vector<int>> dist(N, vector<int>(N, -1)); // dist[x][y]
    
    dist[0][0] = 0;
    q.push({0, 0});
    
    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();

        if (x == N - 1 && y == N - 1) {
            return dist[x][y]; // 출구에 도달하면 최단 경로 반환
        }

        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (inBounds(nx, ny, N) && maze[nx][ny] == 0 && dist[nx][ny] == -1) {
                dist[nx][ny] = dist[x][y] + 1;
                q.push({nx, ny});
            }
        }

        // 포탈 사용
        if (maze[x][y] == 1 && portals.count({x, y})) {
            auto [px, py] = portals[{x, y}];
            if (dist[px][py] == -1) {
                dist[px][py] = dist[x][y];
                q.push({px, py});
            }
        }
    }

    return -1; // 출구에 도달할 수 없다면 -1
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N, P;
        cin >> N >> P;

        vector<vector<int>> maze(N, vector<int>(N));
        unordered_map<pair<int, int>, pair<int, int>> portals;

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> maze[i][j];
            }
        }

        // 포탈 정보 입력
        for (int i = 0; i < P; i++) {
            int x1, y1, x2, y2;
            cin >> x1 >> y1 >> x2 >> y2;
            portals[{x1, y1}] = {x2, y2};
            portals[{x2, y2}] = {x1, y1}; // 양방향 포탈
        }

        int result = findPathWithPortals(N, maze, portals);
        cout << result << endl;
    }

    return 0;
}

'IT 프로그래밍 > 자료구조' 카테고리의 다른 글

자료구조 예상문제 3 - 시간복잡도 (0)	2024.12.15
자료구조 - 예상문제 3 스택, 큐, 직접 구현하기 (0)	2024.12.15
자료구조 예상 문제 1 (0)	2024.12.15
자료구조 그룹액티비티7 (0)	2024.12.15
자료구조 그룹액티비티 6 (2)	2024.12.15

현재글자료구조 예상문제2 - 미로찾기문제

기술 블로그

string 설명, 백준 10813, 티스토리챌린지, 백준2284번, 빈곤의 사회학적 정의, 말레이시아 경제, 따배시 강의, 따배시 강의 요약, 빈곤 정의, 녹색혁명, strtok기능, 빈곤의 원인, 거듭제곱 구하는 법, x5x6, 오블완, 빈곤이란, 빈곤이란 무엇인가?, 프로그래밍 예제, C++, 따배시,

일	월	화	수	목	금	토
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

기술 블로그