Hypyt

warning: unused import: `HashSet`
 --> input/code.rs:2:33
  |
2 | use std::collections::{HashMap, HashSet, VecDeque};
  |                                 ^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused variable: `boolgrid`
  --> input/code.rs:15:13
   |
15 |     let mut boolgrid: Vec<Vec<bool>> = vec!();
   |             ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_boolgrid`
   |
   = note: `#[warn(unused_variables)]` on by default

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

warning: variable does not need to be mutable
  --> input/code.rs:15:9
   |
15 |     let mut boolgrid: Vec<Vec<bool>> = vec!();
   |         ----^^^^^^^^
   |         |
   |         help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

warning: variable does not need to be mutable
  --> input/code.rs:17:...

use std::io;
use std::collections::{HashMap, HashSet, VecDeque};
//use rand::{random, random_bool, random_range};
 
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 rowgrid: Vec<Vec<NodeID>> = vec!();
    let mut colgrid: Vec<Vec<NodeID>> = vec!();
    let mut boolgrid: Vec<Vec<bool>> = vec!();

    let mut val = 0;
 
    for row in 0..startdata[0] {
        rowgrid.push(Vec::new());
        let mut rowinput = String::new();
        io::stdin().read_line(&mut rowinput).expect("Failed to read input");
        let bytes = rowinput.as_bytes();
 
        for c in 0..startdata[1] {
            if row == 0 {
                colgrid.push(Vec::new());
            }
            if bytes[c] == 46 {
                rowgrid[row].push((row, c));
                colgrid[c].push((row, c));
            }
        }
    }
 
    let mut dist2cols: Vec<Vec<NodeID>> = vec!();
 
    for col in 0..startdata[1] {
        dist2cols.push(Vec::new());
        for cell in colgrid[col].iter() {
            for neighbor in rowgrid[cell.0].iter() {
                if neighbor != cell {
                    dist2cols[col].push(*neighbor);
                }
            }
        }
    }
 
    let mut dist2rows: Vec<Vec<NodeID>> = vec!();
 
    for row in 0..startdata[0] {
        dist2rows.push(Vec::new());
        for cell in rowgrid[row].iter() {
            for neighbor in colgrid[cell.1].iter() {
                if neighbor != cell {
                    dist2rows[row].push(*neighbor);
                }
            }
        }
    }
 
    //dbg!(&grid);
 
    let mut distancehash: HashMap<(NodeID, NodeID), usize> = HashMap::new();
    'question: 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 dest: NodeID = (questiondata[2], questiondata[3]);
 
        distancehash.insert((source, source), 0);
 
        match distancehash.get(&(source, dest)) {
            Some(dist) => {println!("{}", dist); continue;}
            None => {}
        }
 
        let mut queue: VecDeque<NodeID> = VecDeque::new();
        queue.push_front(source);
 
        let mut possibilities: Vec<usize> = vec!();
        let mut searchdist: usize = 0;
 
        'bfs: while queue.len() != 0 {
            let node = queue.pop_back().unwrap();
            let dist = *distancehash.get(&(source, node)).unwrap();
 
            if dist > searchdist {
                if possibilities.len() != 0 {
                    println!("{}", possibilities.iter().min().unwrap());
                    continue 'question;
                }
                searchdist += 2;
            }

            if node.0 == dest.0 || node.1 == dest.1 {
                println!("{}", dist+1);
                continue 'question;
            }

            for neighbor in rowgrid[node.0].iter() {
                if *neighbor != node {
                    distancehash.entry((source, *neighbor)).or_insert(dist+1);
                    distancehash.entry((source, *neighbor)).or_insert(dist+1);
                }
            }

            for neighbor in colgrid[node.1].iter() {
                if *neighbor != node {
                    distancehash.entry((source, *neighbor)).or_insert(dist+1);
                    distancehash.entry((source, *neighbor)).or_insert(dist+1);
                }
            }
 
            for neighbor in dist2cols[node.1].iter() {
                if node.0 != neighbor.0 {
                    let neighbordist = match distancehash.get(&(source, *neighbor)) {
                        Some(d) => *d,
                        None => 1000000
                    };
                    if neighbordist > dist {
                        distancehash.insert((source, *neighbor), dist+2);
                        distancehash.insert((*neighbor, source), dist+2);
                        queue.push_front(*neighbor);
                    }
                    if *neighbor == dest {
                        possibilities.push(neighbordist);
                        continue 'bfs;
                    }
                }
            }
 
            for neighbor in dist2rows[node.0].iter() {
                if node.1 != neighbor.1 {
                    let neighbordist = match distancehash.get(&(source, *neighbor)) {
                        Some(d) => *d,
                        None => 1000000
                    };
                    if neighbordist > dist {
                        distancehash.insert((source, *neighbor), dist+2);
                        distancehash.insert((*neighbor, source), dist+2);
                        queue.push_front(*neighbor);
                    }
                    if *neighbor == dest {
                        possibilities.push(neighbordist);
                        continue 'bfs;
                    }
                }
            }
        }
        match distancehash.get(&(source, dest)) {
            Some(d) => println!("{}", d),
            None => println!("-1")
        }
    }
}

Test 1 (public)

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 2

Group: 1, 2, 3, 4, 5

Verdict: WRONG ANSWER

Test 3

Group: 1, 2, 3, 4, 5

Verdict: WRONG ANSWER

Test 4

Group: 1, 2, 3, 4, 5

Verdict: WRONG ANSWER

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

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

Test 20

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 21

Group: 5

Verdict: WRONG ANSWER

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

Test 27

Group: 5

Verdict: ACCEPTED