Hypyt

warning: unused variable: `value`
  --> input/code.rs:31:13
   |
31 |     let mut value: usize = 0;
   |             ^^^^^ help: if this is intentional, prefix it with an underscore: `_value`
   |
   = note: `#[warn(unused_variables)]` on by default

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

warning: unused variable: `dist`
  --> input/code.rs:89:26
   |
89 |                     Some(dist) => {}
   |                          ^^^^ help: if this is intentional, prefix it with an underscore: `_dist`

warning: variable does not need to be mutable
  --> input/code.rs:31:9
   |
31 |     let mut value: usize = 0;
   |         ----^^^^^
   |         |
   |         help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

warning: 4 warnings emitted

use std::io;
use std::collections::{HashMap, VecDeque};

type NodeID = (usize, usize);

#[derive(Debug)]
pub struct Graph {
    data: HashMap<NodeID, Vec<NodeID>>
}

impl Graph {
    fn new() -> Self {
        Self { data: HashMap::new() }
    }
    fn add_node(&mut self, id: NodeID) {
        self.data.entry(id).or_insert(Vec::new());
    }
    fn add_edge(&mut self, from: NodeID, to: NodeID) {
        self.add_node(to);
        self.data.get_mut(&from).unwrap().push(to);
    }
}

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 grid: Vec<NodeID> = vec!();
    let mut value: usize = 0;

    for row in 0..startdata[0] {
        let mut rowinput = String::new();
        io::stdin().read_line(&mut rowinput).expect("Failed to read input");
 
        let bytes = rowinput.as_bytes();

        for bytenum in 0..startdata[1] {
            if bytes[bytenum] == 46 {
                grid.push((row, bytenum));
            }
        }
    }

    let mut graph = Graph::new();
    for node in &grid {
        graph.add_node(*node);
        for neighbor in &grid {
            if node != neighbor {
                if node.0 == neighbor.0 || node.1 == neighbor.1 {
                    graph.add_edge(*node, *neighbor);
                }
            }
        }
    }

    for question 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]);
        let mut distancehash: HashMap<(NodeID, NodeID), isize> = HashMap::new();

        match distancehash.get(&(source, destination)) {
            Some(s) => {println!("{}", s)}
            None => {}
        }

        let mut queue: VecDeque<NodeID> = VecDeque::new();
        distancehash.insert((source, source), 0);
        queue.push_front(source);

        loop {
            let node = match queue.pop_back() {
                Some(s) => s,
                None => break,
            };

            match distancehash.get(&(node, destination)) {
                Some(dist) => {let _ = distancehash.insert((source, destination), distancehash[&(source, node)]+dist); break;}
                None => {}
            };

            for neighbor in &graph.data[&node] {
                match distancehash.get_mut(&(source, *neighbor)) {
                    Some(dist) => {}
                    None => {
                        distancehash.insert((source, *neighbor), distancehash[&(source, node)]+1);
                        distancehash.insert((*neighbor, source), distancehash[&(node, source)]+1);
                        queue.push_front(*neighbor);
                    }
                }
                if *neighbor == destination {
                    queue.clear();
                    break;
                }
            }
        }
        match distancehash.get(&(source, destination)) {
            Some(dist) => {println!("{}", dist)}
            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