提出 #30717048

---

ソースコード 拡げる

#[derive(Debug, Copy, Clone)]
enum Dir {
    S,
    R,
}

const RU: (i32, i32) = (1, 1);
const LU: (i32, i32) = (-1, 1);
const RB: (i32, i32) = (1, -1);
const LB: (i32, i32) = (-1, -1);

fn main() {
    let n: usize = read();
    let (ax, ay): (usize, usize) = (read::<usize>() - 1, read::<usize>() - 1);
    let (bx, by): (usize, usize) = (read::<usize>() - 1, read::<usize>() - 1);
    let mut field = vec![vec!['x'; n]; n];
    let mut dists = vec![vec![std::i32::MAX; n]; n];
    for i in 0..n {
        let s: String = read::<String>();
        field[i] = s.chars().collect();
    }
    let bounded_by_n = |x| -> bool { 0 <= x && x < (n as i32) };
    let mut deque = VecDeque::new();
    dists[ax][ay] = 0;
    deque.push_back(((ax, ay), (0, 0), 0));

    while let Some((p, dir, d)) = deque.pop_front() {
        for &(dx, dy) in &[RU, RB, LU, LB] {
            let nx = p.0 as i32 + dx;
            let ny = p.1 as i32 + dy;
            if bounded_by_n(nx) && bounded_by_n(ny) {
                let nx = (p.0 as i32 + dx) as usize;
                let ny = (p.1 as i32 + dy) as usize;
                if field[nx][ny] == '#' {
                    continue;
                }
                if dir == (dx, dy) && d < dists[nx][ny] {
                    deque.push_front(((nx, ny), dir, d));
                    dists[nx][ny] = d;
                } else if d + 1 < dists[nx][ny] {
                    deque.push_back(((nx, ny), (dx, dy), d + 1));
                    dists[nx][ny] = d + 1;
                };
            }
        }
    }

    let res = if dists[bx][by] == std::i32::MAX {
        -1
    } else {
        dists[bx][by]
    };
    println!("{}", res);
}

// =========
#[allow(unused_imports)]
use std::cmp::{max, min};
use std::collections::VecDeque;
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet};
#[allow(unused_imports)]
use std::process::exit;

#[allow(dead_code)]
const MOD: usize = 1000000007;
#[allow(dead_code)]
const INF: usize = std::usize::MAX / 2;

fn read<T: std::str::FromStr>() -> T {
    use std::io::Read;
    let stdin = std::io::stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

// =========

提出情報

コンパイルエラー

warning: variant is never constructed: `S`
 --> src/main.rs:3:5
  |
3 |     S,
  |     ^
  |
  = note: `#[warn(dead_code)]` on by default

warning: variant is never constructed: `R`
 --> src/main.rs:4:5
  |
4 |     R,
  |     ^

ジャッジ結果