Hypyt

error[E0432]: unresolved imports `rand::random_bool`, `rand::random_range`
 --> input/code.rs:4:20
  |
4 | use rand::{random, random_bool, random_range};
  |                    ^^^^^^^^^^^  ^^^^^^^^^^^^ no `random_range` in the root
  |                    |
  |                    no `random_bool` in the root

warning: unused import: `random`
 --> input/code.rs:4:12
  |
4 | use rand::{random, random_bool, random_range};
  |            ^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

error: aborting due to previous error; 1 warning emitted

For more information about this error, try `rustc --explain E0432`.

use std::io::{self, Write};
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 out = io::stdout().lock();

    let mut rowgrid: Vec<Vec<usize>> = vec!();
    let mut colgrid: Vec<Vec<usize>> = vec!();
    let mut boolgrid: Vec<Vec<bool>> = vec!();
    let mut nodes: Vec<(usize, usize)> = vec!();
 
    for row in 0..startdata[0] {
        rowgrid.push(Vec::new());
        boolgrid.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);
                boolgrid[row].push(true);
            } else {
                boolgrid[row].push(false);
            }
 
            /*if random_bool(0.05) {
                rowgrid[row].push(c);
                colgrid[c].push(row);
                boolgrid[row].push(false);
                nodes.push((row, c));
            } else {
                boolgrid[row].push(false);
            }*/
        }
    }
    //Rowtorow säilyttää mistä rivistä pääsee mihin riviin, ja käyttäen mitä nodea.
    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);});
                }
                if rowtorow[&row].len() == startdata[0]-1 {
                    break;
                }
            }
        }
    }
 
    //Distancehash säilyttää etäisyyden rivistä toiseen, ja rivin mihin matka eka liikkuu sekä
    // rivi mistä matka vikana liikkuu.
    let mut distancehash: HashMap<(usize, usize), (usize, Option<usize>, 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 = (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 {
            writeln!(&mut out, "0").expect("failed to write stdout");
            continue 'question;
        }
 
        if source.0 == dest.0 || source.1 == dest.1 {
            writeln!(&mut out, "1").expect("failed to write stdout");
            continue 'question;
        }

        match distancehash.get(&(source.0, dest.0)) {
            None => {}
            Some(d) => {
                let mut val = d.0;
                if boolgrid[d.1.unwrap()][source.1] {
                    val -= 1;
                }
                if !boolgrid[d.2][dest.1] {
                    val += 1;
                }
                writeln!(&mut out, "{val}");
            }
        }
    
        distancehash.insert((source.0, source.0), (0, None, source.0));
 
        let mut queue: VecDeque<usize> = VecDeque::new();
        queue.push_front(source.0);

        while queue.len() != 0 {
            let row = queue.pop_back().unwrap();
            let info = *distancehash.get(&(source.0, row)).unwrap();
            let start = info.1;
            let dist = info.0;
            let neighborrows = &rowtorow[&row];
 
            for neighborrow in neighborrows.iter() {
                match distancehash.get(&(source.0, *neighborrow)) {
                    Some(_) => {}
                    None => {
                        let newstart = if start.is_none() {
                            Some(*neighborrow)
                        } else {
                            start
                        };
                        distancehash.insert((source.0, *neighborrow), (dist+2, newstart, row));
                        queue.push_front(*neighborrow);
                    }
                }
            }
        }
        match distancehash.get(&(source.0, dest.0)) {
            None => {writeln!(&mut out, "-1");}
            Some(d) => {
                let mut val = d.0;
                if boolgrid[d.1.unwrap()][source.1] {
                    val -= 1;
                }
                if !boolgrid[d.2][dest.1] {
                    val += 1;
                }
                writeln!(&mut out, "{val}");
            }
        }
    };
}