Hypyt

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

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

warning: 2 warnings emitted

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

//use rand::{random, random_bool, random_range};
//use std::time::{SystemTime, UNIX_EPOCH};

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<usize>> = vec!();
    let mut colgrid: Vec<Vec<usize>> = vec!();
    let mut nodes: Vec<(usize, usize)> = vec!();
 
    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.into_bytes();

        for c in 0..startdata[1] {
            if row == 0 {
                colgrid.push(Vec::new());
            }
            if bytes[c] == 46 {
                rowgrid[row].push(c);
                colgrid[c].push(row);
            }

            /*if random_bool(0.1) {
                rowgrid[row].push(c);
                colgrid[c].push(row);
                nodes.push((row, c));
            }*/
        }
    }

    let mut rowtorow: HashMap<usize, HashSet<usize>> = HashMap::new();

    for row in 0..rowgrid.len() {
        rowtorow.insert(row, HashSet::new());

        for node in rowgrid[row].iter() {
            for rowneighbor in colgrid[*node].iter() {
                if *rowneighbor != row {
                    rowtorow.entry(row).and_modify(|v| {v.insert(*rowneighbor);});
                }
            }
        }
    }
 
    '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 = (questiondata[0], questiondata[1]);
        let dest = (questiondata[2], questiondata[3]);

        /*let source = nodes[random_range(0..nodes.len())];
        let dest = nodes[random_range(0..nodes.len())];*/

        if source == dest {
            println!("0");
            continue 'question;
        }

        if source.0 == dest.0 || source.1 == dest.1 {
            println!("1");
            continue 'question;
        }
    
        let mut distancehash: HashMap<usize, usize> = HashMap::new();
        distancehash.insert(source.0, 0);

        let mut queue: VecDeque<usize> = VecDeque::new();
        queue.push_front(source.0);

        for neighborrow in colgrid[source.1].iter() {
            if *neighborrow != source.0 {
                if *neighborrow == dest.0 {
                    println!("2");
                    continue 'question;
                }
                distancehash.insert(*neighborrow, 1);
                queue.push_front(*neighborrow);
            }
        }

        let mut possibilities: Vec<usize> = Vec::new();
        let mut searchdist: usize = 0;
        while queue.len() != 0 {
            let row = queue.pop_back().unwrap();
            let dist = *distancehash.get(&row).unwrap();
            let neighborrows = &rowtorow[&row];

            if dist > searchdist {
                searchdist += 1;

                if possibilities.len() != 0 {
                    let val = possibilities.iter().min().unwrap();
                    println!("{}", val);
                    continue 'question;
                }
            }

            for neighborrow in neighborrows.iter() {
                if *neighborrow == dest.0 {
                    if colgrid[dest.1].contains(&row) {
                        possibilities.push(dist+2);
                    } else {
                        possibilities.push(dist+3);
                    }
                }
                match distancehash.get(&neighborrow) {
                    Some(_) => {}
                    None => {
                        distancehash.insert(*neighborrow, dist+2);
                        queue.push_front(*neighborrow);
                    }
                }
            }
        }
        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: 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: 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: ACCEPTED

Test 25

Group: 5

Verdict: ACCEPTED

Test 26

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 27

Group: 5

Verdict: ACCEPTED