Hypyt

input/code.cpp: In function 'std::unordered_map<int, int> bfs(int, int, std::vector<std::vector<Node> >&, std::vector<std::vector<Node> >&, Node&, std::vector<Node>&, std::vector<Node>&)':
input/code.cpp:50:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<Node>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   50 |             for(int c=0; c<rows[current->pos.second].size(); c++){
      |                          ~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
input/code.cpp:59:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<Node>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   59 |             for(int c=0; c<columns[current->pos.first].size(); c++){
      |                          ~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
input/code.cpp: In function 'int main()':
input/code.cpp:75:10: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result'...

#include <bits/stdc++.h>
using namespace std;
 
struct Node {
  char type; // n = cell, r = row, c = column
  pair<int, int> pos;
};
 
int id(Node* node, int n, int m){
    if(node->type == 'r'){
        return n*m+node->pos.second;
    }
    else if(node->type == 'c'){
        return n*m+n+node->pos.first;
    }
    else{
        return m*node->pos.second+node->pos.first;
    }
}
 
unordered_map<int, int> bfs(int n, int m, vector<vector<Node>>& rows, vector<vector<Node>>& columns, Node& start, vector<Node>& row_nodes, vector<Node>& column_nodes){
    vector<bool> visited (n*m+n+m, false);
    
    queue<pair<Node*, int>> q; // {current, move_count}
    q.push({&start, 0});
    visited[id(&start, n, m)] = true;
    
    unordered_map<int, int> table;
    
    while (q.size() > 0){
        Node* current = q.front().first;
        int move_count = q.front().second;
        q.pop();
        
 
        if(current->type == 'n'){
            if(!visited[id(&row_nodes[current->pos.second], n, m)]){
                q.push({&row_nodes[current->pos.second], move_count});
                visited[id(&row_nodes[current->pos.second], n, m)] = true;
            }
 
            if(!visited[id(&column_nodes[current->pos.first], n, m)]){
                q.push({&column_nodes[current->pos.first], move_count});
                visited[id(&column_nodes[current->pos.first], n, m)] = true;
            }
        }
        else if(current->type == 'r'){
            table[id(current, n, m)] = move_count+1;
            
            for(int c=0; c<rows[current->pos.second].size(); c++){
                if(!visited[id(&rows[current->pos.second][c], n, m)]){
                    q.push({&rows[current->pos.second][c], move_count+1});
                    visited[id(&rows[current->pos.second][c], n, m)] = true;
                }
            }
        }
        else if(current->type == 'c'){
            table[id(current, n, m)] = move_count+1;
            for(int c=0; c<columns[current->pos.first].size(); c++){
                if(!visited[id(&columns[current->pos.first][c], n, m)]){
                    q.push({&columns[current->pos.first][c], move_count+1});
                    visited[id(&columns[current->pos.first][c], n, m)] = true;
                }
            }
        }
 
    }
 
    return table;
}
 
int main() {
    
    int n, m, q;
    scanf("%d %d %d", &n, &m, &q);
   
    vector<vector<char>> grid(n, vector<char>(m, 0));
    
    vector<vector<Node>> rows;
    vector<vector<Node>> columns;
    vector<Node> row_nodes;
    vector<Node> column_nodes;

    for(int i=0; i < n; i++){
        vector<Node> row = {};
        char line[m+1];
        scanf(" %[^\n]", line);
        
        for(int j=0; j < m; j++){
            grid[i][j] = line[j];
            if(grid[i][j] == '*') continue;
            Node node = {'n', {j, i}};
            row.push_back(node);
        }
        rows.push_back(row);

        Node row_node = {'r', {-1, i}};
        row_nodes.push_back(row_node);
    }
 
    for(int j=0; j < m; j++){
        vector<Node> column = {};
        for(int i=0; i < n; i++){
            if(grid[i][j] == '*') continue;
            Node node = {'n', {j, i}};
            column.push_back(node);
        }
        columns.push_back(column);

        Node column_node = {'c', {j, 0}};
        column_nodes.push_back(column_node);
    }
    
 
    vector<unordered_map<int, int>> table(n+m);
    
    for(int i=0; i < q; i++){
        int x1, y1, x2, y2;
        scanf("%d %d %d %d", &y1, &x1, &y2, &x2);
        
        if(y1==y2 && x1==x2){
            printf("%d\n", 0);
            continue;
        }
        
        if(table[y1-1].size() == 0){
            Node start_row = {'r', {-1, y1-1}};
            table[y1-1] = bfs(n, m, rows, columns, start_row, row_nodes, column_nodes);
        }
        if(table[n+(x1-1)].size() == 0){
            Node start_col = {'c', {x1-1, -1}};
            table[n+(x1-1)] = bfs(n, m, rows, columns, start_col, row_nodes, column_nodes);
        }
        
        int p1 = table[y1-1][n*m+(y2-1)];
        int p2 = table[y1-1][n*m+n+(x2-1)];
        int p3 = table[n+(x1-1)][n*m+(y2-1)];
        int p4 = table[n+(x1-1)][n*m+n+(x2-1)];
        
        if(p1 == 0 || p2==0 || p3==0 || p4==0){
            printf("%d\n", -1);
            continue;
        }
        
        printf("%d\n", min(min(p1, p2), min(p3, p4)));
    }
 
    return 0;
}

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

Test 17

Group: 5

Verdict: ACCEPTED

Test 18

Group: 5

Verdict: ACCEPTED

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