Hypyt

#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <unistd.h>
#include <vector>
 
using namespace std;
using pi = pair<int, int>;
 
vector<int> *baseRows;
vector<int> *baseColumns;
 
int *reverseRows;
int *reverseColumns;
 
constexpr int NOT_FOUND = 10000;

int **path;
 
template <bool Row>
char findPath(int depth, pi pos, pi target, int *min) {
    path[pos.first][pos.second] = depth;
 
    if (depth + 1 >= *min) return depth + 1 - *min;
 
    int rev1 = reverseRows[pos.second];
    int rev2 = reverseColumns[pos.first];
 
    if (rev1) {
        if (rev2) {
            if (rev2 < rev1) {
                *min = depth + rev2 - 1;
                return 1;
            } else {
                *min = depth + rev1 - 1;
                return 1;
            }
        }
        else {
            *min = depth + rev1 - 1;
            return 1;
        }
    } else if (rev2) {
        *min = depth + rev2 - 1;
        return 1;
    }
 
    if constexpr (Row) {
        for (int i : baseRows[pos.second]) {
            int found = path[i][pos.second];
            if (found <= depth + 1) continue;
 
            char result = findPath<false>(depth + 1, { i, pos.second }, target, min);
            if (result >= 1) return result - 1;
        }
    } else {
        for (int i : baseColumns[pos.first]) {
            int found = path[pos.first][i];
            if (found <= depth + 1) continue;
 
            char result = findPath<true>(depth + 1, { pos.first, i }, target, min);
            if (result >= 1) return result - 1;
        }
    }
 
    if constexpr (!Row) {
        for (int i : baseRows[pos.second]) {
            int found = path[i][pos.second];
            if (found <= depth + 1) continue;
 
            char result = findPath<true>(depth + 1, { i, pos.second }, target, min);
            if (result >= 1) return result - 1;
        }
    } else {
        for (int i : baseColumns[pos.first]) {
            int found = path[pos.first][i];
            if (found <= depth + 1) continue;
 
            char result = findPath<false>(depth + 1, { pos.first, i }, target, min);
            if (result >= 1) return result - 1;
        }
    }
 
    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 : baseRows[pos.second]) {
        createReverse({ i, pos.second }, depth + 1, max);
    }
 
    for (int i : baseColumns[pos.first]) {
        createReverse({ pos.first, i }, depth + 1, max);
    }
}
 
int main(int argc, char *argv[]) {
    int height, width, count; cin >> height >> width >> count;
 
    baseRows = new vector<int>[height];
    baseColumns = new vector<int>[width];
 
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            char c; cin >> c;
 
            if (c == '.') {
                baseRows[y].push_back(x);
                baseColumns[x].push_back(y);
            }
        }
    }

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

    path = new int*[width];
 
    for (int i = 0; i < width; i++) {
        path[i] = new int[height];
    }
 
    // auto startTime = chrono::high_resolution_clock::now();
    for (int i = 0; i < count; i++) {
        int y1, x1, y2, x2; cin >> y1 >> x1 >> y2 >> x2; 
        int min = NOT_FOUND;
 
        pi start{ x1 - 1, y1 - 1}, end{ x2 - 1, y2 - 1 };
 
        if (start.first == end.first && start.second == end.second) min = 0;
        else {
            for (int i = 0; i < width; i++)
                memset((void*)(path[i]), 127, height * sizeof(int));
 
            memset((void*)reverseRows, 0, height * sizeof(int));
            memset((void*)reverseColumns, 0, width * sizeof(int));
            
            createReverse(end, 1, 1);
 
            for (int i = 0; i < height; i++)
                sort(baseRows[i].begin(), baseRows[i].end(), [end](int p1, int p2) -> bool { return abs(p1 - end.first) < abs(p2 - end.first); });
 
            for (int i = 0; i < width; i++)
                sort(baseColumns[i].begin(), baseColumns[i].end(), [end](int p1, int p2) -> bool { return abs(p1 - end.second) < abs(p2 - end.second); });
 
            findPath<true>(1, start, end, &min);
            // findPath<false>(path, 1, start, end, &min);
 
            if (min == NOT_FOUND) min = -1;
        }
        cout << min << '\n';
    }
    // auto endTime = chrono::high_resolution_clock::now();
    // cout << endTime - startTime << endl;
}

Test 1 (public)

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 2

Group: 1, 2, 3, 4, 5

Verdict: WRONG ANSWER

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: WRONG ANSWER

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: TIME LIMIT EXCEEDED

Test 10

Group: 3, 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 11

Group: 3, 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 12

Group: 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 4, 5

Verdict: TIME LIMIT EXCEEDED

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: TIME LIMIT EXCEEDED

Test 25

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 26

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 27

Group: 5

Verdict: ACCEPTED