Hypyt

#include <chrono>
#include <cstring>
#include <iostream>
#include <thread>
#include <utility>
#include <vector>

using namespace std;
using pi = pair<int, int>;

vector<int> *rows;
vector<int> *columns;

int *reverseRows;
int *reverseColumns;

int *checkedRows;
int *checkedColumns;

int checks = 0;

#define Rows                                                            \
for (int i : rows[pos.second]) {                                        \
    int found = depths[pos.second][i];                                  \
    if (found <= depth + 1) continue;                                   \
                                                                        \
    int ret = find<false>(depths, depth + 1, { i, pos.second }, min);   \
    if (ret) return ret - 1;                                            \
}

#define Columns                                                         \
for (int i : columns[pos.first]) {                                      \
    int found = depths[i][pos.first];                                   \
    if (found <= depth + 1) continue;                                   \
                                                                        \
    int ret = find<true>(depths, depth + 1, { pos.first, i }, min);     \
    if (ret) return ret - 1;                                            \
}

#define Check                                                           \
if (depth + 1 >= *min) return depth + 2 - *min;

template<bool Row>
int find(int **depths, int depth, pi pos, int *min) {
    checks++;
    depths[pos.second][pos.first] = depth;

    Check
    if (depth > checkedRows[pos.second]) return depth - checkedRows[pos.second];
    if (depth > checkedColumns[pos.first]) return depth - checkedColumns[pos.first];

    checkedRows[pos.second] = depth + 1;
    checkedColumns[pos.first] = depth + 1;

    int revRow = reverseRows[pos.second];
    int revCol = reverseColumns[pos.first];

    if (revRow) {
        if (revCol && revCol < revRow) {
            *min = depth + revCol - 1;
            return revCol;
        } else {
            *min = depth + revRow - 1;
            return revRow;
        }
    } else if (revCol) {
        *min = depth + revCol - 1;
        return revCol;
    }

    Check

    if constexpr (Row) {
        Rows
        Check
        Columns
    } else {
        Columns
        Check
        Rows
    }

    Check

    return false;
}

void createReverse(pi pos, int depth, int max) {
    if (reverseRows[pos.second] == 0 || depth < reverseRows[pos.second]) reverseRows[pos.second] = depth;
    if (reverseColumns[pos.first] == 0 || depth < reverseColumns[pos.first]) reverseColumns[pos.first] = depth;

    if (depth >= max) return;

    for (int i : rows[pos.second]) {
        createReverse({ i, pos.second }, depth + 1, max);
    }

    for (int i : columns[pos.first]) {
        createReverse({ pos.first, i }, depth + 1, max);
    }
}

int getDepth(pi start, pi end, int height, int width, int **depths) {
    if (start.first == end.first && start.second == end.second) return 0;

    for (int i = 0; i < height; i++)
        memset((void*)(depths[i]), 127, width * sizeof(int));

    memset((void*)reverseRows, 0, height * sizeof(int));
    memset((void*)reverseColumns, 0, width * sizeof(int));
    memset((void*)checkedRows, 127, height * sizeof(int));
    memset((void*)checkedColumns, 127, width * sizeof(int));

    createReverse(end, 1, 2);

    int min = 42069;
    find<true>(depths, 1, start, &min);

    if (min == 42069) return -1;
    return min;
}

int main(int argc, char *argv[]) {
    int height, width, count; cin >> height >> width >> count;

    rows = new vector<int>[height];
    columns = new vector<int>[width];

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            char c; cin >> c;
            if (c == '.') {
                rows[y].push_back(x);
                columns[x].push_back(y);
            }
        }
    }

    reverseRows = new int[height];
    reverseColumns = new int[width];
    checkedRows = new int[height];
    checkedColumns = new int[width];

    int **depths = new int*[height];

    for (int i = 0; i < height; i++) depths[i] = new int[width];

    for (int i = 0; i < count; i++) {
        int y1, x1, y2, x2; cin >> y1 >> x1 >> y2 >> x2;

        pi start{ x1 - 1, y1 - 1 };
        pi end{ x2 - 1, y2 - 1 };

        int min = getDepth(start, end, height, width, depths);
        cout << min << endl;
    }

}

Test 1 (public)

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 2

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 3

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 4

Group: 1, 2, 3, 4, 5

Verdict: WRONG ANSWER

Test 5

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 6

Group: 2, 5

Verdict: WRONG ANSWER

Test 7

Group: 2, 5

Verdict: WRONG ANSWER

Test 8

Group: 2, 5

Verdict: WRONG ANSWER

Test 9

Group: 3, 4, 5

Verdict: WRONG ANSWER

Test 10

Group: 3, 4, 5

Verdict: WRONG ANSWER

Test 11

Group: 3, 4, 5

Verdict: WRONG ANSWER

Test 12

Group: 4, 5

Verdict: WRONG ANSWER

Test 13

Group: 4, 5

Verdict: WRONG ANSWER

Test 14

Group: 4, 5

Verdict: WRONG ANSWER

Test 15

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 18

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 19

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 21

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 22

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 23

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 24

Group: 5

Verdict: ACCEPTED

Test 25

Group: 5

Verdict: ACCEPTED

Test 26

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 27

Group: 5

Verdict: ACCEPTED