백준 14503 - 로봇 청소기

주어진 규칙에 따라 시뮬레이션하는 문제입니다.

현재 위치와 방향을 관리하면서 회전을 처리하는 것이 중요하다고 생각합니다.

한편 규칙이 어느 정도 혼란을 줄 수 있게 서술되어 있는 것 같아 주의가 필요해 보입니다.

코드

use std::io::{stdin, Read};

fn main() {
    let mut input = String::new();
    stdin().read_to_string(&mut input).unwrap();
    let mut input = input.split_ascii_whitespace().map(str::parse).flatten();
    let n = input.next().unwrap();
    let m = input.next().unwrap();
    let mut r = input.next().unwrap();
    let mut c = input.next().unwrap();
    let d = input.next().unwrap();
    let mut grid = Matrix(input.take(n * m).collect(), m);
    let (mut dr, mut dc): (usize, usize) = match d {
        0 => (!0, 0),
        1 => (0, 1),
        2 => (1, 0),
        _ => (0, !0),
    };
    loop {
        grid[r][c] = 2;
        let mut found = false;
        for _ in 0..4 {
            let tmp = dr;
            dr = dc.wrapping_neg();
            dc = tmp;
            let sr = r.wrapping_add(dr);
            let sc = c.wrapping_add(dc);
            if grid[sr][sc] == 0 {
                r = sr;
                c = sc;
                found = true;
                break;
            }
        }
        if !found {
            let br = r.wrapping_sub(dr);
            let bc = c.wrapping_sub(dc);
            if grid[br][bc] == 1 {
                break;
            }
            r = br;
            c = bc;
        }
    }
    println!("{}", grid.0.iter().filter(|&&x| x == 2).count());
}

struct Matrix<T>(Vec<T>, usize);

impl<T> std::ops::Index<usize> for Matrix<T> {
    type Output = [T];
    fn index(&self, index: usize) -> &Self::Output {
        &self.0[index * self.1..][..self.1]
    }
}

impl<T> std::ops::IndexMut<usize> for Matrix<T> {
    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
        &mut self.0[index * self.1..][..self.1]
    }
}