Ratsun reitit

use std::io::{BufRead, BufReader};
 
fn pretty_print_matrix(m: Vec<Vec<Option<i32>>>) -> String {
    m.iter()
        .map(|v|{
            v.iter()
                .map(|i|{
                    match i {
                        None => "X".to_string(),
                        Some(i) => i.to_string(),
                    }
                })
            .fold("".to_string(), |acc, el| {
                match acc.len() {
                    0 => el,
                    _ => format!("{} {}", acc, el)
                }
            })
        })
    .fold("".to_string(), |acc,el| { 
        match acc.len() {
            0 => el,
            _ => format!("{}{}{}", acc, '\n', el)
        }
    })
}
 
#[derive(PartialEq, Copy, Clone, Debug)]
struct Move(i32, i32);
impl Eq for Move {}
 
fn chained_comp(b: i32,v: i32,a: i32) -> bool {
    b < v && v < a
}
 
fn recurse_knight_moves(
        board: &mut Vec<Vec<Option<i32>>>,
        pos: Move,
        depth: i32,
        note: &mut Vec<Move>) {
    if note.contains(&pos) {
        return ();
    }
    let mut moves = vec![
        Move(-2,-1),
        Move(-1,-2),
        Move(1,-2),
        Move(2, -1),
        Move(2,1),
        Move(1,2),
        Move(-1,2),
        Move(-2,1),
    ];
    let bsize = board.len() as i32;
    moves = moves.iter()
        .map(|t|{Move(t.0+pos.0, t.1+pos.1)}) 
        .filter(|t|{chained_comp(-1,t.0,bsize) && chained_comp(-1,t.1,bsize)})
        // // .filter(|t|{!note.contains(t)})
        .collect::<Vec<Move>>();
    let mut done = Vec::new();
    for t in moves {
        let v = board[t.0 as usize][t.1 as usize];
        if v.unwrap_or(9999) > depth {
            board[t.0 as usize][t.1 as usize] = Some(depth);
            done.push(t)
        }
    }
    // println!("{}\n",pretty_print_matrix(board.clone()));
    note.push(pos);
    for t in done {
        recurse_knight_moves(board, t, depth+1, note); 
    }        
}
 
fn main() {
    let mut input = BufReader::new(std::io::stdin());
    let mut line = "".to_string();
    input.read_line(&mut line).unwrap();
    line.pop();
    let n: i32 = line.parse().unwrap();
    let mut board = Vec::new();
    for _ in 0..n {
        let mut tmp = Vec::new();
        for _ in 0..n {
            tmp.push(None)
        }
        board.push(tmp)
    }
    board[0][0] = Some(0);
    let mut note = Vec::new();
 
    recurse_knight_moves(&mut board,Move(0,0),1,&mut note);
    println!("{}",pretty_print_matrix(board));
}

Test 1

Group: 1, 2, 3

Verdict: ACCEPTED

Test 2

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 3

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 4

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 5

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 6

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 7

Group: 1, 2, 3

Verdict: WRONG ANSWER

Test 8

Group: 2, 3

Verdict: WRONG ANSWER

Test 9

Group: 2, 3

Verdict: WRONG ANSWER

Test 10

Group: 2, 3

Verdict: WRONG ANSWER

Test 11

Group: 3

Verdict: WRONG ANSWER

Test 12

Group: 3

Verdict: WRONG ANSWER

Test 13

Group: 3

Verdict: WRONG ANSWER