Hypyt

warning: unused variable: `question`
  --> input/code.rs:53:9
   |
53 |     for question in 0..startdata[2] {
   |         ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_question`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `freecell`
  --> input/code.rs:61:13
   |
61 |         for freecell in 0..value {
   |             ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_freecell`

warning: field `adj` is never read
 --> input/code.rs:7:5
  |
6 | pub struct Graph {
  |            ----- field in this struct
7 |     adj: HashMap<NodeID, Vec<NodeID>>
  |     ^^^
  |
  = note: `#[warn(dead_code)]` on by default

warning: associated items `new`, `add_node`, and `add_edge` are never used
  --> input/code.rs:11:8
   |
10 | impl Graph {
   | ---------- associated items in this implementation
11 |     fn new() -> Self {
   |        ^^^
...
14 |     fn add_node(&mut self, id: NodeID) {
   |        ^^^^^^^^
...
1...

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

type NodeID = (usize, usize);

pub struct Graph {
    adj: HashMap<NodeID, Vec<NodeID>>
}

impl Graph {
    fn new() -> Self {
        Self { adj: HashMap::new() }
    }
    fn add_node(&mut self, id: NodeID) {
        self.adj.entry(id).or_insert(Vec::new());
    }
    fn add_edge(&mut self, from: NodeID, to: NodeID) {
        self.add_node(from);
        self.add_node(to);
        self.adj.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<Vec<usize>> = vec!();
    let mut value: usize = 0;
    let mut nodehash: HashMap<NodeID, usize> = HashMap::new();

    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();
        let mut rowdata: Vec<usize> = vec!();

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

    // Graph builder here?

    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 distances: Vec<isize> = vec!();
        for freecell in 0..value {
            distances.push(-1);
        }

        let mut queue: VecDeque<NodeID> = VecDeque::new();
        distances[nodehash[&source]] = 0;
        queue.push_front(source);

        while queue.len() != 0 {
            let node = match queue.pop_back() {
                Some(s) => s,
                None => panic!(),
            };

            for row in 0..grid.len() {
                for freecell in &grid[row] {
                    if row == node.0 || *freecell == node.1 {
                        if row != node.0 || *freecell != node.1 {
                            if distances[nodehash[&(row, *freecell)]] == -1 {
                                distances[nodehash[&(row, *freecell)]] = distances[nodehash[&node]] + 1;
                                queue.push_front((row, *freecell));
                            }
                        }
                    }
                }
            }
        }
        println!("{}", distances[nodehash[&destination]]);
    }
}

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