Use hand:

src/bin/score.rs

@@ -46,14 +46,14 @@ fn score_small(task: Task, output_len: usize) -> ScoreInfo {
    let mut passed = Matrix::new(width as usize, height as usize, true);
    let mut valid = Matrix::new(width as usize, height as usize, false);

    for p in &map_points {
    for &p in &map_points {
        passed.set(p, false);
        valid.set(p, true);
        remaining += 1;
    }

    for o in &task.obstacles {
        for p in o.enumerate_points().iter() {
        for &p in o.enumerate_points().iter() {
            if let Some(true) = valid.get(p) {
                valid.set(p, false);
                passed.set(p, true);

src/models.rs

@@ -13,6 +13,10 @@ impl Point {
        Point { x, y }
    }

    pub fn add(&self, p: &Point) -> Point {
        Point::new(self.x + p.x, self.y + p.y)
    }

    pub fn move_with(&self, command: Command) -> Point {
        let (x, y) = (self.x, self.y);
        match command {

src/solve.rs

@@ -19,14 +19,14 @@ pub fn solve_small(task: Task) -> Vec<Command> {
    let mut passed = Matrix::new(width, height, true);
    let mut valid = Matrix::new(width, height, false);

    for p in &map_points {
    for &p in &map_points {
        passed.set(p, false);
        valid.set(p, true);
        remaining += 1;
    }

    for o in &task.obstacles {
        for p in o.enumerate_points().iter() {
        for &p in o.enumerate_points().iter() {
            if let Some(true) = valid.get(p) {
                valid.set(p, false);
                passed.set(p, true);
@@ -43,25 +43,45 @@ pub fn solve_small(task: Task) -> Vec<Command> {
    ];
    let mut res = Vec::new();
    let mut cp = task.initial;
    if !passed.get(&cp).unwrap() {
        passed.set(&cp, true);
    if !passed.get(cp).unwrap() {
        passed.set(cp, true);
        remaining -= 1;
    }
    let bodies_diff = vec![
        Point::new(0, 0),
        Point::new(1, 1),
        Point::new(1, 0),
        Point::new(1, -1),
    ];
    while remaining > 0 {
        let mut data = Matrix::new(width, height, None);
        let mut queue = VecDeque::new();
        queue.push_back(cp);
        data.set(&cp, Some(Command::Noop));
        data.set(cp, Some(Command::Noop));
        let mut reached = false;
        while let Some(c) = queue.pop_front() {
            if !passed.get(&c).unwrap() {
                passed.set(&c, true);
                remaining -= 1;
            let bodies = bodies_diff
                .iter()
                .map(|diff| c.add(diff))
                .collect::<Vec<_>>();
            let not_passed = bodies.iter().any(|p| {
                if let Some(false) = passed.get(*p) {
                    true
                } else {
                    false
                }
            });
            if not_passed {
                for body in bodies {
                    if let Some(false) = passed.try_set(body, true) {
                        remaining -= 1;
                    }
                }

                let mut local_cmds = Vec::new();
                let mut iter = c;
                while iter != cp {
                    let cmd = data.get(&iter).unwrap().unwrap();
                    let cmd = data.get(iter).unwrap().unwrap();
                    local_cmds.push(cmd);
                    iter = iter.revert_with(cmd);
                }
@@ -75,9 +95,9 @@ pub fn solve_small(task: Task) -> Vec<Command> {
            moves.shuffle(&mut rng);
            for m in &moves {
                let nc = c.move_with(*m);
                if let Some(None) = data.get(&nc) {
                    if let Some(true) = valid.get(&nc) {
                        data.set(&nc, Some(*m));
                if let Some(None) = data.get(nc) {
                    if let Some(true) = valid.get(nc) {
                        data.set(nc, Some(*m));
                        queue.push_back(nc);
                    }
                }

src/utils.rs

@@ -16,23 +16,33 @@ impl<T: Copy> Matrix<T> {
        }
    }

    pub fn get(&self, p: &Point) -> Option<T> {
    pub fn get(&self, p: Point) -> Option<T> {
        if p.x >= 0 && p.y >= 0 && (p.x as usize) < self.width && (p.y as usize) < self.height {
            Some(self.inner[p.y as usize * self.width + p.x as usize])
        } else {
            None
        }
    }

    pub fn get_mut(&mut self, p: &Point) -> Option<&mut T> {
    pub fn get_mut(&mut self, p: Point) -> Option<&mut T> {
        if p.x >= 0 && p.y >= 0 && (p.x as usize) < self.width && (p.y as usize) < self.height {
            Some(&mut self.inner[p.y as usize * self.width + p.x as usize])
        } else {
            None
        }
    }

    pub fn set(&mut self, p: &Point, value: T) {
    pub fn try_set(&mut self, p: Point, value: T) -> Option<T> {
        if let Some(r) = self.get_mut(p) {
            let old = *r;
            *r = value;
            Some(old)
        } else {
            None
        }
    }

    pub fn set(&mut self, p: Point, value: T) {
        if let Some(r) = self.get_mut(p) {
            *r = value;
        } else {