Hypyt

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`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `start`
  --> input/code.rs:34:13
   |
34 |         let start = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
   |             ^^^^^ help: if this is intentional, prefix it with an underscore: `_start`

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};
 
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 grid: Vec<Vec<bool>> = vec!();
 
    for row in 0..startdata[0] {
        let mut rowinput = String::new();
        io::stdin().read_line(&mut rowinput).expect("Failed to read input");
 
        let newrow = rowinput.into_bytes().into_iter().map(|c| if c == 46 {true} else {false}).collect();
        /*let mut newrow = vec!();
        for c in 0..startdata[1] {
            newrow.push(random_bool(0.3));
        }*/
        grid.push(newrow);
    }
 
    //dbg!(&grid);
 
    let mut distancehash: HashMap<(NodeID, NodeID), usize> = HashMap::new();
    for _q in 0..startdata[2] {
        let mut questioninput = String::new();
        io::stdin().read_line(&mut questioninput).expect("Failed to read input");
        let start = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
        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 y1 = random_range(0..startdata[0]);
        let y2 = random_range(0..startdata[0]);
        let x1 = random_range(0..startdata[1]);
        let x2 = random_range(0..startdata[1]);
        let source = (y1, x1);
        let destination = (y2, x2);*/
 
        match distancehash.get(&(source, destination)) {
            Some(d) => {
                println!("{} ", d); 
                //let end = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
                //println!("{}", end-start);
                continue;
            },
            None => {}
        }
        
        if source == destination {
            println!("0 ");
            //let end = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
            //println!("{}", end-start);
            continue;
        } 
        if source.0 == destination.0 || source.1 == destination.1 {
            println!("1 ");
            //let end = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
            //println!("{}", end-start);
            continue;
        }
        if grid[source.0][destination.1] || grid[destination.0][source.1] {
            println!("2");
            continue;
        }
 
        let mut sourceset: HashSet<NodeID> = HashSet::new();
        let mut destset: HashSet<NodeID> = HashSet::new();
        distancehash.insert((source, source), 0);
        distancehash.insert((destination, destination), 0);
 
        let mut sourcequeue: VecDeque<NodeID> = VecDeque::new();
        sourcequeue.push_front(source);
        let mut destqueue: VecDeque<NodeID> = VecDeque::new();
        destqueue.push_front(destination);
        let mut destsearch = 0;
        let mut sourcesearch = 0;
        let mut state = true;
        
        'outer: while sourcequeue.len() != 0 && destqueue.len() != 0 {
            if state {
                let node = sourcequeue.pop_back().unwrap();
                let dist = *distancehash.get(&(source, node)).unwrap();
 
                if dist > sourcesearch {
                    sourcequeue.push_back(node);
                    state = false;
                    sourcesearch += 1;
                    continue 'outer;
                }
 
                sourceset.insert(node);
 
                if destset.contains(&node) {
                    let desttonode = distancehash[&(destination, node)];
                    distancehash.insert((source, destination), dist+desttonode);
                    distancehash.insert((destination, source), dist+desttonode);
                    break 'outer;
                }
            
                for row in 0..grid.len() {
                    if row == node.0 {
                        for cell in 0..grid[row].len() {
                            if grid[row][cell] {
                                let neighbor = (row, cell);
                                let d = match distancehash.get(&(source, neighbor)) {
                                    Some(distance) => *distance,
                                    None => 1000000
                                };
                                if d > dist {
                                    distancehash.insert((source, neighbor), dist+1);
                                    distancehash.insert((neighbor, source), dist+1);
                                    sourcequeue.push_front(neighbor);
                                }
                                if neighbor == destination {
                                    break 'outer;
                                }
                            }
                        }
                    } else {
                        if grid[row][node.1] {
                            let neighbor = (row, node.1);
                            let d = match distancehash.get(&(source, neighbor)) {
                                Some(distance) => *distance,
                                None => 1000000
                            };
                            if d > dist {
                                distancehash.insert((source, neighbor), dist+1);
                                distancehash.insert((neighbor, source), dist+1);
                                sourcequeue.push_front(neighbor);
                            }
                            if neighbor == destination {
                                break 'outer;
                            }
                        }
                    }
                }
            } else {
                let destnode = destqueue.pop_back().unwrap();
                let destdist = *distancehash.get(&(destination, destnode)).unwrap();
 
                if destdist > destsearch {
                    destqueue.push_back(destnode);
                    state = true;
                    destsearch += 1;
                    continue 'outer;
                }
 
                destset.insert(destnode);
                if sourceset.contains(&destnode) {
                    let sourcetonode = distancehash[&(source, destnode)];
                    distancehash.insert((source, destination), destdist+sourcetonode);
                    distancehash.insert((destination, source), destdist+sourcetonode);
                    break 'outer;
                }
 
 
                for row in 0..grid.len() {
                    if row == destnode.0 {
                        for cell in 0..grid[row].len() {
                            if grid[row][cell] {
                                let neighbor = (row, cell);
                                let d = match distancehash.get(&(destination, neighbor)) {
                                    Some(distance) => *distance,
                                    None => 1000000
                                };
                                if d > destdist {
                                    distancehash.insert((destination, neighbor), destdist+1);
                                    distancehash.insert((neighbor, destination), destdist+1);
                                    destqueue.push_front(neighbor);
                                }
                                if neighbor == source {
                                    break 'outer;
                                }
                            }
                        }
                    } else {
                        if grid[row][destnode.1] {
                            let neighbor = (row, destnode.1);
                            let d = match distancehash.get(&(destination, neighbor)) {
                                Some(distance) => *distance,
                                None => 1000000
                            };
                            if d > destdist {
                                distancehash.insert((destination, neighbor), destdist+1);
                                distancehash.insert((neighbor, destination), destdist+1);
                                destqueue.push_front(neighbor);
                            }
                            if neighbor == source {
                                break 'outer;
                            }
                        }
                    }
                }
            }
        }
        match distancehash.get(&(source, destination)) {
            Some(s) => {println!("{} ", s);},
            None => {println!("-1 ");}
        }
        //let end = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
        //println!("{}", end-start);
    }
}

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

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

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

Test 27

Group: 5

Verdict: ACCEPTED