Added nuriloop (#235)

* Added nuriloop

* Forgot some constraints

* Parity optimization

Author: ReverM

cspuz_rs_puzzles/src/puzzles/mod.rs

@@ -102,6 +102,7 @@ pub mod nothing;
 pub mod nothree;
 pub mod numcity;
 pub mod nurikabe;
+pub mod nuriloop;
 pub mod nurimaze;
 pub mod nurimisaki;
 pub mod nuritwin;

cspuz_rs_puzzles/src/puzzles/nuriloop.rs

@@ -0,0 +1,137 @@
+use crate::util;
+use cspuz_rs::graph;
+use cspuz_rs::serializer::{
+    problem_to_url_pzprxs, url_to_problem, Choice, Combinator, Dict, Grid, HexInt, Optionalize,
+    Spaces,
+};
+use cspuz_rs::solver::Solver;
+
+pub fn solve_nuriloop(clues: &[Vec<Option<i32>>]) -> Option<graph::BoolGridEdgesIrrefutableFacts> {
+    let (h, w) = util::infer_shape(clues);
+
+    let mut solver = Solver::new();
+    let is_line = &graph::BoolGridEdges::new(&mut solver, (h - 1, w - 1));
+    solver.add_answer_key_bool(&is_line.horizontal);
+    solver.add_answer_key_bool(&is_line.vertical);
+    let is_passed = &graph::single_cycle_grid_edges(&mut solver, is_line);
+
+    let mut has_question_mark = false;
+    let mut sum = 0;
+
+    let mut clue_pos = vec![];
+    for y in 0..h {
+        for x in 0..w {
+            if let Some(n) = clues[y][x] {
+                if n < 0 {
+                    has_question_mark = true;
+                }
+                sum += n;
+                clue_pos.push((y, x, n));
+            }
+        }
+    }
+
+    // Parity check
+    if !has_question_mark && (h as i32 * w as i32 - sum) % 2 != 0 {
+        return None;
+    }
+
+    let group_id = solver.int_var_2d((h, w), 0, clue_pos.len() as i32);
+
+    solver.add_expr(is_passed.iff(group_id.eq(0)));
+
+    for i in 1..=clue_pos.len() {
+        graph::active_vertices_connected_2d(&mut solver, group_id.eq(i as i32));
+    }
+
+    solver.add_expr(
+        (!is_passed.conv2d_or((2, 1))).imp(
+            group_id
+                .slice((..(h - 1), ..))
+                .eq(group_id.slice((1.., ..))),
+        ),
+    );
+    solver.add_expr(
+        (!is_passed.conv2d_or((1, 2))).imp(
+            group_id
+                .slice((.., ..(w - 1)))
+                .eq(group_id.slice((.., 1..))),
+        ),
+    );
+
+    for (i, &(y, x, n)) in clue_pos.iter().enumerate() {
+        solver.add_expr(group_id.at((y, x)).eq((i + 1) as i32));
+        if n > 0 {
+            solver.add_expr(group_id.eq((i + 1) as i32).count_true().eq(n));
+        }
+    }
+
+    solver.irrefutable_facts().map(|f| f.get(is_line))
+}
+
+type Problem = Vec<Vec<Option<i32>>>;
+
+fn combinator() -> impl Combinator<Problem> {
+    Grid::new(Choice::new(vec![
+        Box::new(Optionalize::new(HexInt)),
+        Box::new(Spaces::new(None, 'g')),
+        Box::new(Dict::new(Some(-1), ".")),
+    ]))
+}
+
+pub fn serialize_problem(problem: &Problem) -> Option<String> {
+    problem_to_url_pzprxs(combinator(), "nuriloop", problem.clone())
+}
+
+pub fn deserialize_problem(url: &str) -> Option<Problem> {
+    url_to_problem(combinator(), &["nuriloop"], url)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn problem_for_tests() -> Problem {
+        vec![
+            vec![Some(4), None, None, None, None],
+            vec![None, None, None, Some(2), None],
+            vec![None, None, None, None, None],
+            vec![None, Some(1), None, None, None],
+            vec![None, None, None, None, None],
+        ]
+    }
+
+    #[test]
+    fn test_nuriloop_problem() {
+        let problem = problem_for_tests();
+        let ans = solve_nuriloop(&problem);
+        assert!(ans.is_some());
+        let ans = ans.unwrap();
+
+        let expected_edges = graph::GridEdges {
+            horizontal: crate::util::tests::to_option_bool_2d([
+                [0, 0, 1, 1],
+                [0, 0, 0, 0],
+                [1, 1, 0, 0],
+                [0, 0, 1, 0],
+                [1, 1, 0, 1],
+            ]),
+            vertical: crate::util::tests::to_option_bool_2d([
+                [0, 0, 1, 0, 1],
+                [0, 0, 1, 0, 1],
+                [1, 0, 0, 0, 1],
+                [1, 0, 1, 1, 1],
+            ]),
+        };
+        assert_eq!(ans, expected_edges);
+    }
+
+    #[test]
+    fn test_nurilooop_serializer() {
+        {
+            let problem = problem_for_tests();
+            let url = "https://pzprxs.vercel.app/p?nuriloop/5/5/4m2m1n";
+            util::tests::serializer_test(problem, url, serialize_problem, deserialize_problem);
+        }
+    }
+}

cspuz_solver_backend/src/puzzle/mod.rs

@@ -176,6 +176,7 @@ puzzle_list!(puzz_link,
     (nothree, ["nothree"], "No Three", "ノースリー"),
     (numcity, ["numcity"], "Number City", "ナンバーシティー"),
     (nurikabe, ["nurikabe"], "Nurikabe", "ぬりかべ", enumerable),
+    (nuriloop, ["nuriloop"], "Nurikabe Loop", "面積リンク"),
     (nurimaze, ["nurimaze"], "Nurimaze", "ぬりめいず"),
     (nurimisaki, ["nurimisaki"], "Nurimisaki", "ぬりみさき"),
     (nuritwin, ["nuritwin"], "Nuritwin", "ぬりツイン"),

cspuz_solver_backend/src/puzzle/nuriloop.rs

@@ -0,0 +1,89 @@
+use crate::board::{Board, BoardKind, Item, ItemKind};
+use crate::uniqueness::check_uniqueness;
+use cspuz_rs_puzzles::puzzles::nuriloop;
+
+pub fn solve(url: &str) -> Result<Board, &'static str> {
+    let problem = nuriloop::deserialize_problem(url).ok_or("invalid url")?;
+    let ans = nuriloop::solve_nuriloop(&problem);
+
+    let height = problem.len();
+    let width = problem[0].len();
+    let mut board = Board::new(BoardKind::Grid, height, width, check_uniqueness(&ans));
+
+    if let Some(is_line) = &ans {
+        for y in 0..height {
+            for x in 0..width {
+                if let Some(clue) = problem[y][x] {
+                    board.push(Item::cell(
+                        y,
+                        x,
+                        "black",
+                        if clue >= 0 {
+                            ItemKind::Num(clue)
+                        } else {
+                            ItemKind::Text("?")
+                        },
+                    ));
+                }
+            }
+        }
+
+        board.add_lines_irrefutable_facts(is_line, "green", None);
+    } else {
+        for y in 0..height {
+            for x in 0..width {
+                if let Some(clue) = problem[y][x] {
+                    board.push(Item::cell(
+                        y,
+                        x,
+                        "black",
+                        if clue >= 0 {
+                            ItemKind::Num(clue)
+                        } else {
+                            ItemKind::Text("?")
+                        },
+                    ));
+                }
+            }
+        }
+    }
+
+    Ok(board)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::solve;
+    use crate::board::*;
+    use crate::compare_board_and_check_no_solution_case;
+    use crate::uniqueness::Uniqueness;
+
+    #[test]
+    #[rustfmt::skip]
+    fn test_solve() {
+        compare_board_and_check_no_solution_case!(
+            solve("https://pzprxs.vercel.app/p?nuriloop/3/3/l1h"),
+            Board {
+                kind: BoardKind::Grid,
+                height: 3,
+                width: 3,
+                data: vec![
+                    Item { y: 5, x: 1, color: "black", kind: ItemKind::Num(1) },
+                    Item { y: 2, x: 1, color: "green", kind: ItemKind::Line },
+                    Item { y: 2, x: 3, color: "green", kind: ItemKind::Cross },
+                    Item { y: 2, x: 5, color: "green", kind: ItemKind::Line },
+                    Item { y: 4, x: 1, color: "green", kind: ItemKind::Cross },
+                    Item { y: 4, x: 3, color: "green", kind: ItemKind::Line },
+                    Item { y: 4, x: 5, color: "green", kind: ItemKind::Line },
+                    Item { y: 1, x: 2, color: "green", kind: ItemKind::Line },
+                    Item { y: 1, x: 4, color: "green", kind: ItemKind::Line },
+                    Item { y: 3, x: 2, color: "green", kind: ItemKind::Line },
+                    Item { y: 3, x: 4, color: "green", kind: ItemKind::Cross },
+                    Item { y: 5, x: 2, color: "green", kind: ItemKind::Cross },
+                    Item { y: 5, x: 4, color: "green", kind: ItemKind::Line },
+                    ],
+                uniqueness: Uniqueness::Unique,
+            },
+        );
+    }
+}