Hypyt

input/code.cpp: In lambda function:
input/code.cpp:124:35: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  124 |                 for (int i = 0; i < rowPoints[v[a].row].size(); i++)
      |                                 ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
input/code.cpp:144:35: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  144 |                 for (int i = 0; i < columnPoints[v[a].column].size(); i++)
      |                                 ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
#include <chrono>
#include <iomanip>
#include <queue>

typedef long long ll;
using namespace std;

int grid[250][250];

struct route
{
    int x1 = -1;
    int y1 = -1;
    int x2 = -1;
    int y2 = -1;
};

struct piste
{
    bool unSafe = false;
    int row;
    int column;
};

piste v[62500];

vector<int> rowPoints[250];
vector<int> columnPoints[250];

int main()
{

    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int height, width, operationAmount;

    cin >> height >> width >> operationAmount;

    // setupataan algoritmiin tarvittava tietorakenne:
    // joka turvakohta merkkaa oman x ja y koordinaattinsa

    int count = 0;

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

                v[count].column = x;
                v[count].row = y;
            }
            if (c == '*')
            {
                v[count].unSafe = true;
            }
            count++;
        }
    }

    /*     cout << "\n \n";
        count = 0;
        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                cout << v[count].row << v[count].column << " ";
                count++;
            }
            cout << "\n";
        } */

    // Tehdään algoritmista funktio:
    int ruutuCount = height * width;

    vector<int> distancesMain[62500];
    bool distancesDone[62500];

    auto algorithm = [&](int startR, int startC, int endR, int endC)
    {
        if (startR == endR && startC == endC)
        {
            return 0;
        }

        vector<int> distances(ruutuCount, -1);

        vector<bool> visitedRows(height, false);
        vector<bool> visitedColumns(width, false);

        queue<int> q;
        int start = startR * width + startC;
        int target = endR * width + endC;

        distances[start] = 0;
        q.push(start);
        //cout << "START: " << start << " " << startR << " " << startC << "\n";

        while (!q.empty())
        {
            int a = q.front();
            //cout << "A: " << a << " " << "\n";
            q.pop();

            if (!visitedRows[v[a].row])
            {

                //cout << "ROW: " << a << " " << v[a].row << "\n";

                visitedRows[v[a].row] = true;

                for (int i = 0; i < rowPoints[v[a].row].size(); i++)
                {
                    int kohta = rowPoints[v[a].row][i];
                    //cout << "KOHTA: " << kohta << "\n";

                    if (distances[kohta] == -1)
                    {
                        distances[kohta] = distances[a] + 1;
                        q.push(kohta);
                    }
                }
            }

            if (!visitedColumns[v[a].column])
            {

                //cout << "COLUMN: " << a << " " << v[a].column << "\n";

                visitedColumns[v[a].column] = true;

                for (int i = 0; i < columnPoints[v[a].column].size(); i++)
                {
                    int kohta = columnPoints[v[a].column][i];

                    if (distances[kohta] == -1)
                    {
                        distances[kohta] = distances[a] + 1;
                        q.push(kohta);
                    }
                }
            }
        }

/*         cout << "\n \n";
        count = 0;
        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                if (distances[count] == -1)
                    cout << "X";
                else
                    cout << distances[count];
                count++;
            }
            cout << "\n";
        } */

        distancesMain[start] = distances;
        distancesDone[start] = true;

        if (distances[target] == -1)
        {
            return -1;
        }
        else
        {
            return distances[target];
        }
    };

    // vector<int> distances[62500];
    // int n = height * width;

    /*  for (int c = 0; c < n; c++)
     { // tehdään algoritmi joka solmulle

         if (v[c].unSafe)
         {
             continue;
         }

         vector<bool> visitedRows(250, false);
         vector<bool> visitedColumns(250, false);

         for (int i = 1; i <= n; i++)
             distances[c].push_back(1e9);

         distances[c][c] = 0;

         queue<int> q;
         q.push(c);
         while (!q.empty())
         {
             int a = q.front();
             q.pop();

             if (!visitedRows[v[a].row])
             {

                 // cout << "ROW: " << c << " " << v[a].row << "\n";

                 visitedRows[v[a].row] = true;

                 for (int i = 0; i < rowPoints[v[a].row].size(); i++)
                 {
                     int kohta = rowPoints[v[a].row][i];

                     if (kohta == a)
                         continue;

                     if (distances[c][kohta] > distances[c][a] + 1)
                     {
                         distances[c][kohta] = distances[c][a] + 1;
                         q.push(kohta);
                     }
                 }
             }

             if (!visitedColumns[v[a].column])
             {

                 // cout << "COLUMN: " << c << " " << v[a].column << "\n";

                 visitedColumns[v[a].column] = true;

                 for (int i = 0; i < columnPoints[v[a].column].size(); i++)
                 {
                     int kohta = columnPoints[v[a].column][i];

                     if (kohta == a)
                         continue;

                     if (distances[c][kohta] > distances[c][a] + 1)
                     {
                         distances[c][kohta] = distances[c][a] + 1;
                         q.push(kohta);
                     }
                 }
             }
         }
     } */

    for (int i = 0; i < operationAmount; i++)
    {

        int y1, x1, y2, x2;

        cin >> y1 >> x1 >> y2 >> x2;

        y1--; x1--; y2--; x2--;

        int start = y1 * width + x1;

        if (!distancesDone[start]){
            cout << algorithm(y1, x1, y2, x2) << "\n";
        }
        else{
            int target = y2 * width + x2;
            cout << distancesMain[start][target] << "\n";
        }
    }

    /*     for (int i = 0; i < operationAmount; i++)
        {
            int alkukohta = reitit[i].x1 + reitit[i].y1 * width;
            int loppukohta = reitit[i].x2 + reitit[i].y2 * width;
            int askelCount = distances[alkukohta][loppukohta];
            if (askelCount == INFINITY)
                cout << "-1" << "\n";
            else
                cout << askelCount << "\n";
        } */

    cout << "\n";
}

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: ACCEPTED

Test 5

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 6

Group: 2, 5

Verdict: ACCEPTED

Test 7

Group: 2, 5

Verdict: ACCEPTED

Test 8

Group: 2, 5

Verdict: ACCEPTED

Test 9

Group: 3, 4, 5

Verdict: ACCEPTED

Test 10

Group: 3, 4, 5

Verdict: ACCEPTED

Test 11

Group: 3, 4, 5

Verdict: ACCEPTED

Test 12

Group: 4, 5

Verdict: ACCEPTED

Test 13

Group: 4, 5

Verdict: ACCEPTED

Test 14

Group: 4, 5

Verdict: ACCEPTED

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: RUNTIME ERROR

Test 19

Group: 5

Verdict: ACCEPTED

Test 20

Group: 5

Verdict: ACCEPTED

Test 21

Group: 5

Verdict: ACCEPTED

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