Hypyt

warning: unused variable: `nodehash`
  --> input/code.rs:12:13
   |
12 |     let mut nodehash: HashMap<usize, NodeID> = HashMap::new();
   |             ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_nodehash`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `value`
  --> input/code.rs:14:13
   |
14 |     let mut value: usize = 0;
   |             ^^^^^ help: if this is intentional, prefix it with an underscore: `_value`

warning: unused variable: `row`
  --> input/code.rs:16:9
   |
16 |     for row in 0..startdata[0] {
   |         ^^^ help: if this is intentional, prefix it with an underscore: `_row`

warning: unused variable: `s`
  --> input/code.rs:64:42
   |
64 | ...                   Some(s) => {}
   |                            ^ help: if this is intentional, prefix it with an underscore: `_s`

warning: unused variable: `s`
  --> input/code.rs:77:34
   |
77 | ...                   Some(s) => {}
   |...

use std::io;
use std::collections::{HashMap, VecDeque};
 
type NodeID = (usize, usize);

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read input");
 
    let startdata: Vec<usize> = input.split_whitespace().map(|e| e.parse::<usize>().unwrap()).collect();
 
    let mut nodehash: HashMap<usize, NodeID> = HashMap::new();
    let mut grid: Vec<Vec<bool>> = vec!();
    let mut value: usize = 0;
 
    for row in 0..startdata[0] {
        let mut newrow: Vec<bool> = vec!();
        let mut rowinput = String::new();
        io::stdin().read_line(&mut rowinput).expect("Failed to read input");

        for c in rowinput.into_bytes().into_iter() {
            if c == 46 {
                newrow.push(true);
            } else {
                newrow.push(false);
            }
        } 
        grid.push(newrow);
    }
 
    for _q in 0..startdata[2] {
        let mut questioninput = String::new();
        io::stdin().read_line(&mut questioninput).expect("Failed to read input");
        let questiondata: Vec<usize> = questioninput.split_whitespace().map(|e| e.parse::<usize>().unwrap()-1).collect();
        let source: NodeID = (questiondata[0], questiondata[1]);
        let destination: NodeID = (questiondata[2], questiondata[3]);
        
        if source == destination {
            println!("0");
            continue;
        }

        let mut distancehash: HashMap<(NodeID, NodeID), usize> = HashMap::new();
        distancehash.insert((source, source), 0);

        let mut queue: VecDeque<NodeID> = VecDeque::new();
        queue.push_front(source);
        
        while queue.len() != 0 {
            let node = queue.pop_back().unwrap();
            let dist = *distancehash.get(&(source, node)).unwrap();

            //dbg!(&node);
            //dbg!(&queue);
            //dbg!(&distancehash);

            for row in 0..grid.len() {
                if row == node.0 {
                    for cell in 0..grid[row].len() {
                        if grid[row][cell] {
                            if cell != node.1 {
                                let neighbor = (row, cell);
                                match distancehash.get(&(source, neighbor)) {
                                    Some(s) => {}
                                    None =>{
                                        distancehash.entry((source, neighbor)).or_insert(dist+1);
                                        queue.push_front(neighbor);
                                    }
                                }
                            }
                        }
                    }
                } else {
                    if grid[row][node.1] {
                        let neighbor = (row, node.1);
                        match distancehash.get(&(source, neighbor)) {
                            Some(s) => {}
                            None => {
                                distancehash.entry((source, neighbor)).or_insert(dist+1);
                                queue.push_front(neighbor);
                            }
                        }
                    }
                }
            }
        }
        match distancehash.get(&(source, destination)) {
            Some(s) => {println!("{}", s);},
            None => {println!("-1");}
        }
    }
}

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