Maalaus

input/code.cpp: In function 'int main()':
input/code.cpp:104:18: warning: unused variable 'len' [-Wunused-variable]
  104 |     const size_t len = read(0, input, 1024*1024*8);
      |                  ^~~

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <unordered_map>
#include <vector>

#define __STDC_LIMIT_MACROS
#include <stdint.h>

size_t next_space = 0;
size_t idx = 0;

char *input;
char *output;

size_t width, height, n_questions;

size_t getnum() {
    next_space = strchr((input + idx), ' ') - (input + idx);
    (input + idx)[next_space] = '\0';
    size_t n = atoi((input + idx));
    idx += next_space + 1;

    return n;
}

size_t getnum_last() {
    next_space = strchr((input + idx), '\n') - (input + idx);
    (input + idx)[next_space] = '\0';
    size_t n = atoi((input + idx));
    idx += next_space + 1;

    return n;
}

inline size_t get_idx(size_t x, size_t y) {
    return ( x << 32 ) | y;
}

#define VERTICAL 1
#define HORIZONTAL 2
#define START 3

int get_jumps(size_t x1, size_t y1, size_t x2, size_t y2, size_t n_jumps, int last, std::unordered_map<size_t, size_t> &covered) {
    covered.insert({get_idx(x1,y1), n_jumps});

    if (x1 == x2 && y1 == y2) {
        return 0;
    }

    std::vector<int> jumps;
    if (last != HORIZONTAL) {
    for (size_t i = 1; i < width + 1; i++) {
        if (i == x1) {
            continue;
        }

        if (output[i - 1 + (y1 - 1)*width] == '.' && covered.find(get_idx(i, y1)) == covered.end()) {
            // Safe square
            jumps.push_back(get_jumps(i, y1, x2, y2, n_jumps + 1, HORIZONTAL, covered));
        } else if (output[i - 1 + (y1 - 1)*width] == '.' && covered[get_idx(i,y1)] > n_jumps) {
            jumps.push_back(get_jumps(i, y1, x2, y2, n_jumps + 1, HORIZONTAL, covered));
        }
    }
    }

    if (last != VERTICAL) {
    for (size_t i = 1; i < height + 1; i++) {
        if (i == y1) {
            continue;
        }

        if (output[x1-1+(i-1)*width] == '.' && covered.find(get_idx(x1, i)) == covered.end()) {
            // Safe square
            jumps.push_back(get_jumps(x1, i, x2, y2, n_jumps + 1, VERTICAL, covered));
        } else if (output[x1-1 + (i-1)*width] == '.' && covered[get_idx(x1,i)] > n_jumps) {
            jumps.push_back(get_jumps(x1, i, x2, y2, n_jumps + 1, VERTICAL, covered));
        }
    }
    }

    int min = INT32_MAX;
    bool way_found = false;
    for (int jump : jumps) {
        if (jump != -1) {
            way_found = true;
        }

        if (jump < min && jump != -1) {
            min = jump;
        }
    }

    if (!way_found)
        return -1;
    else
        return min + 1;
}

int main() {

    input = (char *)malloc(1024*1024*8);
    const size_t len = read(0, input, 1024*1024*8);
    
    height = getnum();
    width = getnum();

    output = (char *)malloc((height) * (width));

    n_questions = getnum_last();

    for (size_t i = 0; i < height; i++) {
        next_space = strchr((input + idx), '\n') - (input + idx);
        memcpy(output + i * width, (input + idx), next_space);
        idx += next_space + 1;
    }

    std::unordered_map<size_t, size_t> covered{};
    for (size_t i = 0; i < n_questions; i++) {
        size_t y1 = getnum();
        size_t x1 = getnum();
        size_t y2 = getnum();
        size_t x2 = getnum_last();

        printf("%d\n", get_jumps(x1, y1, x2, y2, 0, START, covered));
    }

    return 0;
}

Test 1 (public)

Group: 1, 3, 4

Verdict: RUNTIME ERROR

Test 2 (public)

Group: 3, 4

Verdict: RUNTIME ERROR

Test 3

Group: 1, 3, 4

Verdict: RUNTIME ERROR

Test 4

Group: 2, 4

Verdict: RUNTIME ERROR

Test 5

Group: 2, 4

Verdict: RUNTIME ERROR

Test 6

Group: 3, 4

Verdict: RUNTIME ERROR

Test 7

Group: 3, 4

Verdict: RUNTIME ERROR

Test 8

Group: 4

Verdict: RUNTIME ERROR

Test 9

Group: 4

Verdict: RUNTIME ERROR

Test 10

Group: 1, 3, 4

Verdict: RUNTIME ERROR

Test 11

Group: 1, 3, 4

Verdict: RUNTIME ERROR

Test 12

Group: 2, 4

Verdict: RUNTIME ERROR

Test 13

Group: 2, 4

Verdict: RUNTIME ERROR

Test 14

Group: 4

Verdict: RUNTIME ERROR

Test 15

Group: 4

Verdict: RUNTIME ERROR

Test 16

Group: 4

Verdict: RUNTIME ERROR

Test 17

Group: 4

Verdict: RUNTIME ERROR