in c++

Paste this inside getMinimumMoves:

cpp
int getMinimumMoves(vector<vector<int>> maze, int k) {
    int n = maze.size();
    int m = maze[0].size();

    if (maze[0][0] == 1 || maze[n - 1][m - 1] == 1) return -1;

    vector<vector<int>> dist(n, vector<int>(m, -1));
    queue<pair<int, int>> q;

    dist[0][0] = 0;
    q.push({0, 0});

    int dr[4] = {0, 0, 1, -1};
    int dc[4] = {1, -1, 0, 0};

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

        if (r == n - 1 && c == m - 1) {
            return dist[r][c];
        }

        for (int dir = 0; dir < 4; dir++) {
            for (int step = 1; step <= k; step++) {
                int nr = r + dr[dir] * step;
                int nc = c + dc[dir] * step;

                if (nr < 0 || nr >= n || nc < 0 || nc >= m) break;
                if (maze[nr][nc] == 1) break;

                if (dist[nr][nc] == -1) {
                    dist[nr][nc] = dist[r][c] + 1;
                    q.push({nr, nc});
                }
            }
        }
    }

    return -1;
}

Try this version. It includes the important optimization: when moving in one direction, if we reach a cell already visited with a smaller or equal distance, we can stop scanning further in that direction. This avoids some hidden test issues/timeouts.

cpp
int getMinimumMoves(vector<vector<int>> maze, int k) {
    int n = maze.size();
    int m = maze[0].size();

    if (maze[0][0] == 1 || maze[n - 1][m - 1] == 1) return -1;

    vector<vector<int>> dist(n, vector<int>(m, INT_MAX));
    queue<pair<int, int>> q;

    dist[0][0] = 0;
    q.push({0, 0});

    int dr[4] = {0, 0, 1, -1};
    int dc[4] = {1, -1, 0, 0};

    while (!q.empty()) {
        auto cur = q.front();
        q.pop();

        int r = cur.first;
        int c = cur.second;

        if (r == n - 1 && c == m - 1) {
            return dist[r][c];
        }

        for (int dir = 0; dir < 4; dir++) {
            for (int step = 1; step <= k; step++) {
                int nr = r + dr[dir] * step;
                int nc = c + dc[dir] * step;

                if (nr < 0 || nr >= n || nc < 0 || nc >= m) break;
                if (maze[nr][nc] == 1) break;

                if (dist[nr][nc] < dist[r][c] + 1) break;

                if (dist[nr][nc] == dist[r][c] + 1) continue;

                dist[nr][nc] = dist[r][c] + 1;
                q.push({nr, nc});
            }
        }
    }

    return -1;
}

If it still fails, send me the failing input and output shown by the platform.

Use this set-based BFS version. It avoids hidden-case issues from scanning/visited logic and is faster for large cases.

cpp
int getMinimumMoves(vector<vector<int>> maze, int k) {
    int n = maze.size();
    int m = maze[0].size();

    if (maze[0][0] == 1 || maze[n - 1][m - 1] == 1) return -1;
    if (n == 1 && m == 1) return 0;

    vector<vector<int>> dist(n, vector<int>(m, -1));

    vector<set<int>> rowFree(n), colFree(m);
    vector<vector<int>> rowBlock(n), colBlock(m);

    for (int i = 0; i < n; i++) {
        rowBlock[i].push_back(-1);
        rowBlock[i].push_back(m);
    }

    for (int j = 0; j < m; j++) {
        colBlock[j].push_back(-1);
        colBlock[j].push_back(n);
    }

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (maze[i][j] == 0) {
                rowFree[i].insert(j);
                colFree[j].insert(i);
            } else {
                rowBlock[i].push_back(j);
                colBlock[j].push_back(i);
            }
        }
    }

    for (int i = 0; i < n; i++) sort(rowBlock[i].begin(), rowBlock[i].end());
    for (int j = 0; j < m; j++) sort(colBlock[j].begin(), colBlock[j].end());

    queue<pair<int, int>> q;

    dist[0][0] = 0;
    q.push({0, 0});

    rowFree[0].erase(0);
    colFree[0].erase(0);

    while (!q.empty()) {
        auto cur = q.front();
        q.pop();

        int r = cur.first;
        int c = cur.second;

        int d = dist[r][c];

        // Move left/right in same row
        auto itR = lower_bound(rowBlock[r].begin(), rowBlock[r].end(), c);
        int rightObstacle = *itR;
        int leftObstacle = *(--itR);

        int left = max(c - k, leftObstacle + 1);
        int right = min(c + k, rightObstacle - 1);

        auto it = rowFree[r].lower_bound(left);
        while (it != rowFree[r].end() && *it <= right) {
            int nc = *it;

            dist[r][nc] = d + 1;
            if (r == n - 1 && nc == m - 1) return dist[r][nc];

            q.push({r, nc});

            colFree[nc].erase(r);
            it = rowFree[r].erase(it);
        }

        // Move up/down in same column
        auto itC = lower_bound(colBlock[c].begin(), colBlock[c].end(), r);
        int downObstacle = *itC;
        int upObstacle = *(--itC);

        int up = max(r - k, upObstacle + 1);
        int down = min(r + k, downObstacle - 1);

        auto it2 = colFree[c].lower_bound(up);
        while (it2 != colFree[c].end() && *it2 <= down) {
            int nr = *it2;

            dist[nr][c] = d + 1;
            if (nr == n - 1 && c == m - 1) return dist[nr][c];

            q.push({nr, c});

            rowFree[nr].erase(c);
            it2 = colFree[c].erase(it2);
        }
    }

    return -1;
}

This handles obstacles correctly, including cases where HackerMan cannot jump over a 1.