From 24651fdc615889810018c6cc70ce96c7452d6423 Mon Sep 17 00:00:00 2001 From: Qiuyang Mang Date: Fri, 5 Jun 2026 12:25:33 -0400 Subject: [PATCH] Clarify and rescore Number Loop construction --- algorithmic/problems/145/checker.cpp | 77 ++++++++++++++------- algorithmic/problems/145/statement.txt | 95 ++++++++++++++++++++------ 2 files changed, 126 insertions(+), 46 deletions(-) diff --git a/algorithmic/problems/145/checker.cpp b/algorithmic/problems/145/checker.cpp index 6b779f4c6..0843fbb48 100644 --- a/algorithmic/problems/145/checker.cpp +++ b/algorithmic/problems/145/checker.cpp @@ -26,6 +26,38 @@ const vector M = { string valid_char; vector grid; +int clue_cell_count(){ + int total = 0; + for(const string &row : M) { + for(char c : row) { + if(c == '?') total++; + } + } + return total; +} + +int count_ones(){ + int total = 0; + for(const string &row : grid) { + for(char c : row) { + if(c == '1') total++; + } + } + return total; +} + +double score_percent(int solution_count){ + if(solution_count <= 0) return 0.0; + + const double u = (double)count_ones() / (double)clue_cell_count(); + if(solution_count >= 6) return 1.0 + 9.0 * u; + if(solution_count == 5) return 10.0 + 10.0 * u; + if(solution_count == 4) return 20.0 + 10.0 * u; + if(solution_count == 3) return 30.0 + 10.0 * u; + if(solution_count == 2) return 40.0 + 10.0 * u; + return 50.0 + 50.0 * u; +} + // helper printing to stderr (like original) void eprint(const string &s){ cerr << s << "\n"; } void myAssert(bool cond, const string &msg){ @@ -531,38 +563,35 @@ int main(int argc, char **argv){ quitp(0.0, "There is no valid solution"); } - // enumerate solutions, stop when 5 found (>=5 -> 0 points) + // Enumerate solutions, stopping once the score bucket is known. sol_list.clear(); sol_set.clear(); - const int LIMIT = 5; + const int LIMIT = 6; try_search(LIMIT); int cnt = (int)sol_list.size(); if(cnt == 0){ quitp(0.0, "There is no valid solution"); - } else if(cnt == 1){ - // unique -> 100% - // print solution to stderr - print_solution_to_stderr(sol_list[0].first, sol_list[0].second); - quitp(1.0, "Ratio: 1.0 Correct! unique solution"); - } else if(cnt == 2){ - for(int k=0;k<2;k++) print_solution_to_stderr(sol_list[k].first, sol_list[k].second); - quitp(0.80, "Ratio: 0.8 Two valid solutions"); - } else if(cnt == 3){ - for(int k=0;k<3;k++) print_solution_to_stderr(sol_list[k].first, sol_list[k].second); - quitp(0.60, "Ratio: 0.6 Three valid solutions"); - } else if(cnt == 4){ - for(int k=0;k<4;k++) print_solution_to_stderr(sol_list[k].first, sol_list[k].second); - quitp(0.40, "Ratio: 0.4 Four valid solutions"); - } else if(cnt == 5){ - for(int k=0;k<5;k++) print_solution_to_stderr(sol_list[k].first, sol_list[k].second); - quitp(0.20, "Ratio: 0.2 Five valid solutions"); - } else { - // >=5 - for(int k=0;k< (int)min((size_t)6, sol_list.size()); ++k) print_solution_to_stderr(sol_list[k].first, sol_list[k].second); - quitp(0.0, "Ratio: 0.0 Six or more valid solutions (or too many)"); } + + for(int k=0;k< (int)min((size_t)6, sol_list.size()); ++k) { + print_solution_to_stderr(sol_list[k].first, sol_list[k].second); + } + + const int ones = count_ones(); + const int clues = clue_cell_count(); + const double score = score_percent(cnt); + const string count_label = cnt >= 6 ? "six or more" : to_string(cnt); + quitp( + score / 100.0, + "Ratio: %.10f RatioUnbounded: %.10f Score: %.6f, solutions: %s, ones: %d/%d", + score / 100.0, + score / 100.0, + score, + count_label.c_str(), + ones, + clues + ); return 0; } - diff --git a/algorithmic/problems/145/statement.txt b/algorithmic/problems/145/statement.txt index 015e81035..de695ed88 100644 --- a/algorithmic/problems/145/statement.txt +++ b/algorithmic/problems/145/statement.txt @@ -1,55 +1,106 @@ -# Meituan Cup Warm-up Problem — Number Loop +# Number Loop Construction -This year's Meituan Cup warm-up problem is a **Number Loop**. +You are given a fixed 12 by 12 clue template. Some cells are clue cells, and the +remaining cells are blank. Your task is to fill every clue cell with a digit and +construct a Number Loop puzzle. -When designing this problem, Suanxie first selected the following template, ensuring that the puzzle must contain the two patterns **MT** and **PKU**. +The goal has two levels: -The next step is to replace all `?` in the template with digits from `0` to `3`, thus forming a valid Number Loop puzzle. An important requirement is that the puzzle must have a **unique solution** (the definition of a solution can be found in the warm-up problem). +1. Make the puzzle have as few valid loop solutions as possible. +2. Among puzzles with the same number of valid loop solutions, maximize the + number of clue cells equal to `1`. -However, Suanxie found that creating a puzzle of suitable difficulty with a unique solution on this template was extremely challenging. Therefore, he temporarily modified the template, which resulted in the final warm-up problem used in the contest. +## Number Loop Rules -Although he eventually managed to produce a valid puzzle, the feeling of failure still bothered him. Now, he hopes that you can help him achieve his original goal — **to construct a unique-solution Number Loop puzzle based on the original template.** +A loop is drawn on the grid lines around the 12 by 12 cells. ---- +* Each grid vertex must have degree either `0` or `2`. +* The selected grid edges must form exactly one non-empty closed loop. +* For every clue cell containing digit `d`, exactly `d` of its four surrounding + grid edges must be selected. +* Blank cells impose no clue constraint. -## Problem Description +A valid loop solution is one loop satisfying all clue constraints in your +output puzzle. -You need to construct a valid Number Loop puzzle according to the given input type. +## Template -* If the input is `0`, this corresponds to the **Small Task**: replace all `?` in the template with integers from `0` to `3`, ensuring the resulting puzzle has a **unique solution**. -* If the input is `1`, this corresponds to the **Large Task**: replace all `?` in the template with integers from `1` to `3`, ensuring the resulting puzzle has a **unique solution**. +Your output must preserve the following blank positions exactly. Every `?` +position must be replaced by a digit. -Your program should output a $12\times12$ grid consisting only of spaces and digits `0`–`3`, representing the constructed puzzle. Each row of the grid corresponds to one line of output (including spaces). +```text +? ? ??? +?? ?? ? ? +? ? ? ? ? +? ? ? ???? +? ? ? ? +? ? ? + +? ? ????? +? ? ? +?? ? ? ? +? ? ? ? ? +? ? ??? ? +``` ---- +There are 56 clue cells. ## Input Format The input contains a single integer: -* `0` — requires output of the Small Task solution. -* `1` — requires output of the Large Task solution. - ---- +* `0`: each clue cell may be one of `0`, `1`, `2`, or `3`. +* `1`: each clue cell may be one of `1`, `2`, or `3`. ## Output Format -Output a $12\times12$ character matrix containing only spaces and digits `0`–`3`, representing your constructed Number Loop puzzle. +Output exactly 12 lines, each with exactly 12 characters. ---- +* A blank position in the template must be output as a space. +* A `?` position in the template must be output as an allowed digit. -## Sample Output +Trailing spaces are significant for the 12 by 12 format. + +## Scoring + +For each test case, the judge counts the number of valid loop solutions in your +constructed puzzle, up to a cap of six solutions. It also counts + +```text +ones = number of clue cells equal to '1' +``` -Below is a sample output (note that this example has **multiple solutions** and therefore does **not** satisfy the problem requirement; it is shown only to illustrate the format): +Let `u = ones / 56`. +The per-case score is: + +```text +0 valid solutions: 0 +6 or more valid solutions: 1 + 9 * u +5 valid solutions: 10 + 10 * u +4 valid solutions: 20 + 10 * u +3 valid solutions: 30 + 10 * u +2 valid solutions: 40 + 10 * u +1 valid solution: 50 + 50 * u ``` + +The final score is the average over the two test cases. A unique-solution puzzle +is therefore always better than any non-unique puzzle, and within the same +solution-count bucket, more `1` clues are better. + +## Sample Output + +The following output only illustrates the required 12 by 12 format. It is not +necessarily a high-scoring construction. + +```text 0 0 000 00 00 0 0 0 0 0 0 0 0 0 0 0000 0 0 0 0 0 0 0 - + 0 0 00000 0 0 0 00 0 0 0