Peli

warning: unused variable: `de`
  --> input/code.rs:56:9
   |
56 |     let de = {
   |         ^^ help: if this is intentional, prefix it with an underscore: `_de`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: 1 warning emitted

use std::{*, collections::VecDeque};

fn check(graph: &Vec<Vec<usize>>, n: usize, _m: usize, a: usize, b: usize, x: usize) -> bool {
    let mut dist_o = vec![usize::MAX; n + 1];
    let mut dist_e = vec![usize::MAX; n + 1];
    let mut pe = vec![0; n + 1];
    let mut po = vec![0; n + 1];

    let mut visited_o = vec![false; n + 1];
    let mut visited_e = vec![false; n + 1];

    let mut qo = VecDeque::new();
    let mut qe = VecDeque::new();
    qe.push_back(a);
    dist_e[a] = 0;
    visited_e[a] = true;

    while !qe.is_empty() || !qo.is_empty() {
        if let Some(planet) = qe.pop_front() {
            visited_e[planet] = true;
            for c in graph[planet].iter() {
                if dist_e[planet] + 1 < dist_o[*c] {
                    dist_o[*c] = dist_e[planet] + 1;
                    po[*c] = planet;
                }
                if !visited_o[*c] {
                    qo.push_back(*c);
                } 
            }
        }
        if let Some(planet) = qo.pop_front() {
            visited_o[planet] = true;
            for c in graph[planet].iter() {
                if dist_o[planet] + 1 < dist_e[*c] {
                    dist_e[*c] = dist_o[planet] + 1;
                    pe[*c] = planet;
                }
                if !visited_e[*c] {
                    qe.push_back(*c);
                } 
            }
        }
    }


    let mut visited2 = vec![false; n + 1];
    let mut planet = b;

    eprintln!("a: {a} b: {b} x: {x}");
    eprintln!("pe: {:?}", pe);
    eprintln!("po: {:?}", po);
    eprintln!("de: {:?}", dist_e);
    eprintln!("ddo: {:?}", dist_o);

    let de = {
        let mut d = 0;
        let p = pe;
        while planet != a {
            eprintln!("> {}", planet);
            planet = p[planet];
            if visited2[planet] {
                break;
            }
            visited2[planet] = true;
            d += 1;
        }
        d
    };

    eprintln!("de: {}, do: {}", dist_e[b], dist_o[b]);

    if x % 2 == 0 {
        dist_e[b] <= x
    } else {
        dist_o[b] <= x
    }
}

fn main() {
    let stdin = io::stdin();
    let mut str = String::new();
    stdin.read_line(&mut str).unwrap();
    let mut s = str.split(" ");
    let n: usize = s.next().unwrap().trim().parse().unwrap();
    let m: usize = s.next().unwrap().trim().parse().unwrap();
    let q: usize = s.next().unwrap().trim().parse().unwrap();

    let mut graph = vec![vec![]; n + 1];


    for _ in 0..m {
        let mut str = String::new();
        stdin.read_line(&mut str).unwrap();
    
        let mut s = str.split(" ");
        let a: usize = s.next().unwrap().trim().parse().unwrap();
        let b: usize = s.next().unwrap().trim().parse().unwrap();

        graph[a].push(b);
        graph[b].push(a);
    }

    eprintln!("{:?}", graph);


    let mut res: Vec<bool> = vec![];
    for _ in 0..q {
        let mut str = String::new();
        stdin.read_line(&mut str).unwrap();    
        let mut s = str.split(" ");
        let a: usize = s.next().unwrap().trim().parse().unwrap();
        let b: usize = s.next().unwrap().trim().parse().unwrap();
        let x: usize = s.next().unwrap().trim().parse().unwrap();

        res.push(check(&graph, n, m, a, b, x));
    }

    println!("{}", res.into_iter()
    .map(|b| if b {String::from("YES")} else {String::from("NO")})
        .collect::<Vec<String>>().join("\n"));
}

Test 1

Group: 1, 2

Verdict: ACCEPTED

[[], [2], [1]]
a: 1 b: 1 x: 0
pe: [0, 0, 0]
po: [0, 0, 1]
de: [18446744073709551615, 0, 18...

Test 2

Group: 1, 2

Verdict: ACCEPTED

[[], [2], [3, 1], [4, 2], [3, 5], [6, 4], [7, 5], [8, 6], [7, 9], [8, 10], [11, 9], [12, 1...

Test 3

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 4

Group: 1, 2

Verdict: ACCEPTED

[[], [12, 2], [3, 1], [2, 4], [3, 5], [6, 4], [7, 5], [8, 6], [7, 9], [10, 8], [9, 11], [1...

Test 5

Group: 1, 2

Verdict: ACCEPTED

[[], [2, 11], [1, 3], [4, 2], [3, 5], [6, 4], [5, 7], [8, 6], [7, 9], [10, 8], [11, 9], [1...

Test 6

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 7

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 8

Group: 1, 2

Verdict: ACCEPTED

[[], [35, 9, 5, 4, 2], [6, 3, 1], [11, 10, 20, 2, 37, 23], [7, 14, 8, 26, 1], [15, 1, 17,...

Test 9

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 10

Group: 2

Verdict: TIME LIMIT EXCEEDED