Hypyt

input/code.cpp: In function 'int main()':
input/code.cpp:121:35: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  121 |                 for (int i = 0; i < rowPoints[v[a].row].size(); i++)
      |                                 ~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
input/code.cpp:143:35: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  143 |                 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";
    } */

    // Suoritetaan algoritmi

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

    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);
                    }
                }
            }
        }
    }

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

    vector<route> reitit;

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

        int y1, x1, y2, x2;

        cin >> y1 >> x1 >> y2 >> x2;
        reitti.x1 = x1 - 1;
        reitti.y1 = y1 - 1;
        reitti.x2 = x2 - 1;
        reitti.y2 = y2 - 1;

        reitit.push_back(reitti);
    }

    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 == 1e9)
            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: TIME LIMIT EXCEEDED

Test 7

Group: 2, 5

Verdict: TIME LIMIT EXCEEDED

Test 8

Group: 2, 5

Verdict: TIME LIMIT EXCEEDED

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

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