結果
問題 | No.8063 幅優先探索 |
ユーザー | くれちー |
提出日時 | 2020-04-01 21:56:22 |
言語 | Rust (1.83.0 + proconio) |
結果 |
CE
(最新)
AC
(最初)
|
実行時間 | - |
コード長 | 13,959 bytes |
コンパイル時間 | 12,075 ms |
コンパイル使用メモリ | 387,080 KB |
最終ジャッジ日時 | 2024-11-14 22:15:51 |
合計ジャッジ時間 | 12,709 ms |
ジャッジサーバーID (参考情報) |
judge5 / judge1 |
(要ログイン)
コンパイルエラー時のメッセージ・ソースコードは、提出者また管理者しか表示できないようにしております。(リジャッジ後のコンパイルエラーは公開されます)
ただし、clay言語の場合は開発者のデバッグのため、公開されます。
ただし、clay言語の場合は開発者のデバッグのため、公開されます。
コンパイルメッセージ
error[E0433]: failed to resolve: use of undeclared crate or module `spella` --> src/main.rs:402:11 | 402 | pub use spella::byte::{ByteChar, ByteStr, ByteString}; | ^^^^^^ use of undeclared crate or module `spella` error[E0433]: failed to resolve: use of undeclared crate or module `spella` --> src/main.rs:32:11 | 32 | use spella::byte::{ByteChar, ByteString}; | ^^^^^^ use of undeclared crate or module `spella` error[E0433]: failed to resolve: use of undeclared crate or module `spella` --> src/main.rs:128:11 | 128 | use spella::byte::{ByteChar, ByteStr}; | ^^^^^^ use of undeclared crate or module `spella` error[E0433]: failed to resolve: use of undeclared crate or module `spella` --> src/main.rs:197:11 | 197 | use spella::byte::{ByteChar, ByteStr, ByteString}; | ^^^^^^ use of undeclared crate or module `spella` error[E0433]: failed to resolve: use of undeclared crate or module `spella` --> src/main.rs:336:11 | 336 | use spella::byte::{ByteStr, FromByteStr}; | ^^^^^^ use of undeclared crate or module `spella` warning: unused import: `std::iter::FromIterator` --> src/main.rs:405:11 | 405 | pub use std::iter::FromIterator; | ^^^^^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` on by default warning: unused import: `std::marker::PhantomData` --> src/main.rs:406:11 | 406 | pub use std::marker::PhantomData; | ^^^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `std::num::Wrapping` --> src/main.rs:407:11 | 407 | pub use std::num::Wrapping; | ^^^^^^^^^^^^^^^^^^ warning: unused imports: `RangeFrom`, `RangeTo`, `Range` --> src/main.rs:408:22 | 408 | pub use std::ops::{Range, RangeFrom, RangeTo}; | ^^^^^ ^^^^^^^^^ ^^^^^^^ warning: unused imports: `cell`, `cmp`, `f64`, `i32`, `i64`, `iter`, `mem`, `rc`, `str`, `time`, `u32`, `u64`
ソースコード
// The main code is at the very bottom.#[allow(unused_imports)]#[macro_use]pub mod spella {pub mod byte {pub use self::byte_char::*;pub use self::byte_str::*;pub use self::byte_string::*;pub use self::from_byte_str::*;mod byte_char {use std::fmt::{self, Debug, Display, Formatter};#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]pub struct ByteChar(pub u8);impl Debug for ByteChar {fn fmt(&self, f: &mut Formatter) -> fmt::Result {write!(f, "b'{}'", self.0 as char)}}impl Display for ByteChar {fn fmt(&self, f: &mut Formatter) -> fmt::Result {write!(f, "{}", self.0 as char)}}}mod byte_str {use spella::byte::{ByteChar, ByteString};use std::fmt::{self, Debug, Display, Formatter};use std::ops::{Deref, DerefMut};#[derive(PartialEq, Eq, PartialOrd, Ord, Hash)]pub struct ByteStr([ByteChar]);macro_rules! cast {(mut $x:expr, $($T:ty)=>*) => {unsafe { &mut *($x $(as *mut $T)*) }};($x:expr, $($T:ty)=>*) => {unsafe { &*($x $(as *const $T)*) }};}impl ByteStr {pub fn from_bytes(s: &[u8]) -> &Self {cast!(s, [u8] => [ByteChar] => ByteStr)}pub fn from_bytes_mut(s: &mut [u8]) -> &mut Self {cast!(mut s, [u8] => [ByteChar] => ByteStr)}pub fn from_byte_chars(s: &[ByteChar]) -> &Self {cast!(s, [ByteChar] => ByteStr)}pub fn from_byte_chars_mut(s: &mut [ByteChar]) -> &mut Self {cast!(mut s, [ByteChar] => ByteStr)}pub fn as_byte_chars(&self) -> &[ByteChar] {&self.0}pub fn as_byte_chars_mut(&mut self) -> &mut [ByteChar] {&mut self.0}pub fn as_bytes(&self) -> &[u8] {cast!(self, ByteStr => [ByteChar] => [u8])}pub fn as_bytes_mut(&mut self) -> &mut [u8] {cast!(mut self, ByteStr => [ByteChar] => [u8])}}impl ToOwned for ByteStr {type Owned = ByteString;fn to_owned(&self) -> ByteString {ByteString::from(self.0.to_owned())}}impl Debug for ByteStr {fn fmt(&self, f: &mut Formatter) -> fmt::Result {write!(f, "b\"")?;for &c in &self.0 {write!(f, "{}", c)?;}write!(f, "\"")}}impl Display for ByteStr {fn fmt(&self, f: &mut Formatter) -> fmt::Result {for &c in &self.0 {write!(f, "{}", c)?;}Ok(())}}impl Deref for ByteStr {type Target = [ByteChar];fn deref(&self) -> &[ByteChar] {self.as_byte_chars()}}impl DerefMut for ByteStr {fn deref_mut(&mut self) -> &mut [ByteChar] {self.as_byte_chars_mut()}}}mod byte_string {use spella::byte::{ByteChar, ByteStr};use std::borrow::{Borrow, BorrowMut};use std::fmt::{self, Debug, Display, Formatter};use std::ops::{Deref, DerefMut};#[derive(Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]pub struct ByteString(Vec<ByteChar>);impl ByteString {pub fn into_byte_chars(self) -> Vec<ByteChar> {self.0}pub fn as_byte_str(&self) -> &ByteStr {ByteStr::from_byte_chars(&self.0)}pub fn as_mut_byte_str(&mut self) -> &mut ByteStr {ByteStr::from_byte_chars_mut(&mut self.0)}}impl From<Vec<ByteChar>> for ByteString {fn from(s: Vec<ByteChar>) -> ByteString {ByteString(s)}}impl Borrow<ByteStr> for ByteString {fn borrow(&self) -> &ByteStr {self.as_byte_str()}}impl BorrowMut<ByteStr> for ByteString {fn borrow_mut(&mut self) -> &mut ByteStr {self.as_mut_byte_str()}}impl Debug for ByteString {fn fmt(&self, f: &mut Formatter) -> fmt::Result {Debug::fmt(self.as_byte_str(), f)}}impl Display for ByteString {fn fmt(&self, f: &mut Formatter) -> fmt::Result {Display::fmt(self.as_byte_str(), f)}}impl Deref for ByteString {type Target = ByteStr;fn deref(&self) -> &ByteStr {ByteStr::from_byte_chars(&self.0)}}impl DerefMut for ByteString {fn deref_mut(&mut self) -> &mut ByteStr {ByteStr::from_byte_chars_mut(&mut self.0)}}}mod from_byte_str {use spella::byte::{ByteChar, ByteStr, ByteString};use std::error::Error;use std::fmt::{self, Debug, Display, Formatter};use std::str::{self, FromStr, Utf8Error};pub trait FromByteStr: Sized {type Err;fn from_byte_str(s: &ByteStr) -> Result<Self, Self::Err>;}macro_rules! fn_description {() => {fn description(&self) -> &str {"description() is deprecated; use Display"}};}#[derive(Debug)]pub struct ParseByteCharError(ParseByteCharErrorKind);#[derive(Debug)]enum ParseByteCharErrorKind {EmptyByteStr,TooManyByteChars,}impl Display for ParseByteCharError {fn fmt(&self, f: &mut Formatter) -> fmt::Result {use self::ParseByteCharErrorKind::*;f.write_str(match self.0 {EmptyByteStr => "empty `ByteStr`",TooManyByteChars => "too many `ByteChar`s",})}}impl Error for ParseByteCharError {fn_description! {}}impl FromByteStr for ByteChar {type Err = ParseByteCharError;fn from_byte_str(s: &ByteStr) -> Result<Self, Self::Err> {use self::ParseByteCharErrorKind::*;match s.len() {1 => Ok(unsafe { *s.get_unchecked(0) }),0 => Err(ParseByteCharError(EmptyByteStr)),_ => Err(ParseByteCharError(TooManyByteChars)),}}}#[derive(Debug)]pub enum ParseByteStringError {}impl Display for ParseByteStringError {fn fmt(&self, _: &mut Formatter) -> fmt::Result {match *self {}}}impl Error for ParseByteStringError {fn_description! {}}impl FromByteStr for ByteString {type Err = ParseByteStringError;fn from_byte_str(s: &ByteStr) -> Result<Self, Self::Err> {Ok(ByteString::from(s.to_vec()))}}pub struct ParseFromStrError<T: FromStr>(ParseFromStrErrorKind<T>);enum ParseFromStrErrorKind<T: FromStr> {Utf8Error(Utf8Error),FromStrError(T::Err),}impl<T: FromStr> Debug for ParseFromStrError<T>whereT::Err: Debug,{fn fmt(&self, f: &mut Formatter) -> fmt::Result {use self::ParseFromStrErrorKind::*;match self.0 {Utf8Error(ref err) => f.debug_tuple("Utf8Error").field(err).finish(),FromStrError(ref err) => f.debug_tuple("FromStrError").field(err).finish(),}}}impl<T: FromStr> Display for ParseFromStrError<T>whereT::Err: Display,{fn fmt(&self, f: &mut Formatter) -> fmt::Result {use self::ParseFromStrErrorKind::*;match self.0 {Utf8Error(ref err) => write!(f, "{}", err),FromStrError(ref err) => write!(f, "{}", err),}}}impl<T: FromStr> Error for ParseFromStrError<T>whereT::Err: Debug + Display,{fn_description! {}}impl<T: FromStr> FromByteStr for T {type Err = ParseFromStrError<T>;fn from_byte_str(s: &ByteStr) -> Result<T, Self::Err> {use self::ParseFromStrErrorKind::*;str::from_utf8(s.as_bytes()).map_err(|e| ParseFromStrError(Utf8Error(e))).and_then(|s| s.parse().map_err(|e| ParseFromStrError(FromStrError(e))))}}}}pub mod io {pub use self::scanner::*;mod scanner {use spella::byte::{ByteStr, FromByteStr};use std::io::{self, BufRead};#[derive(Debug)]pub struct Scanner<R> {reader: R,buf: Vec<u8>,pos: usize,}const INITIAL_CAPACITY: usize = 32;impl<R: BufRead> Scanner<R> {pub fn new(reader: R) -> Self {Scanner {reader: reader,buf: Vec::with_capacity(INITIAL_CAPACITY),pos: 0,}}pub fn next<T: FromByteStr>(&mut self) -> io::Result<Result<T, T::Err>> {self.next_byte_str().map(T::from_byte_str)}pub fn next_byte_str(&mut self) -> io::Result<&ByteStr> {if self.buf.is_empty() {self.read_line()?;}loop {match self.buf.get(self.pos) {Some(&b' ') => self.pos += 1,Some(&b'\n') => self.read_line()?,Some(_) => break,None => return Err(io::Error::from(io::ErrorKind::UnexpectedEof)),}}let start = self.pos;self.pos += 1;loop {match self.buf.get(self.pos) {Some(&b' ') | Some(&b'\n') | None => break,Some(_) => self.pos += 1,}}Ok(ByteStr::from_bytes(&self.buf[start..self.pos]))}fn read_line(&mut self) -> io::Result<()> {self.buf.clear();self.pos = 0;self.reader.read_until(b'\n', &mut self.buf)?;Ok(())}}}}}mod prelude {pub use spella::byte::{ByteChar, ByteStr, ByteString};pub use std::collections::*;pub use std::io::prelude::*;pub use std::iter::FromIterator;pub use std::marker::PhantomData;pub use std::num::Wrapping;pub use std::ops::{Range, RangeFrom, RangeTo};pub use std::{cell, cmp, f64, i32, i64, isize, iter, mem, rc, str, time, u32, u64, usize};}use prelude::*;const CUSTOM_STACK_SIZE_MEBIBYTES: Option<usize> = None;fn main() {fn exec_solver() {let stdin = std::io::stdin();let stdout = std::io::stdout();#[cfg(not(debug_assertions))]let mut writer = std::io::BufWriter::new(stdout.lock());#[cfg(debug_assertions)]let mut writer = stdout.lock();solve(stdin.lock(), &mut writer);writer.flush().unwrap();}if let Some(stack_size_mebibytes) = CUSTOM_STACK_SIZE_MEBIBYTES {std::thread::Builder::new().name("exec_solver".to_owned()).stack_size(stack_size_mebibytes * 1024 * 1024).spawn(exec_solver).unwrap().join().unwrap();} else {exec_solver();}}fn solve<R: BufRead, W: Write>(reader: R, mut writer: W) {let mut _scanner = spella::io::Scanner::new(reader);#[allow(unused_macros)]macro_rules! scan {($T:ty) => {_scanner.next::<$T>().unwrap().unwrap()};($($T:ty),+) => {($(scan!($T)),+)};($($T:ty),+; $n:expr $(; $m:expr)*) => {{(0..$n).map(|_| scan!($($T),+ $(; $m)*)).collect::<Vec<_>>()}};}#[allow(unused_macros)]macro_rules! scan_iter {($($T:ty),+; $n:expr) => {(0..$n).map(|_| scan!($($T),+))};}#[allow(unused_macros)]macro_rules! print {($fmt:expr) => {write!(writer, $fmt).unwrap()};($fmt:expr, $($arg:tt)*) => {write!(writer, $fmt, $($arg)*).unwrap()};}#[allow(unused_macros)]macro_rules! println {($fmt:expr) => {writeln!(writer, $fmt).unwrap()};($fmt:expr, $($arg:tt)*) => {writeln!(writer, $fmt, $($arg)*).unwrap()};}#[allow(unused_macros)]macro_rules! eprint {($fmt:expr) => {#[cfg(debug_assertions)]write!(std::io::stderr(), $fmt).unwrap()};($fmt:expr, $($arg:tt)*) => {#[cfg(debug_assertions)]write!(std::io::stderr(), $fmt, $($arg)*).unwrap()};}#[allow(unused_macros)]macro_rules! eprintln {($fmt:expr) => {#[cfg(debug_assertions)]writeln!(std::io::stderr(), $fmt).unwrap()};($fmt:expr, $($arg:tt)*) => {#[cfg(debug_assertions)]writeln!(std::io::stderr(), $fmt, $($arg)*).unwrap()};}#[allow(unused_macros)]macro_rules! dbg {($($x:expr),+) => {{eprintln!(concat!("[{}:{}] ", $(stringify!($x), " = {:?}; "),+), file!(), line!(), $($x),+);}};}let (r, c) = scan!(usize, usize);let (sy, sx) = scan!(usize, usize);let (sy, sx) = (sy - 1, sx - 1);let (gy, gx) = scan!(usize, usize);let (gy, gx) = (gy - 1, gx - 1);let g = scan_iter!(ByteString; r).map(|g_i| {g_i.into_iter().map(|g_i_j| g_i_j.0 == b'.').collect::<Vec<_>>()}).collect::<Vec<_>>();let mut queue = VecDeque::new();queue.push_back((sy as isize, sx as isize, 0));let mut visited = vec![vec![false; c]; r];visited[sy][sx] = true;while let Some((y, x, n)) = queue.pop_front() {if (y, x) == (gy as isize, gx as isize) {println!("{}", n);return;}const DX: [isize; 4] = [-1, 0, 1, 0];const DY: [isize; 4] = [0, -1, 0, 1];for i in 0..4 {let y = y + DY[i];let x = x + DX[i];if 0 <= y&& y < r as isize&& 0 <= x&& x < c as isize&& !visited[y as usize][x as usize]// && g[y as usize][x as usize]{queue.push_back((y, x, n + 1));visited[y as usize][x as usize] = true;}}}}