15-kokeunho

[kokeunho]

🔗 문제 링크

[BOJ] 격자상의 경로 https://www.acmicpc.net/problem/10164

✔️ 소요된 시간

1h

✨ 수도 코드

K가 0 (거쳐야 할 지점이 없는)인 경우와 K가 있는 경우를 나누어야 합니다.

K가 있는 경우 해당 지점의 좌표를 찾고 해당 좌표를 거쳐서
최종 목적지에 도달하는 경로의 수를 구합니다.
움직일 수 있는 방법은 오른쪽이나 아래 밖에 없으므로
findPath(0, 0, midX, midY) * findPath(midX, midY, N-1, M-1)이
곧 최종 목적지에 도착할 수 있는 경로의 수 입니다.

K가 없는 경우는 그냥 findPath(0,0,N-1,M-1) 입니다.

findPath 함수에서는
우선 배열의 값들을 0으로 초기화 시켜주고
시작 지점부터 목표 지점까지 우, 하로 이동하며 해당 지점까지의 경로 수를 갱신합니다.

         for (int i = sx; i <= ex; i++) {
            for (int j = sy; j <= ey; j++) {
                if (i > sx) path[i][j] += path[i-1][j];
                if (j > sy) path[i][j] += path[i][j-1];
            }
        }

📚 새롭게 알게된 내용

2차원 배열에서 K 번째 요소의 좌표를 찾을 때, 처음에는 배열에 값을
1씩 늘려가며 넣어주고 K와 같은 값을 넣게 될 때 좌표의 위치를 저장하는 식으로 했습니다.

그러나 2차원 배열이 하나 더 필요하기도 하고 좋은 방법은 아니라고 생각했습니다.
아래와 같은 코드로 좌표를 찾을 수 있다는 것을 알게 되었습니다.

        int mx = 0, my = 0;
        if (K != 0) {
            mx = (K-1) / M;
            my = (K-1) % M;
        }

[kangrae-jo]

이 부분을 보고 궁금한 점이 생겼습니다!

path 배열은 findPath에서만 사용되는듯 합니다.
그래서 이 함수가 호출될 때 매번 부분적인 초기화를 하는 것보다는
그냥 함수 스택에서 0으로 초기화 된 배열을 생성해버리는 것은 어떨까요?

int[][] path = new int[N][M];  // 모든 값이 0으로 자동 초기화됨

또는 범위를 아래와 같이 지정하면 어떨까요?

for (int i = sx; i <= ex; i++) {
    for (int j = sy; j <= ey; j++) {
        path[i][j] = 0;
    }
}

[kangrae-jo]

중학생? 고등학생? 때 수학문제로 자주 나왔던 문제 같네요
덕분에 문제 이해는 쉬웠습니다

저는 1 to K, K to N*M 을 곱하는 방법과 조금 다른 방법을 사용했습니다.
1 to K를 먼저 진행하고, K좌표가 시작이라 생각하고 다시 K to N*M을 하는 방식입니다.
( 반복되는 로직이 있어서 함수화 할 수 있을 것 같은데 pass했습니다.. ㅎㅎ)

조금 어려웠던 점은 K 의 위치를 구하는 부분이었습니다.

int K_x = K % M - 1;
int K_y = K / M;
if (K == 0) {
    K_x = 0;
    K_y = 0;
}
else if (K_x < 0){
    K_x = M - 1;
    K_y--;
}

조건 검사도 많고 조금 지저분하게 됐네요..
근호님은 깔끔한 로직으로 한번에 잘 처리하신 것 같네요 ! 👍

CPP CODE

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int N, M, K;
    cin >> N >> M >> K;

    // find K's position
    int K_x = K % M - 1;
    int K_y = K / M;
    if (K == 0) {
        K_x = 0;
        K_y = 0;
    }
    else if (K_x < 0){
        K_x = M - 1;
        K_y--;
    }

    vector<vector<int>> board(N, vector<int>(M, 0));
    // 1 to K
    for (int y = 0; y <= K_y; y++) {
        for (int x = 0; x <= K_x; x++) {
            if (x == 0 || y == 0) board[y][x] = 1;
            else board[y][x] += board[y][x - 1] + board[y - 1][x];
        }
    }

    // K to N*M
    for (int y = K_y; y < N; y++) {
        for (int x = K_x; x < M; x++) {
            if (x == K_x || y == K_y) board[y][x] = board[K_y][K_x];
            else board[y][x] += board[y][x - 1] + board[y - 1][x];
        }
    }

    cout << board[N - 1][M - 1];

    return 0;
}

좋은 문제 감사합니다 고생하셨습니다~

[g0rnn]

저는 dfs를 사용하여 문제를 해결하였는데 dp로 해결하는 방법은 생각치도 못했네요. 예전에 배웠던 문제를 알고리즘적으로 구현하는 문제라 판단해버려서 다른 생각은 하지도 못했던 것 같네요. 문제를 좀 더 다양한 방면으로 볼 수 있도록 노력해야겠어요

사실 dfs로 구현하는 데에도 어려운 점이 많았습니다. 오랜만에 미로를 dfs로 풀려 하다보니 base case에 해당하는 변수를 잘못 지정하거나 잘못된 base case를 설정하였고 k의 위치를 설정하는 것에서도 오류가 많았어서 시간이 좀 걸렸습니다.

그리고 저번처럼 백준에서 문제를 풀어보았는데요. 좀 막막하더군요.. 중간 결과를 모르니 해당 언어에 대한 문법을 완벽히 숙지해야하기에 문제가 더 어렵게 느껴졌던것 같습니다. 근데 괜찮은 연습 방법이라 생각하여 종종 해보는걸 추천드려요!

제 완성된 코드입니다. 시간초과는 없었고 점수도 100점 받았습니다. 아마 N과 M값이 너무 작아서 그런거 같아요.

code

//
// Created by 김균호 on 2025. 1. 17..
//
#include <iostream>
#include <vector>
using namespace std;

int n, m, k;
int offset[2][2] = {{1, 0}, {0, 1}};
vector<vector<int> > map; //[n][m]
vector<vector<bool> > visited;

int dfs(int xs, int ys, int xd, int yd) {
    if (xs == xd && ys == yd) return 1;
    if (xs < 0 || ys < 0 || xs >= m || ys >= n) return 0;
    if (visited[ys][xs]) return 0;

    int cnt = 0;
    visited[ys][xs] = true;
    for (auto &dir: offset) {
        int nx = xs + dir[0];
        int ny = ys + dir[1];
        cnt += dfs(nx, ny, xd, yd);
    }
    visited[ys][xs] = false;
    return cnt;
}

int main() {
    cin >> n >> m >> k;
    map = vector<vector<int> >(n, vector<int>(m));
    visited = vector<vector<bool> >(n, vector<bool>(m, false));

    int xt = 0, yt = 0;
    if (k != 0) {
        xt = (k - 1) % m;
        yt = (k - 1) / m;
    }

    int fir = dfs(0, 0, xt, yt);
    int sec = dfs(xt, yt, m - 1, n - 1);
    cout << fir * sec;
    return 0;
}