\n ![](\"./images/input.png\")
\n\t
\n \n\tAccurate map
\n\n ![](\"./images/output.png\")
\n\t
\n\n\tSmall map correctly representing adjacencies
\n\n\tAccurate map
\n\n\tSmall map correctly representing adjacencies
\n![](\"./images/oni.png\")
and **Fukunokami (fortune gods)** ![](\"./images/fuku.png\")
pieces on the board, with $2N$ pieces of each type, all placed on distinct squares.\n\nYou can select one row or column in a single operation and shift the chosen row/column by one square in either the left/right or up/down direction.\n\n- Shifting row $i$ to the left: The piece on square $(i,0)$ is removed from the board, and for each $j=1, \\dots, N-1$, the piece on square $(i,j)$ moves to $(i,j-1)$.\n- Shifting row $i$ to the right: The piece on square $(i,N-1)$ is removed from the board, and for each $j=0, \\dots, N-2$, the piece on square $(i,j)$ moves to $(i,j+1)$.\n- Shifting column $j$ upward: The piece on square $(0,j)$ is removed from the board, and for each $i=1, \\dots, N-1$, the piece on square $(i,j)$ moves to $(i-1,j)$.\n- Shifting column $j$ downward: The piece on square $(N-1,j)$ is removed from the board, and for each $i=0, \\dots, N-2$, the piece on square $(i,j)$ moves to $(i+1,j)$.\n\nYou can perform up to $4N^2$ operations.\n\nYour goal is to remove all the Oni from the board using as few moves as possible, without removing any Fukunokami.\n\nScoring\n--------\nLet $T$ be the number of operations in the output sequence, $X$ be the number of Oni remaining on the board, and $Y$ be the number of Fukunokami removed from the board.\nThen, you will obtain the following score.\n\n- If $X=0$ and $Y=0$, the score is $8N^2 - T$.\n- If $X>0$ or $Y>0$, the score is $4N^2 - N (X+Y)$.\n\nThere are $150$ test cases, and the score of a submission is the total score for each test case.\nIf your submission produces an illegal output or exceeds the time limit for some test cases, the submission itself will be judged as WA or TLE , and the score of the submission will be zero.\nThe highest score obtained during the contest will determine the final ranking, and there will be no system test after the contest.\nIf more than one participant gets the same score, they will be ranked in the same place regardless of the submission time.\n\n\n\nInput\n--------\nInput is given from Standard Input in the following format:\n~~~\n$N$\n$C_0$\n$\\vdots$\n$C_{N-1}$\n~~~\n\n- The board size $N$ is fixed at $N=20$ for all test cases.\n- For each $i=0,1,\\dots,N-1$, $C_i$ represents the initial state of row $i$ as a string of length $N$, where the $j$-th character is one of the following:\n\t- `x`: An Oni is present.\n\t- `o`: A Fukunokami is present.\n\t- `.`: Neither an Oni nor a Fukunokami is present.\n- There are exactly $2N$ Oni and $2N$ Fukunokami on the board.\n- **For every square initially occupied by an Oni, at least one of the following conditions is guaranteed to hold. This ensures that there always exists a sequence of at most $4N^2$ moves that removes all Oni while keeping all Fukunokami on the board.**\n\t- All squares above it in the same column do not contain a Fukunokami.\n\t- All squares below it in the same column do not contain a Fukunokami.\n\t- All squares to the left of it in the same row do not contain a Fukunokami.\n\t- All squares to the right of it in the same row do not contain a Fukunokami.\n\n#### Hint\nFor a square $(i,j)$ occupied by an Oni, if there is no Fukunokami in the upward direction, performing an upward shift $i+1$ times followed by a downward shift $i+1$ times will remove the Oni at $(i,j)$ without removing any Fukunokami.\nSimilarly, if there are no Fukunokami in the downward, leftward, or rightward directions, the Oni can be removed using the corresponding sequence of moves.\n\nSince this operation does not change the positions of the remaining pieces on the board, applying it to all Oni ensures that all Oni are removed without removing any Fukunokami.\n\n### Output\nEach operation at step $t$ is represented as a pair $(d_t, p_t)$, where $d_t$ is a character indicating the direction and $p_t$ is an integer indicating the row or column index.\n\n- Shifting row $i$ to the left: (`L`, $i$)\n- Shifting row $i$ to the right: (`R`, $i$)\n- Shifting column $j$ upward: (`U`, $j$)\n- Shifting column $j$ downward: (`D`, $j$)\n\nThen, output to Standard Output in the following format:\n~~~\n$d_0$ $p_0$\n$\\vdots$\n$d_{T-1}$ $p_{T-1}$\n~~~\n\nThe number of operations $T$ must not exceed $4N^2$.\nIf the limit is exceeded, the output will be judged as WA.\n\n\n\nShow example\n\n\n\nInput Generation\n--------\nFirst, $2N$ distinct squares are randomly selected from the $N^2$ squares on the board to determine the positions of the $2N$ Fukunokami pieces.\n\nNext, all squares satisfying at least one of the following conditions are listed, forming the set $S$:\n\n- All squares above it in the same column do not contain a Fukunokami.\n- All squares below it in the same column do not contain a Fukunokami.\n- All squares to the left of it in the same row do not contain a Fukunokami.\n- All squares to the right of it in the same row do not contain a Fukunokami.\n\nIf the number of elements in $S$ is less than $2N$, the Fukunokami placement process is repeated.\n\nFinally, $2N$ squares are randomly selected from $S$ to determine the positions of the $2N$ Oni pieces.\n\n\nTools (Input generator and visualizer)\n--------\n- Web version: This is more powerful than the local version providing animations and manual play.\n- Local version: You need a compilation environment of Rust language.\n\t- Pre-compiled binary for Windows: If you are not familiar with the Rust language environment, please use this instead.\n\nPlease be aware that sharing visualization results or discussing solutions/ideas during the contest is prohibited.", "target": "", "metadata": {"track": "algorithmic", "problem_id": 169, "statement_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/169/statement.txt", "config_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/169/config.yaml"}}
+{"context": "Time limit per test: 10 seconds\nMemory limit per test: 256 megabytes\nNote: The only difference between versions of this problem is the maximum value of n.\n\nOverview\nProfessor Vector is preparing to teach her Arithmancy class. She needs to prepare n distinct magic words for the class. Each magic word is a string over the alphabet {X, O}. A spell is created by concatenating two magic words. The power of a spell is defined as the number of distinct non-empty substrings of the resulting string.\n\nExample: The power of the spell \"XOXO\" is 7, because it has 7 distinct non-empty substrings:\nX, O, XO, OX, XOX, OXO, XOXO.\n\nTask Summary\nYour program must:\n1) Read n and output n distinct magic words (w1, w2, ..., wn).\n2) Then read q (the number of students/queries).\n3) For each student j = 1..q:\n - Read pj, the power of the student’s spell.\n - Output the exact pair of indices (uj, vj) such that concatenating w_uj followed by w_vj produces a string whose power is pj.\n - The order matters: you must output the indices in the correct order (first word, then second word).\n\nInteraction Protocol (Interactive Problem)\n1) Input: A single integer n (1 ≤ n ≤ 1000), the number of magic words to prepare.\n2) Output: Print n distinct magic words, one per line.\n - Each magic word must:\n • Consist only of characters 'X' and 'O'.\n • Have length between 1 and 30·n (inclusive).\n - Denote the i-th printed word as w_i (1 ≤ i ≤ n).\n - After printing all n words, flush the output.\n\n3) Input: A single integer q (1 ≤ q ≤ 1000), the number of students.\n4) For each of the q students:\n - Input: A single integer pj, the power of their spell.\n • It is guaranteed that pj was produced as follows:\n ◦ Two indices uj and vj were chosen independently and uniformly at random from {1, 2, ..., n}.\n ◦ The spell S was formed by concatenating w_uj and w_vj (in this order).\n ◦ pj equals the number of distinct non-empty substrings of S.\n - Output: Print the two integers uj and vj (1 ≤ uj, vj ≤ n) in this order.\n - Flush after printing each pair (uj, vj).\n\nImportant Requirements and Notes\n• Distinctness: All n magic words you output must be distinct.\n• Alphabet: Only 'X' and 'O' are allowed in each magic word.\n• Length bounds: For each word, 1 ≤ |w_i| ≤ 30·n.\n• Exact identification: For each query, it is not enough to find any pair that yields pj. You must identify the exact two words used by the student and the correct order (w_uj then w_vj).\n• Flushing: Remember to flush after:\n – Printing all n words.\n – Printing each answer pair (uj, vj).\n\nDefinitions\n• Magic word: A string over {X, O}.\n• Spell: Concatenation of two magic words (w_a followed by w_b).\n• Power of a string: The number of different non-empty substrings of that string.\n\nConstraints\n• 1 ≤ n ≤ 1000\n• 1 ≤ q ≤ 1000\n• For each i: 1 ≤ |w_i| ≤ 30·n\n• Alphabet: {X, O} only\n\nExample\nInput (conceptual, since the problem is interactive):\n2\n2\n15\n11\n\nOutput (one possible valid interaction transcript):\nXOXO\nX\n1 1\n2 1\n\nExplanation of the example:\n• After reading n = 2, the program outputs two distinct magic words, e.g., w1 = \"XOXO\" and w2 = \"X\" (flush).\n• Then q = 2 is read.\n• For the first student, the power p1 = 15 is read; the program answers with the indices \"1 1\".\n• For the second student, the power p2 = 11 is read; the program answers with the indices \"2 1\".\n(Exact details of powers and indices depend on the judge’s random choices and the specific words you output.)\n\nScoring:\nYour score for this problem is not just an AC or WA verdict. The scoring is based on the following formula:\n(30n^2 - Total length of your magic words)/(30n^2 - Optimal total length of magic words)\nYour goal is to maximize your score.", "target": "", "metadata": {"track": "algorithmic", "problem_id": 69, "statement_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/69/statement.txt", "config_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/69/config.yaml"}}
+{"context": "Time limit: 2 seconds\nMemory limit: 512 megabytes\nThis is an interactive problem, where your program and the judge interact via standard input and output.\nIn the kingdom of Duloc, Lord Farquaad is developing a network of watchtowers to monitor every corner of his land. He has a map of towers and the roads that connect them, forming an undirected simple graph G=(V,E), where each tower is a vertex and each road is an edge between two towers. However, Farquaad is worried that some parts of Duloc might be isolated, making it impossible to reach every tower from any other.\nTo ensure full connectivity, he tasks you with verifying whether his network is connected. However, there’s a catch: you’re only allowed limited access to information about the graph.\nYou can query the network to investigate its connectivity. A query allows you to select a subset of towers S and receive a count of the towers not in S that have direct roads connecting them to at least one tower in S. More precisely, query(S) = |N(S) \\ S|, where S ⊆ V and N(S) = {x | ∃y ∈ S such that (x,y) ∈ E} .\nYour goal is to use these queries efficiently to determine if the network is connected.\nCan you help Lord Farquaad confirm the security of his kingdom by verifying that every tower is reachable from any other in Duloc’s network?\n\nInput\nFirst input an integer T (T <= 5), representing the number of testcases.\nFor each testcase:\nInteraction starts by reading an integer the number of vertices.\nThen you can make queries of the type \"? s\" (without quotes) where s is a binary string of length n such that character s_i is 1 if node i ∈ S and 0 otherwise. After the query, read an integer, which is the answer to your query.\nAfter printing a query do not forget to output end of line and flush the output. The interactor is nonadaptive. The graph does not change during the interaction.\n \nConstraints\n1 <= |V| <= 200.\nYou are allowed to use at most 3500 queries for each testcase. Your score is inversely linear related to the number of queries.\n\nOutput\nWhen you find if G is connected or disconnected, print it in the format \"! x\" (without quotes), where x is 1 if G is connected and 0 otherwise.\n\nNote\nIn the following interaction, T = 1, |V| = 4, G = (V,E), V = {1,2,3,4} , E = {(1,2), (2,3), (3,4), (2,4)} .\nInput|Output|Description\n 1 | | 1 testcase.\n 4 | | |V| is given.\n |? 1100| Ask a query for subset {1,2}.\n 2 | | The judge responds with 2.\n |? 0010| Ask a query for subset {3}.\n 2 | | The judge responds with 2.\n |? 1001| Ask a query for subset {1,4}.\n 2 | | The judge responds with 2.\n |! 1 | The algorithm detected that G is connected.\nHere is another example, |V| = 2, G = (V,E), V = {1,2} , E = Φ.\nInput|Output|Description\n 2 | | |V| is given.\n |? 10 | Ask a query for subset {1}.\n 0 | | The judge responds with 0.\n |? 11 | Ask a query for subset {1,2}.\n 0 | | The judge responds with 0.\n |! 0 | The algorithm detected that G is disconnected.", "target": "", "metadata": {"track": "algorithmic", "problem_id": 25, "statement_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/25/statement.txt", "config_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/25/config.yaml"}}
+{"context": "# Problem\n\nAnton owns \\(n\\) umbrellas, each labeled with a distinct integer from \\(1\\) to \\(n\\). He wants to arrange some of them in a line to form a brilliant sequence of umbrellas (BSU).\n\nA sequence of \\(k\\) umbrellas with numbers \\(a_1, a_2, \\ldots, a_k\\) is a BSU if:\n\n- \\(a_i > a_{i-1}\\) for all \\(2 \\le i \\le k\\);\n- \\(\\gcd(a_i, a_{i-1}) > \\gcd(a_{i-1}, a_{i-2})\\) for all \\(3 \\le i \\le k\\).\n\nHere, \\(\\gcd(x, y)\\) denotes the greatest common divisor of integers \\(x\\) and \\(y\\).\n\n## Input\nA single line containing an integer \\(n\\) — the number of umbrellas \\((1 \\le n \\le 10^{12})\\).\n\n## Output\nPrint two lines:\n\n- The first line should contain an integer \\(k\\), the length of your BSU \\((1 \\le k \\le 10^6)\\).\n- The second line should contain \\(k\\) integers \\(a_1, a_2, \\ldots, a_k\\) \\((1 \\le a_i \\le n)\\), forming a valid BSU.\n\n## Goal\nMaximize the objective:\n\\[\nV \\;=\\; \\text{length}(\\text{BSU}) \\times \\sum_{i=1}^{k} a_i \\;=\\; k \\times \\Big(\\sum_{i=1}^{k} a_i\\Big).\n\\]\n\n## Scoring\nWe compare your objective value \\(V_{\\text{you}}\\) with a fixed baseline heuristic’s value \\(V_{\\text{base}}\\) on the same test. There is **no** best/optimal reference in scoring.\n\nYour score for a test is:\n\\[\n\\text{score} \\;=\\; 100 \\times \\min\\!\\left(\\frac{V_{\\text{you}}}{1.05 \\times V_{\\text{base}}},\\, 1\\right).\n\\]\n\nThus, reaching \\(1.05 \\times V_{\\text{base}}\\) yields a score of 100. Your final score is the average over all tests. Invalid outputs (violating constraints) receive 0 for that test.\n\n## Time limit\n1 second\n\n## Memory limit\n512 MB\n\n## Sample\n**Input**\n22\n**Output**\n5\n1 2 4 8 16\n\n(The sample only illustrates format and validity; it is not necessarily optimal for the new objective.)", "target": "", "metadata": {"track": "algorithmic", "problem_id": 41, "statement_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/41/statement.txt", "config_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/41/config.yaml"}}
+{"context": "Story\n--------\nAtCoder's CEO Takahashi prepares for Halloween tomorrow.\nAt AtCoder's Halloween party, Takahashi will dress up in disguise and receive a piece of candy from 100 employees in turn by saying, \"trick or treat!\"\nHe prepares a square box that can contain $10\\times 10$ pieces of candy in a grid pattern, and each employee puts a piece of candy in an empty space so that no candies overlap.\nThere are $3$ types of candies: strawberry, watermelon, and pumpkin flavors.\nHe knows which flavor of candy each employee will put in by preliminary survey, but he doesn't know where each employee will put it.\nSince he is a clean freak, he will move the pieces of candy by tilting the box forward, backward, left, or right, just once for each piece of candy received, and eventually wants to make sure that the same type of candy is clustered together as much as possible.\nPlease help him by writing a program to determine the direction to tilt.\n\n![](\"./images/b639c75d_1.gif\")
\n\t| $t$ | \nInput | \nOutput | \n
|---|---|---|
| Prior information | \n2 2 1 3 1 2 1 2 1 $\\cdots$ 3 | \n\n |
| 1 | \n3 | \nR | \n
| 2 | \n98 | \nB | \n
| $\\vdots$ | \n\n | \n |
| 100 | \n1 | \nL | \n
| $i$ | \nInput | \nOutput | \n
|---|---|---|
| Prior information | \n\n406 19\n347 786\n$\\vdots$\n21 191\n | \n\n |
| $0$ | \n69 | \n1 | \n
| $1$ | \n89 | \n0 | \n
| $\\vdots$ | \n||
| $M-1$ | \n175 | \n0 | \n
![](\"./images/out1.svg\")
\n![](\"./images/out2.svg\")
\n![](\"./images/out3.svg\")
\n\nOf the above three figures, only the path in the left figure satisfies the conditions.\nIn the middle figure, the same tile is stepped on twice in a row.\nIn the right figure, he left a tile once and then came back to the same tile.\n\n![](\"./images/out.min.svg\")
\n\nVisualization result of the sample output.\nThe red circle represents the initial position, and the green circle represents the final position.\nThe tiles stepped on are painted in light blue.\n\nScoring\n--------\nThe score of the output path is the score for the test case.\nIf the output does not satisfy the conditions, it is judged as `WA`.\nThere are 100 test cases, and the score of a submission is the total score for each test case.\nIf you get a result other than `AC` for one or more test cases, the score of the submission will be zero.\nThe highest score obtained during the contest time will determine the final ranking, and there will be no system test after the contest.\nIf more than one participant gets the same score, the ranking will be determined by the submission time of the submission that received that score.\n\n\nInput\n--------\nInput is given from Standard Input in the following format:\n\n~~~\n$si$ $sj$\n$t_{0,0}$ $t_{0,1}$ $\\ldots$ $t_{0,49}$\n$\\vdots$\n$t_{49,0}$ $t_{49,1}$ $\\ldots$ $t_{49,49}$\n$p_{0,0}$ $p_{0,1}$ $\\ldots$ $p_{0,49}$\n$\\vdots$\n$p_{49,0}$ $p_{49,1}$ $\\ldots$ $p_{49,49}$\n~~~\n\n- $(si,sj)$ denotes the initial position and satisfies $0\\leq si,sj\\leq 49$.\n- $t_{i,j}$ is an integer representing the tile placed on $(i,j)$. $(i,j)$ and $(i',j')$ are covered by the same tile if and only if $t_{i,j}=t_{i',j'}$ holds. Let the total number of tiles be $M$, then $0\\leq t_{i,j}\\leq M-1$ is satisfied.\n- $p_{i,j}$ is an integer value satisfying $0\\leq p_{i,j}\\leq 99$ which represents the score obtained when visiting $(i,j)$.\n\nOutput\n--------\nLet `U`, `D`, `L`, and `R` represent the movement from $(i,j)$ to $(i-1,j)$, $(i+1,j)$, $(i,j-1)$, and $(i,j+1)$, respectively.\nOutput a string representing a path in one line.\n\nInput Generation\n--------\n#### Generation of $si,sj$\nGenerate an integer between $0$ and $49$ uniformly at random.\n\n#### Generation of $t_{i,j}$\nWe start from an initial configuration where tiles of size $1\\times 1$ are placed on all squares.\nWe shuffle the 50x50 squares in random order and perform the following process for each square in order.\n\n- If the tile placed on the current square is $1\\times 1$, we randomly select one of the adjacent squares whose tile is $1\\times 1$ and connect the two tiles into one tile. If there are no such adjacent squares, we do nothing.\n- If the tile placed on the current square is not $1\\times 1$, we do nothing.\n\n#### Generation of $p_{i,j}$\nGenerate an integer between $0$ and $99$ uniformly at random independently for each square.\n\nTools\n--------\n- Inputs: A set of 100 inputs (seed 0-99) for local testing, including the sample input (seed 0). These inputs are different from the actual test case.\n- Visualizer on the web\n- Input generator and visualizer: If you want to use more inputs, or if you want to visualize your output locally, you can use this program. You need a compilation environment of Rust language.\n\n{sample example}", "target": "", "metadata": {"track": "algorithmic", "problem_id": 148, "statement_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/148/statement.txt", "config_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/148/config.yaml"}}
+{"context": "Problem Statement\n--------\nThere are $N(N+1)/2$ balls arranged in an $N$-tiered pyramid as shown in the figure below.\nLet $(0, 0)$ be the coordinates of the ball at the top of the pyramid, and let $(x,y)$ be the coordinates of the $y (0\\leq y\\leq x)$-th ball from the left in the $x (0\\leq x-1)$-th tier from the top.\n\n\n![](\"./images/d17182d7.png\")
\n![](\"./images/d17182d7.gif\")
\n![](\"./images/cow.png\")
Cow: Perform one basic move.\n2. ![](\"./images/pig.png\")
Pig: Perform two basic moves.\n3. ![](\"./images/rabbit.png\")
Rabbit: Perform three basic moves.\n4. ![](\"./images/dog.png\")
Dog: Move toward a target person as follows. The first turn starts with no target. If it has no target, the target person is in the current position, or there exists no path to the target person, then it selects one person uniformly at random among those reachable from the current position, excluding those in the current position. If there is no such person, reset to no target and perform one basic move. Otherwise, move to an adjacent passable square that shortens the shortest distance to the target person (if there are multiple such squares, choose one of them uniformly at random), and then perform one basic move. If it reaches the destination after the first or the second move, reset to no target.\n5. ![](\"./images/cat.png\")
Cat: Move toward a target square as follows. The first turn starts with no target. If it has no target or there exists no path to the target square, then it selects one square uniformly at random among those reachable from the current position, excluding the current position. If there exists no such square, do nothing. Otherwise, move to an adjacent passable square that shortens the shortest distance to the target square (if there are multiple such squares, choose one of them uniformly at random), and then perform one basic move. If it reaches the destination after the first or the second move, reset to no target.\n\n\nInput Generation\n--------\nLet $\\mathrm{rand}(L,U)$ be a function that generates a uniform random integer between $L$ and $U$, inclusive.\n\nWe generate the number of pets by $N=\\mathrm{rand}(10, 20)$.\nThe initial position of each pet is chosen uniformly at random from the coordinates that have not been chosen yet.\nWe generate the type of each pet by $pt_i=\\mathrm{rand}(1, 5)$.\n\nWe generate the number of humans by $M=\\mathrm{rand}(5, 10)$.\nThe initial position of each human is chosen uniformly at random from the coordinates that have not been chosen yet.\n\n\nTools\n--------\n- Local tester: You need a compilation environment of Rust language.\n\t- For those who are not familiar with the Rust language environment, we have prepared a pre-compiled binary for Windows. tools_x86_64-pc-windows-gnu.zip\n\t- The first version contained a bug in the cat's movement, which has been fixed at 130 minutes after the contest started. Please re-download it.\n\t- We have added more examples in README. If you don't know how to use the tools, please refer to README. Also, as stated in the rules, you are free to share information on how to run the provided tools.\n- Web visualizer: By pasting the output generated by the local tester into the Output field, you can display the animation of the execution result.\n\nYou are allowed to share output images (png or gif) of the provided visualizer for seed=0 on twitter during the contest. You have to use the specified hashtag and public account. You can only share visualization results and scores for seed=0. Do not share scores for other seeds or mention solutions or discussions. List of shared images.\n\n#### Specification of input/output files used by the tools\nInput files for the local tester consist of the prior information (the initial position and type of each pet, and the initial position of each person) followed by a random seed value to generate pet movements.\nSince the pet's movement depends on human actions, the input file contains only the random seed value and not specific movements.\nThe local tester writes outputs from your program directly to the output file.\nYour program may output comment lines starting with `#`.\nThe web version of the visualizer displays the comment lines at the time they are output, which may be useful for debugging and analysis.\nSince the judge program ignores all comment lines, you can submit a program that outputs comment lines as is.", "target": "", "metadata": {"track": "algorithmic", "problem_id": 154, "statement_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/154/statement.txt", "config_path": "/Users/jingzhuohu/repos/Frontier-CS/algorithmic/problems/154/config.yaml"}}
+{"context": "Story\n--------\nTakahashi, who loves loop lines, is playing with a toy train.\nAs shown in the figure below, this toy consists of square tiles containing railroad lines.\nBy rotating the tiles, he can connect lines and play with toy trains running on the lines.\nBecause Takahashi has two toy trains, please create two large loop lines as much as possible.\n\n| \n\n | \n\n\n | \n
| \nInitial State.\n | \n\nAfter rotating the top-right tile and the middle-right tile.\n | \n
\nYou are not required to understand this.\nWe recommend changing the seed value in the web visualizer to observe what kind of inputs are generated.\n
\n\nLet $\\mathrm{rand}(L,U)$ be a function that generates a uniform random integer between $L$ and $U$, inclusive.\nLet $\\mathrm{noise}(y,x,\\mathrm{seed})$ be a function that generates two-dimensional Perlin noise scaled to the range between $-1$ and $1$ based on a random seed value $\\mathrm{seed}$.\n
\n\nFirst, generate a seed value for Perlin noise generation as $\\mathrm{seed}=\\mathrm{rand}(0,2^{32}-1)$. \n
\n\nNext, for each $(i,j)$, generate $h_{i,j}=\\mathrm{round}(\\mathrm{noise}(i/10,j/10,\\mathrm{seed})\\times 50)$.\nIf $h_{i,j}=0$ for all $(i,j)$, then regenerate $\\mathrm{seed}$.\n
\n\nLet $S$ be the sum of $h_{i,j}$.\nTo make $S=0$, perform the following transformation.\n
\n\nShuffle all coordinates $(0,0),(0,1),\\cdots,(N-1,N-1)$ in a uniformly random order, and let the $k$-th coordinate be $(i_k,j_k)$. \nIf $S>0$, then for each $k=0,1,\\cdots,S-1$, decrease $h_{i_{k\\% N^2},j_{k\\% N^2}}$ by $1$. \nIf $S<0$, then for each $k=0,1,\\cdots,-S-1$, increase $h_{i_{k\\% N^2},j_{k\\% N^2}}$ by $1$.\n
\n| \nTile\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n\n\n | \n
| \nBinary\n | \n\n0000\n | \n\n0001\n | \n\n0010\n | \n\n0011\n | \n\n0100\n | \n\n0101\n | \n\n0110\n | \n\n0111\n | \n\n1000\n | \n\n1001\n | \n\n1010\n | \n\n1011\n | \n\n1100\n | \n\n1101\n | \n\n1110\n | \n\n1111\n | \n
| \nHex\n | \n\n0\n | \n\n1\n | \n\n2\n | \n\n3\n | \n\n4\n | \n\n5\n | \n\n6\n | \n\n7\n | \n\n8\n | \n\n9\n | \n\na\n | \n\nb\n | \n\nc\n | \n\nd\n | \n\ne\n | \n\nf\n | \n
\n![](\"./images/f29506fb2_1.svg\") \n | \n\n![](\"./images/f29506fb2_2.svg\") \n | \n\n![](\"./images/f29506fb2_3.svg\") \n | \n
| Input | \nOutput | \n
|---|---|
3 19 16 17 | \n\n |
| \n | DDDDDDDDDDDDDLL | \n
99561 | \n\n |
26 18 13 18 | \n\n |
| \n | UUUUUUUUUUUUU | \n
72947 | \n\n |