Peli

warning: unused variable: `n`
  --> input/code.rs:80:9
   |
80 |     let n: usize = s.next().unwrap().trim().parse().unwrap();
   |         ^ help: if this is intentional, prefix it with an underscore: `_n`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: 1 warning emitted

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

const  MAX_N: usize = 2510;

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

    let mut visited_o = [false; MAX_N];
    let mut visited_e = [false; MAX_N];

    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() {
            if planet == b {
                if x % 2 == 0 {
                    return dist_e[b] <= x
                }
            }

            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() {
            if planet == b {
                if x % 2 == 1 {
                    return dist_o[b] <= x
                }
            }

            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);
                } 
            }
        }
    }

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

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

    return 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![]; MAX_N];


    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);


    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();

        if check(&graph, a, b, x) {
            println!("YES");
        } else {
            println!("NO");
        }
    }

}

Test 1

Group: 1, 2

Verdict: ACCEPTED

Test 2

Group: 1, 2

Verdict: ACCEPTED

Test 3

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 4

Group: 1, 2

Verdict: ACCEPTED

Test 5

Group: 1, 2

Verdict: ACCEPTED

Test 6

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 7

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 8

Group: 1, 2

Verdict: ACCEPTED

Test 9

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 10

Group: 2

Verdict: TIME LIMIT EXCEEDED