22 Solving Tatamibari Puzzle Using Exhaustive Search Approach
22 Solving Tatamibari Puzzle Using Exhaustive Search Approach
22 Solving Tatamibari Puzzle Using Exhaustive Search Approach
#
undergraduate student, Computing Laboratory
School of Computing, Telkom University, Indonesia (40257)
1
[email protected]
∗
Computing Laboratory
School of Computing, Telkom University, Indonesia (40257)
2
[email protected],
3
[email protected]
Abstract
Tatamibari is a puzzle that was first published in 2004 and was proven to be NP-complete
in 2020. However, to the best of our knowledge, algorithmic investigation of the Tatamibari
puzzle is relatively new and limited. There are discussions about an approach for solving the
Tatamibari puzzle using the Z3 SMT solver, but this solver requires an additional library that
cannot be directly executed using standard libraries in an arbitrary imperative programming
language. Hence, this paper discusses an exhaustive search approach for solving an arbitrary
Tatamibari puzzle. We show that this algorithm can find all solutions to an m × n Tatamibari
instance with h hints in O(max{m2 n2 , hmn−h · hmn}) time. We also use this algorithm to
find the number of possible Tatamibari solutions in an m × n grid for some small values of
m and n.
Abstrak
Tatamibari merupakan suatu teka teki yang pertama kali diperkenalkan pada tahun 2004
dan telah dibuktikan termasuk ke dalam permasalahan NP-complete pada tahun 2020. Akan
tetapi, sepanjang pengetahuan kami, investigasi algoritmik terkait teka teki ini masih sa-
ngat sedikit. Terdapat pembahasan mengenai penggunaan Z3 SMT solver untuk menyele-
saikan teka teki Tatamibari ini, namun solver ini menggunakan pustaka (library) yang tidak
dapat digunakan secara langung pada sembarang bahasa pemrograman imperatif. Dalam
artikel ini kami mendiskusikan algoritma pencarian menyeluruh (exhaustive search) untuk
memecahkan teka teki Tatamibari dan menunjukkan bahwa algoritma ini dapat mencari se-
mua solusi dari teka teki Tatamibari berukuran m × n yang memiliki h petunjuk dalam
waktu O(max{m2 n2 , hmn−h ·hmn}). Kami juga menggunakan algoritma ini untuk mencari
banyaknya solusi Tatamibari pada grid m × n untuk beberapa nilai m dan n yang kecil.
I. I NTRODUCTION
T ATAMIBARI is a pencil-and-paper logic puzzle popularized by Nikoli, a puzzle magazine from Japan
that also popularized Sudoku. This puzzle—which was first published in 2004 [1] and inspired by
Japanese tatami mats—has recently been proven to be NP-complete in 2020 [2]. The NP-completeness
proof of this puzzle establishes a Nikoli gap1 of 16 years, which is one of the longest for a pencil-and-
paper puzzle.
Tatamibari puzzle is a one-player pencil-and-paper game played on an m × n grid of cells where each
cell is either filled with the characters +, −, or |, or is empty. The characters +, −, and | are called
hints. The objective of the player is to partition the grid into several rectangles satisfying the following
criteria:
1) The rectangles do not overlap.
2) The union of all rectangles must cover all cells within the grid.
3) Every rectangle must contain exactly one hint (either +, −, or |) and satisfies the following
conditions:
a) a rectangle containing + must be a square (the number of rows and columns in this rectangle
are identical),
b) a rectangle containing − must have a greater width than height (the number of rows in this
rectangle is less than its number of columns),
c) a rectangle containing | must have a greater height than width (the number of rows in this
rectangle is more than its number of columns).
4) No rectangles share the same corner.
Puzzles are forms of entertainment that give a feeling of satisfaction to the player upon completing it [4].
Solving puzzles can help the player relax while developing visual processing and logical thinking skills.
Many puzzles also contain mathematical and computational aspects with connections to combinatorial and
computational problems. Numerous systematic studies have been conducted on the algorithmic aspects of
one-player puzzles (see [4]–[6] for extensive bibliography). Taken from [4], there have been many puzzles
that have been proven to be NP-complete, such as (in alphabetical order): Blocks World, Clickomania,
Corral Puzzle, Cross Sum, Cryptarithms, Instant Insanity, KPlumber, Lemmings, Light Up, Mastermind,
Minesweeper, n-Puzzle, Nurikabe (see also [7]), Pearl Puzzle, Peg Solitaire, Reflections, Rush Hour,
Shanghai, Slither Link, Sokoban, Solitaire, Spiral Galaxies, Sudoku (see also [8]), and Tetris. Other
one-player pencil-and-paper puzzles that have been proven to be NP-complete are: Country Road [9],
Dosun-Fuwari [10], Fillmat [11], Five Cells [12], Hashiwokakero [13], Herugolf [14], Heyawake [15],
Hiroimono [16], Juosan [17], Kurodoko [18], Kurotto [17], Makaro [14], Moon-or-Sun [19], Nagareru
[19], Nurimeizu [19], Ripple Effect [20], Shakashaka [21], Shikaku [20], Sto-Stone [3], Tatamibari [2],
Tilepaint [12], Usowan [22], Yajilin [9], Yin-Yang [23], and Yosenabe [24].
The NP-completeness of Tatamibari puzzles implies the existence of a polynomial time algorithm for
verifying whether an arbitrary m×n grid is also a Tatamibari solution.2 Furthermore, the NP-completeness
of the puzzles also infers the existence of an exponential time algorithm for solving an arbitrary m × n
Tatamibari puzzle with h hints. To our knowledge, algorithmic investigation of the Tatamibari puzzle
is relatively new and limited. Adler et al. [2], [25] and Bosboom [26] briefly discuss an approach for
solving the Tatamibari puzzle using the Z3 SMT solver, but the authors did not provide details regarding
the steps of the algorithm as well as its explicit asymptotic upper bound. Moreover, solving Tatamibari
puzzles using this solver requires an additional library that cannot be directly executed using standard
libraries in an arbitrary imperative programming language.
There are several approaches to solve NP-complete puzzles, such as using the integer programming
model [21], the SAT solver [27]–[31], or the SMT solver [25]. Here, we discuss the exhaustive search
technique as an elementary and explicit method for solving arbitrary Tatamibari puzzles. We provide an
explicit upper bound of the time complexity for finding all solutions to an arbitrary Tatamibari puzzle
and also prove that the solutions can be obtained in exponential time in terms of the number of hints
and the size of the puzzle.
Here, we present our systematic investigation of solving Tatamibari puzzles using an exhaustive search
approach, divided into four sections. We briefly summarize the NP-completeness of Tatamibari puzzles in
[2] and discuss the formal representation of Tatamibari instances, configurations, and solutions in Section
1 According to [3], a Nikoli gap is the amount of time between the first publication of a Nikoli puzzle and its corresponding
hardness result.
2 A Tatamibari solution is an m × n grid configuration that satisfies the four rules of the Tatamibari puzzle, the formal definition
of the Tatamibari solution is discussed in Definition 1.
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 55
II. We provide an O(hmn) time algorithm for verifying whether an m × n Tatamibari configuration with
h hints is also a solution in Section III. Our main result of the paper is presented in Section IV and
it is shown that all solutions to an m × n Tatamibari instance with h hints can be obtained using an
O(max{m2 n2 , hmn−h · hmn}) algorithm. We implement our proposed algorithm in C++ programming
language and summarize some of its computational results in Section V. Finally, this paper is concluded
in Section VI.
II. P RELIMINARIES
In this section, we discuss related works about the NP-completeness of the Tatamibari puzzles that
have been proven in 2020 [2]. We also provide the definitions of instances, configurations, and solutions
for the Tatamibari puzzles.
To prove that the Tatamibari puzzle is NP-complete, Adler et al. first showed that the puzzle is NP-
hard. The authors discussed a reduction to the Tatamibari puzzle from the planar rectilinear monotone
3SAT problems. This reduction uses small partial instances of a Tatamibari puzzle, commonly referred
to as gadgets, to simulate certain objects in the planar rectilinear monotone 3SAT problems. The author
first introduced a general “gadget area hardness framework” to argue about the compilations of local
gadgets whose logical representation is characterized by area coverage. There are three types of gadget
construction used in the reduction, namely:
1) The construction of wire and terminator gadgets. According to [2], wire gadgets in a Tatamibari
instance consist of columns containing + hints surrounded by | hints which encode a truth value in
the parity of whether the cells are oriented with the + hints in their lower left or upper left corners;
while terminator gadgets are used to terminate unused wire gadgets regardless of their parity.
In a planar rectilinear monotone 3SAT instance, a wire connects two different clauses separated
horizontally.
2) The construction of variable gadgets. Variable gadgets in a Tatamibari instance are associated with
the variable in the planar rectilinear monotone 3SAT problems, which are expressed as x1 , x2 , . . ..
Reinhard et al.
Solving Tatamibari Puzzle Using Exhaustive... 56
3) The construction of clause gadgets. Clause gadgets in a Tatamibari instance are associated with the
clauses in the planar rectilinear monotone 3SAT problems, which are expressed as a disjunction of
several variables or their negations, such as x1 ∨ x5 ∨ x6 .
Adler et al. constructed a reduction f that maps a planar rectilinear monotone 3SAT instance Φ to a
Tatamibari instance f (Φ) using the aforementioned gadgets and show that the following conditions are
satisfied:
1) if Φ consists of n variables and m clauses, then the size of f (Φ) is polynomial in n + m and it
can be computed in O(p(n + m)) time where p is a polynomial [2, Proposition 3.16];
2) an instance Φ of a rectilinear monotone 3SAT problem has a solution if and only if its corresponding
Tatamibari instance f (Φ) also has a solution [2, Proposition 3.17, Proposition 3.18].
The two previously mentioned results imply that Tatamibari puzzles are NP-hard. Moreover, since any
given Tatamibari solution can be checked in polynomial time (with respect to the size of the Tatamibari
board and the number of hints), we infer that Tatamibari puzzles are NP-complete. We discuss an explicit
polynomial time verification algorithm for checking whether arbitrary Tatamibari configurations are also
Tatamibari solutions in Section III.
−1 −
−
−2 |3 − |
− |
−4 |5 − |
− |
+6 −7 + −
+ −
(b) A 4 × 4 Tatamibari instance (c) A solution for the Tatamibari
(a) A 4 × 4 Tatamibari instance. with numbered hints. puzzle in Fig. 2a.
Fig. 2: Examples of a Tatamibari instance, a Tatamibari instance with numbered hints, and a solution to
a Tatamibari puzzle. Fig. 2a is a 4 × 4 Tatamibari instance. Fig. 2b is obtained from the instance in Fig.
2a by adding a number to every hint. Fig. 2c is a solution to the Tatamibari puzzle in Fig. 2a.
Definition 1 allows us to conveniently represents every Tatamibari instance, configuration, and solution
using a two-dimensional array. An illustration regarding this representation is given in Fig. 3. In general,
any Tatamibari instance can be represented using a two-dimensional array of size m × n where each
entry of the array is either ∗, +, −, or |, where ∗ denotes an empty cell. Using this convention, the
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 57
Tatamibari instances in Fig. 2a and Fig. 2b and the Tatamibari solution in Fig. 2c can be respectively
represented using the arrays in Fig. 3a, Fig. 3b, and Fig. 3c. In addition, Definition 1 also tells that every
Tatamibari solution is also a Tatamibari configuration, but not vice versa. Several examples of Tatamibari
configurations that are not Tatamibari solutions are given in Fig. 4.
∗ ∗ − ∗ ∗ ∗ −1 ∗
∗ − ∗ | ∗ −2 ∗ |3 −1 −1 −1 −1
− ∗ | ∗ −4 ∗ |5 ∗ −2 −2 |5 |3
+ − ∗ ∗ +6 −7 ∗ ∗ −4 −4 |5 |3
+6 −7 −7 |3
(a) An array that corresponds to (b) An array for the Tatamibari
the Tatamibari instance depicted in instance with numbered hints de- (c) An array for the Tatamibari
Fig. 2a. picted in Fig. 2b. solution depicted in Fig. 2c.
Fig. 3: Several two-dimensional array representations of a Tatamibari puzzle.
−1 −1 −1 −1 −1 −1 −1 −1
−2 −2 |5 |3 −2 −2 −3 −3
−4 −4 |5 |3 +4 +4 +5 +5
+6 −7 |5 |3 +4 +5 +5 +5
(a) The shape of the region of iden- (b) There is a grid dot that is shared by four
tity −7 is a square. different regions.
Fig. 4: Two Tatamibari configurations which are not solutions to any Tatamibari instances.
We develop a polynomial time algorithm for verifying whether a Tatamibari configuration is also a
Tatamibari solution. We refer to this algorithm as the Tatamibari solution verifier. This algorithm uses
0-based index convention for arrays and lists. Therefore, the top-leftmost cell in a Tatamibari board is
mapped into a cell (0, 0) in its two-dimensional array B representing the board. This algorithm takes
an m × n two-dimensional array as input. Moreover, every cell in this array is a string of the form
⟨symbol⟩⟨number⟩ called identity, abbreviated as id. In other words, the algorithm takes a Tatamibari
configuration as an input. Our proposed Tatamibari solution verifier algorithm consists of three main
parts, namely: a procedure to create a list of identities, a procedure to check the region of each identity,
and a procedure to check the non-existence of a corner that is shared by four different regions.
Algorithm 1 I DENTITY-L IST(B, m, n) creates a list containing the identities as well as the first and the last cell
of such identities in row-major order in a Tatamibari configuration B of size m × n.
Input: A two-dimensional array B of size m × n whose entries are of the form ⟨symbol⟩⟨number⟩.
Output: A list L containing triples of the form (id, (r1 , c1 ), (r2 , c2 )) where (r1 , c1 ) and (r2 , c2 ) are correspondingly
the first and the last cells of the identity id in row-major order.
1: i ← 0, L ← an empty list
2: while i < m do
3: j←0
4: while j < n do
5: if B[i][j] is not in L then
6: r1 , r 2 ← i
7: c1 , c2 ← j
8: add (B[i][j], (r1 , c1 ), (r2 , c2 )) to L
9: else
10: update (r2 , c2 ) with (i, j) for corresponding identity in B[i][j]
11: end if
12: j ←j+1
13: end while
14: i←i+1
15: end while
16: return L
Observe that the maximum number of iterations in lines 2–15 of Algorithm 1 is mn. In this algorithm
and many algorithms that follow, we use a dynamic list3 L whose amortized time complexity for adding
an element is constant, see [33]–[35] for details. Thus, the step to add the triple (B[i][j], (r1 , c1 ), (r2 , c2 ))
to L in line 8 takes an amortized O(1) time. Therefore, the asymptotic upper bound for the running time
of Algorithm 1 is O(mn).
3 In practice, this list can be represented using a vector data structure in C++ or a list data structure in Python.
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 59
Algorithm 2 VALID -S HAPES(B, m, n, id, r1 , c1 , r2 , c2 ) checks whether the shape of a region which is a collection
of all cells with identity id meets the rules of Tatamibari puzzle (represented as an array B of size m × n). The cell
(r1 , c1 ) is the top-leftmost cell with identity id while the cell (r2 , c2 ) is the bottom-rightmost cell with identity id.
Input: A two-dimensional array B of size m × n whose entries are of the form ⟨symbol⟩⟨number⟩, an identity
value id, the cell (r1 , c1 ) denoting the first cell that is filled with id, and the last cell (r2 , c2 ) denoting the last
cell that is filled with id. The cells are checked in row-major order.
Output: The procedure returns true if the region which is a collection of all cells with identity id satisfies the
Tatamibari rules according to its hint symbol; otherwise it returns false.
1: ∆r = r2 − r1 ; ∆c = c2 − c1
2: if (id[0] = − and (∆r ≥ ∆c)) or (id[0] = | and (∆r ≤ ∆c)) or (id[0] = + and (∆r ̸= ∆c)) then
3: return false ▷ the shape of the region does not concur with the hint symbol
4: else
5: i←0
6: while i < m do
7: j←0
8: while j < n do
9: if (i < r1 or i > r2 or j < c1 or j > c2 ) and B[i][j] = id then
10: return false ▷ there is a cell with identity id outside the rectangle
11: end if
12: if (i ≥ r1 and i ≤ r2 and j ≥ c1 and j ≤ c2 ) and B[i][j] ̸= id then
13: return false ▷ there is a cell within the rectangle whose identity is different from id
14: end if
15: j ←j+1
16: end while
17: i←i+1
18: end while
19: end if
20: return true
Observe that the maximum number of iterations in lines 6–18 of Algorithm 2 is mn. Therefore, the
asymptotic upper bound for the running time of Algorithm 2 is O(mn).
Algorithm 3 VALID -C ORNER(B, m, n) checks whether there is a corner that is shared by four different regions
in a Tatamibari configuration represented by an array B of size m × n.
Input: A two-dimensional array B of size m × n whose entries are of the form ⟨symbol⟩⟨number⟩.
Output: The function returns true if no corner is shared by four different regions, otherwise it returns false.
1: i ← 0
2: while i < m − 1 do
3: j←0
4: while j < n − 1 do
5: if (B[i][j] ̸= B[i+1][j]) and (B[i][j] ̸= B[i][j +1]) and (B[i][j] ̸= B[i+1][j +1]) and(B[i+1][j] ̸=
B[i][j + 1]) and (B[i + 1][j] ̸= B[i + 1][j + 1]) and (B[i][j + 1] ̸= B[i + 1][j + 1]) then
6: return false ▷ the cell (i, j), (i, j + 1), (i + 1, j), and (i + 1, j + 1) have different identities
7: end if
8: j ←j+1
9: end while
10: i←i+1
11: end while
12: return true
Observe that the number of iterations in lines 2–11 of Algorithm 3 cannot be larger than mn. Therefore,
the asymptotic upper bound for the running time of Algorithm 3 is O(mn).
Reinhard et al.
Solving Tatamibari Puzzle Using Exhaustive... 60
Notice that the asymptotic time complexity of Algorithm 4 can be determined as follows:
1) Line 1 executes the procedure F IND -I DENTITY described in Algorithm 1 whose running time is
O(mn).
2) Lines 4–9 is executed at most h times, where h is the number of identities. Each iteration executes
the procedure VALID -S HAPES described in Algorithm 2 whose running time is O(mn). Thus the
asymptotic time complexity of lines 4–9 is O(hmn).
3) Line 10 executes the function VALID -C ORNER described in Algorithm 3 whose running time is
O(mn).
Therefore, assuming that h ≥ 1, the asymptotic upper bound for the running time of Algorithm 4 is
O(mn) + O(hmn) + O(mn) = O(hmn).
This section discusses an algorithm for solving any arbitrary Tatamibari instances using an exhaustive
search technique. The instances are represented using two-dimensional array B of size m × n whose
entries are either +, −, |, or ∗, where ∗ signifies an empty cell as illustrated in Fig. 3a. The main
algorithm is divided into four major steps as follows:
1) a procedure to append a number to every hint,
2) a procedure to determine the possible identities (possible regions) of an empty cell,
3) a procedure to generate possible combinations of identities for all empty cells,
4) a procedure to construct a Tatamibari configuration from each of the possible combinations in step
3 and verify whether such a configuration satisfies four Tatamibari rules.
Algorithm 5 I DFIER(B, m, n) appends a unique number to every hint in an array B of a Tatamibari instance of
size m × n.
Input: A two-dimensional array B of a Tatamibari instance whose characters are either +, −, |, or ∗, where ∗ ,
where ∗ denotes an empty cell.
Output: A two-dimensional array B of a Tatamibari instance with numbered hints. The numbering is performed in
row-major order.
1: x ← 0 ▷ x is the hint number
2: i ← 0
3: while i < m do
4: j←0
5: while j < n do
6: if B[i][j] ̸= ∗ then ▷ the cell is non-empty
7: x←x+1
8: B[i][j] ← B[i][j] ∥ x ▷ concatenate the hint with a unique number to create a unique identity
9: end if
10: j ←j+1
11: end while
12: i←i+1
13: end while
14: Return B
The purpose of Algorithm 5 is to provide a unique number to each hint. A concatenation of a hint
and its number is called an identity as described in Definition 1. The maximum value of such a number
also signifies the number of partitions in the solution to the corresponding Tatamibari instance (if any
solution exists). Observe that the maximum number of iterations in lines 3–13 of Algorithm 5 is mn.
Therefore, the asymptotic upper bound for the running time of Algorithm 5 is O(mn).
Algorithm 6 C HECK -A BOVE(B, x, y, L) returns the row position of an identity located directly above the empty
cell (x, y) in a Tatamibari instance B of size m × n as well as a list L containing such an identity. If such an
identity does not exist, the algorithm returns (−1, L) and L remains unchanged.
Input: A Tatamibari instance B, the location of the empty cell (x, y), and a list L containing all possible identities
for the cell (x, y).
Output: The pair (minr, L), here minr is the row index such that (minr, y) contains an identity (non-empty), is
located directly above (x, y), and the value x − minr is minimum, such an identity is also added to the list L;
if such an identity does not exist, the algorithm returns (−1, L) and L remains unchanged.
1: minr ← −1
2: i ← x − 1
3: while i > −1 do
4: if B[i][y] ̸= ∗ then
5: minr ← i
6: add B[i][y] to L
7: break
8: end if
9: i←i−1
10: end while
11: return (minr, L)
Fig. 5b provides an illustration of Algorithm 6 on the empty cell (3, 3). Here, the algorithm finds |1 as
the nearest cell located directly above (3, 3) containing an identity and sets minr = 1 since |1 is located
at the cell (1, 3). Notice that the worst-case scenario of Algorithm 6 happens when x = m − 1 and all
cells located above (x, y) are empty. Thus, assuming that the amortized time complexity for adding an
element to L in line 6 of Algorithm 6 takes O(1) time (as in the analysis of Algorithm 1), we infer that
the asymptotic upper bound for the running time of Algorithm 6 is O(m).
The function C HECK -B ELOW is defined analogously as the previous C HECK -A BOVE function. If (x, y)
is an empty cell in a Tatamibari instance of size m × n, maxr denotes the row position of the nearest
identity located directly below and in the same column of the cell (x, y). The C HECK -B ELOW function
stores the possible identities of an empty cell (x, y) in a (dynamic) list L. This function takes a tuple
(B, x, y, L) as an input and returns a pair (maxr, L) such that maxr is the row index of an identity
located directly below the empty cell (x, y) in a Tatamibari instance B of size m × n such that x − maxr
is minimum. Here L is a list containing possible identities for the empty cell. Initially, the value maxr
is set to m. If there is no cell located directly below (x, y) containing any identity, then the function
returns a pair (m, L) where L remains unchanged.
Fig. 5c illustrates C HECK -B ELOW function on the empty cell (3, 3). Here, the function does not find
any cell containing any hint located directly below (3, 3). As a result, it sets maxr = 8. Notice that the
worst-case scenario of C HECK -B ELOW function happens when x = 0 and all cells located below (x, y)
are empty. Thus, the asymptotic upper bound for the running time of this function is O(m).
To define the leftmost perimeter of an empty cell we use the variable minc. Here, minc signifies the
column position of the nearest identity located directly to the left and in the same row of an empty cell
(x, y) in a Tatamibari instance B of size m × n. We define C HECK -L EFT as a function that takes a tuple
(B, x, y, L) as an input and returns a pair (minc, L) such that y − minc is minimum and (x, minc)
contains a hint. As in the previous C HECK -A BOVE and C HECK -B ELOW functions, C HECK -L EFT function
uses a (dynamic) list L containing possible identities for (x, y). At first, the value minc is set to 0. If
there is no cell located directly to the left of (x, y) containing any identity, then the function returns a
pair (0, L) where L remains unchanged.
Fig. 5d depicts an illustration of C HECK -L EFT function on the empty cell (3, 3). In this case, the
function does not find any cell containing any hint located directly to the left of (3, 3). Hence, it sets
minc = −1. Observe that the worst-case scenario of this function happens when y = n − 1 and all
cells located to the left of (x, y) are empty. Thus, the asymptotic upper bound for the running time of
C HECK -L EFT function is O(n).
To determine the rightmost perimeter of an empty cell we use the variable maxc. This variable
represents the column position of the nearest identity located directly to the right and in the same row of
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 63
an empty cell (x, y) in a Tatamibari instance B of size m × n. Analogous to the C HECK -L EFT function,
we define C HECK -R IGHT as the function that takes a tuple (B, x, y, L) and returns a pair (maxc, L) such
that (x, maxc) contains an identity and the value y − maxc is minimum. As in the previous C HECK -
A BOVE, C HECK -B ELOW, and C HECK -L EFT functions, this function also stores the possible identities
of an empty cell (x, y) in a (dynamic) list L. Initially, the value of maxc is set to n. If there is no
cell located directly to the right of (x, y) with any identity, then C HECK -R IGHT function returns (n, L)
where L remains unchanged.
Fig. 5e demonstrates C HECK -R IGHT function on the empty cell (3, 3). The function finds the cell (3, 6)
with identity −3 as the nearest cell located directly to the right of (3, 3) and thus it sets maxc = 6. It
also adds −3 to the list L. Notice that the worst-case scenario of C HECK -R IGHT function happens when
y = 0 and all cells located to the right of (x, y) are empty. Thus, the asymptotic upper bound for the
running time of this function is O(n).
The functions C HECK -A BOVE, C HECK -B ELOW, C HECK -L EFT, and C HECK -R IGHT are independent
of one another and they can be performed in any order. In Fig. 5, we illustrate the execution of these
functions in sequential order.
|1 |1
−2 −2
∗ −3 |4 ∗ −3 |4
+5 −6 +5 −6
|7 |7
−8 −8
+9 +9
(a) We consider an empty cell (3, 3). (b) Algorithm 6 finds |1, adds |1 to the list L,
and sets minr = 1.
|1 |1
−2 −2
∗ −3 |4 ∗ −3 |4
+5 −6 +5 −6
|7 |7
−8 −8
+9 +9
(c) The C HECK -B ELOW function does not find (d) The C HECK -L EFT function does not find
anything below ∗ and sets maxr = 8. anything on the left and sets minc = −1.
|1
−2
∗ −3 |4
+5 −6
|7
−8
+9
(e) The C HECK -R IGHT functions finds −3,
adds −3 to the list L, and sets maxc = 6.
Fig. 5: Visualization of the C HECK -A BOVE, C HECK -B ELOW, C HECK -L EFT, and C HECK -R IGHT on cell
(3, 3). Here, we use 0-based indexing for the array B representing the Tatamibari board.
Reinhard et al.
Solving Tatamibari Puzzle Using Exhaustive... 64
The values minr, maxr, minc, and maxc provide an orthogonal perimeter for an empty cell (x, y).
We have a rectangle whose corners are (minr, minc) (top-left corner), (minr, maxc) (top-right corner),
(maxr, minc) (bottom-left corner), and (maxr, maxc) (bottom-right corner). We restrict our investigation
of possible identities for (x, y) in this rectangle. Moreover, to further limit the number of possible identities
for this empty cell, in general, we consider four smaller regions as follows:
1) the top-right area, i.e., all cells within the rectangle whose corners are (minr + 1, y + 1) (top-
left corner), (minr + 1, maxc − 1) (top-right corner), (x − 1, y + 1) (bottom-left corner), and
(x − 1, maxc − 1) (bottom-right corner);
2) the bottom-right area, i.e., all cells within the rectangle whose corners are (x + 1, y + 1) (top-
left corner), (x + 1, maxc − 1) (top-right corner), (maxr − 1, y + 1) (bottom-left corner), and
(maxr − 1, maxc − 1) (bottom-right corner);
3) the bottom-left area, i.e., all cells within the rectangle whose corners are (x + 1, minc + 1) (top-
left corner), (x + 1, y − 1) (top-right corner), (maxr − 1, minc + 1) (bottom-left corner), and
(maxr − 1, y − 1) (bottom-right corner);
4) the top-left area, i.e., all cells within the rectangle whose corners are (minr + 1, minc+1) (top-left
corner), (minr+1, y−1) (top-right corner), (x−1, minc+1) (bottom-left corner), and (x−1, y−1)
(bottom-right corner).
We describe the function C HECK -T OP -R IGHT to find all possible identities of an empty cell (x, y) in
its associated top-right area in Algorithm 7. This algorithm requires the position of an empty cell (x, y)
as well as the corresponding minr and maxc values respectively obtained from C HECK -A BOVE and
C HECK -R IGHT functions.
Algorithm 7 C HECK -T OP -R IGHT(B, x, y, minr, maxc, L) finds all possible identities in the corresponding top-
right area of an empty cell (x, y).
Input: A Tatamibari instance B, the location of the empty cell (x, y), the value minr from C HECK -A BOVE function,
the value maxc from C HECK -R IGHT function, and a list L containing all possible identities for the cell (x, y).
Output: An updated list L containing all possible identities for the cell (x, y). The identities are obtained from the
top-right area associated with (x, y).
1: ℓ ← maxc
2: i ← x − 1
3: while i > minr do
4: j ←y+1
5: while j < ℓ do
6: if B[i][j] ̸= ∗ then
7: add B[i][j] to L
8: ℓ←j
9: break
10: end if
11: j ←j+1
12: end while
13: i←i−1
14: end while
15: return L
Fig. 6 depicts an illustration of Algorithm 7 on the empty cell (3, 3). The algorithm checks all possible
identities in the top-right area associated with the empty cell (3, 3), namely the cells (2, 4) and (2, 5). In
general, the cells are visited in a left-to-right and bottom-up fashion. The variable ℓ is used to minimize
the number of cells that must be visited in a left-to-right and bottom-up approach. Initially, ℓ is set to
maxc, and if the algorithm finds a non-empty cell, the value ℓ is updated with the column position of
this non-empty cell. Observe that the worst-case scenario of Algorithm 7 happens when x = m − 1,
y = 0, minr = −1, maxc = n − 1, and all cells located in the top-right area of (x, y) are empty. Thus,
assuming that the amortized time complexity for adding an element to L in line 7 of Algorithm 7 takes
O(1) time (as in the Analysis of Algorithm 1 and Algorithm 6), we infer that the asymptotic upper bound
for the running time of Algorithm 7 is O(mn).
The function C HECK -B OTTOM -R IGHT is defined analogously and it is used to find all possible
identities of an empty cell (x, y) in its associated bottom-right area. This function requires the position
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 65
|1
−2
∗ −3 |4
+5 −6
|7
−8
+9
Fig. 6: Visualization of Algorithm 7 on (3, 3). It checks all cells in the top-right rectangle associated
with the cell (3, 3) in a left-to-right and bottom-up fashion. No identities are added to the list L.
of an empty cell (x, y) as well as the corresponding maxr and maxc values respectively obtained from
C HECK -B ELOW and C HECK -R IGHT functions.
Fig. 7 illustrates the working of C HECK -B OTTOM -R IGHT function on the empty cell (3, 3). This
function checks all possible identities in the bottom-right area associated with the empty cell (3, 3).
There are four outermost iterations of this function because maxr = 8 and initially we inspect row 4.
These iterations are consecutively illustrated in Fig. 7a, Fig. 7b, Fig. 7c, and Fig. 7d. Here, the cells are
visited in a left-to-right and top-down approach. In the first iteration, the function checks cells (4, 4) and
(4, 5) and finds no identities at such cells. In the second iteration, the function checks cells (5, 4) and
(5, 5) and finds |7 at cell (5, 5). Thus, the list L is added with |7. The third iteration only inspects cell
(6, 4) because any identity in cell (6, 5) is block by |7 at cell (5, 5). Similarly, the last iteration checks
only the cell (7, 4).
Observe that the worst-case scenario of function C HECK -B OTTOM -R IGHT happens when x = 0, y = 0,
maxr = m − 1, maxc = n − 1, and all cells located in the bottom-right area of (x, y) are empty. Thus,
as the time complexity of C HECK -T OP -R IGHT function, the asymptotic upper bound for the running
time of this function is O(mn).
We define the function C HECK -B OTTOM -L EFT to find all possible identities of an empty cell (x, y)
in its associated bottom-left area as an analog of C HECK -T OP -R IGHT and C HECK -B OTTOM -R IGHT
functions. This function requires the position of an empty cell (x, y) as well as the corresponding maxr
and minc values respectively obtained from C HECK -B ELOW and C HECK -L EFT functions.
Fig. 8 depicts the working of C HECK -B OTTOM -L EFT function on the empty cell (3, 3). The function
checks all possible identities in the bottom-left area associated with the empty cell (3, 3). The cells are
visited in a right-to-left and top-down fashion. There are four outermost iterations of this function because
maxr = 8 and initially we inspect row 4. The first, the second, and the third iterations are respectively
illustrated in Fig. 8a, Fig. 8b, and Fig. 8c. In the first iteration illustrated in Fig. 8a, the function finds
+5 in cell (4, 0), adds +5 to L, and sets the column limit for the next iteration to 1. The second iteration
illustrated in Fig. 8b checks the cells (5, 1) and (5, 2). Here, no identities are added to the list L. The
third iteration is depicted in Fig. 8c where the function finds −8 in cell (6, 2) and sets the column limit to
2. The last iteration does not check any cell. A the end of the iteration, C HECK -B OTTOM -L EFT function
adds +5 and −8 to the list L.
Observe that the worst-case scenario of C HECK -B OTTOM -L EFT function happens when x = 0, y =
n−1, maxr = m−1, minc = −1, and all cells located in the bottom-left area of (x, y) are empty. Thus,
as in the time complexity analysis of C HECK -T OP -R IGHT and C HECK -B OTTOM -R IGHT functions, the
asymptotic upper bound for the running time of this function is O(mn).
Reinhard et al.
Solving Tatamibari Puzzle Using Exhaustive... 66
|1 |1
−2 −2
∗ −3 |4 ∗ −3 |4
+5 −6 +5 −6
|7 |7
−8 −8
+9 +9
(a) Visualization of the first iteration for the (b) Visualization of the second iteration for the
outermost loop of C HECK -B OTTOM -R IGHT outermost loop of C HECK -B OTTOM -R IGHT
function. No identities are added to the list L. function. It finds |7 at (5, 5) and adds it to
the list L.
|1 |1
−2 −2
∗ −3 |4 ∗ −3 |4
+5 −6 +5 −6
|7 |7
−8 −8
+9 +9
(c) Visualization of the third iteration for the (d) Visualization of the fourth iteration for the
outermost loop of C HECK -B OTTOM -R IGHT outermost loop of C HECK -B OTTOM -R IGHT
function. No identities are added to the list L. function. No identities are added to the list L.
Fig. 7: Visualization of C HECK -B OTTOM -R IGHT function on the empty cell (3, 3). Here, C HECK -T OP -
R IGHT function is completed before C HECK -B OTTOM -R IGHT function is executed.
|1 |1
−2 −2
∗ −3 |4 ∗ −3 |4
+5 −6 +5 −6
|7 |7
−8 −8
+9 +9
(a) Visualization of the first iteration for (b) Visualization of the second iteration for the
the outermost loop of C HECK -B OTTOM -L EFT outermost loop of C HECK -B OTTOM -L EFT. No
function. It finds +5 and adds it to the list L. identities are added to the list L.
The column limit is set to 1.
|1
−2
∗ −3 |4
+5 −6
|7
−8
+9
(c) Visualization of the third iteration for the
outermost loop of C HECK -B OTTOM -L EFT. It
finds the identity −8 and adds it to the list L.
The column limit is set to 2.
Fig. 8: Visualization of C HECK -B OTTOM -L EFT on the empty cell (3, 3). Here, C HECK -T OP -R IGHT and
C HECK -B OTTOM -R IGHT functions are completed before C HECK -B OTTOM -L EFT function is executed.
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 67
To find all possible identities of an empty cell (x, y) in its associated top-left area we define the function
C HECK -T OP -L EFT which is slightly adapted from the previous C HECK -T OP -R IGHT, C HECK -B OTTOM -
R IGHT, and C HECK -B OTTOM -L EFT functions. This function requires the position of an empty cell
(x, y) as well as the corresponding minr and minc values respectively obtained from C HECK -A BOVE
and C HECK -L EFT functions.
Fig. 9 depicts the working of C HECK -T OP -L EFT function on the empty cell (3, 3). It checks all
possible identities in the top-left area associated with the empty cell (3, 3), namely the cells (2, 0), (2, 1),
and (2, 2). The cells are inspected in a right-to-left and bottom-up way. In Fig. 9, only one iteration is
performed. In this iteration, the algorithm finds −2 in cell (2, 1) and adds it to the list L. Observe that the
worst-case scenario of C HECK -T OP -L EFT function happens when x = m − 1, y = n − 1, minr = −1,
minc = −1, and all cells located in the top-left area of (x, y) are empty. Thus, as in the complexity
analysis of C HECK -T OP -R IGHT, C HECK -B OTTOM -R IGHT, and C HECK -B OTTOM -L EFT functions, the
asymptotic upper bound for the running time of this function is O(mn).
|1
−2
∗ −3 |4
+5 −6
|7
−8
+9
Fig. 9: Visualization of C HECK -T OP -L EFT function on the cell (3, 3). It finds −2 in its only iteration of
the outermost loop and adds it to the list L. Here, C HECK -T OP -R IGHT, C HECK -B OTTOM -R IGHT, and
C HECK -B OTTOM -L EFT functions are completed before C HECK -T OP -L EFT function is executed.
The functions C HECK -T OP -R IGHT, C HECK -B OTTOM -R IGHT, C HECK -B OTTOM -L EFT, and C HECK -
T OP -L EFT are independent of one another and they can be carried out in any order. However, all of
these functions must be executed after the functions C HECK -A BOVE, C HECK -B ELOW, C HECK -L EFT,
and C HECK -R IGHT are completed. Moreover, to minimize the number of cells that must be checked
horizontally, we use the variable ℓ as in Algorithm 7 that is updated whenever we find an identity in
a row-based traversal. The process to find a list L of possible identities for an empty cell (x, y) is
summarized in Algorithm 8. From previous discussion, the functions C HECK -A BOVE, C HECK -B ELOW,
C HECK -L EFT, and C HECK -R IGHT respectively return the tuples (minr, L), (maxr, L), (minc, L), and
(maxc, L).
Algorithm 8 C HECK -P OSSIBLE -R EGION(B, x, y) finds all possible identities of an empty cell (x, y) using
the functions C HECK -A BOVE, C HECK -B ELOW, C HECK -L EFT, C HECK -R IGHT, C HECK -T OP -R IGHT, C HECK -
B OTTOM -R IGHT, C HECK -B OTTOM -L EFT, and C HECK -T OP -L EFT in sequential order.
Input: A Tatamibari instance B of size m × n and the location of the empty cell (x, y).
Output: A list L containing all possible identities for the cell (x, y).
1: L ← an empty list
2: (minr, L) ← C HECK -A BOVE(B, x, y, L)
3: (maxr, L) ← C HECK -B ELOW(B, x, y, L)
4: (minc, L) ← C HECK -L EFT(B, x, y, L)
5: (maxc, L) ← C HECK -R IGHT(B, x, y, L)
6: L ← C HECK -T OP -R IGHT(B, x, y, minr, maxc, L)
7: L ← C HECK -B OTTOM -R IGHT(B, x, y, maxr, maxc, L)
8: L ← C HECK -B OTTOM -L EFT(B, x, y, maxr, minc, L)
9: L ← C HECK -T OP -L EFT(B, x, y, minr, minc, L)
10: return L
The asymptotic upper bound for the running time of Algorithm 8 is described in Lemma 1.
Reinhard et al.
Solving Tatamibari Puzzle Using Exhaustive... 68
Lemma 1. The asymptotic upper bound for the running time of Algorithm 8 for an empty cell (x, y)
within a Tatamibari instance B of size m × n is O(mn).
Proof. Notice that Algorithm 8 consecutively calls the procedure C HECK -A BOVE,C HECK -B ELOW, C HECK -
L EFT, C HECK -R IGHT, C HECK -T OP -R IGHT, C HECK -B OTTOM -R IGHT, C HECK -B OTTOM -L EFT, and C HECK -
T OP -L EFT. From the previous analyses, we have the asymptotic upper bound for each of these algo-
rithms is O(m), O(m), O(n), O(n), O(mn), O(mn), O(mn), O(mn) (resp.). Hence, with assumption
that m, n > 1, the asymptotic upper bound for Algorithm 8 is
O(max{m, m, n, n, mn, mn, mn, mn}) = O(mn).
Algorithm 9 P OSSIBLE -E MPTY(B) returns a pair (E, H) such that E is a list containing the positions of all empty
cells in B and H is a list describing the possible identities for all empty cells.
Input: A Tatamibari instance B of size m × n.
Output: A pair (E, H) such that E is a list that contains the positions of all empty cells in B and H is a list such
that H[i] describes the possible identities of the i-th empty cell in 0-based index convention.
1: E ← an empty list
2: H ← an empty list
3: i ← 0
4: while i < m do
5: j←0
6: while j < n do
7: if B[i][j] = ∗ then
8: add (i, j) to E ▷ E contains the locations of the empty cells in B
9: add C HECK -P OSSIBLE -R EGION(B, m, n, i, j) to H
10: ▷ H is updated with the list of possible identities for cell (i, j)
11: end if
12: j ←j+1
13: end while
14: i←i+1
15: end while
16: return E
17: return H
In Algorithm 9 we assume that the (amortized) worst-case complexity for adding a pair (i, j) to the list
E in line 8 is O(1). This is consistent with the previous analysis of Algorithm 6 and Algorithm 7. For line
9, observe that C HECK -P OSSIBLE -R EGION (B, m, n, i, j) returns a list that contains at most h entries.
Hence, we assume that the (amortized) worst-case complexity for adding a list of possible identities
for cell (i, j) to H is O(h). Observe that, according to Lemma 1, the asymptotic upper bound for the
C HECK -P OSSIBLE -R EGION function in line 9 is O(mn). Thus the total time required to execute line 9
of Algorithm 9 that consists of Algorithm 8 and adding its return value to a list H is O(mn) + O(h) =
O(max{mn, h}) = O(mn), since h ≤ mn. Since the number of iterations for the innermost loop is n
and the number of iterations for the outermost loop is m, the asymptotic upper bound for Algorithm 9
is O((mn) · (mn)) = O(m2 n2 ).
We illustrate the workings of Algorithm 9 using a Tatamibari instance in Fig. 10 as follows. In Fig.
10, the indices of the empty cells in row-major order are (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), and
(2, 1); thus we have:
E = [(0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1)] .
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 69
The list H contains the lists of possible identities for every empty cell, that is, H[i] is a list of possible
identities for the i-th empty cell. Using Fig. 10 as an example, the 0-th empty cell is (0, 1), the 1-st empty
cell is (0, 2), and so on. Moreover, in this example, using the function C HECK -P OSSSIBLE -R EGION in
Algorithm 8, it is clear that every empty cell can be filled with either −1 or −2. Thus, we have:
H = [[−1, −2], [−1, −2], [−1, −2], [−1, −2], [−1, −2], [−1, −2], [−1, −2]] .
−1
−2
Notice that to store E we need to store mn − h pairs of integers (i, j), thus the space requirement
for storing E is 2(mn − h) = O(mn). The space requirement for H is analyzed as follows. Notice that
H = [H[0], H[1], . . . , H[e − 1]] where e = mn − h denotes the number of empty cells in the board. Each
H[i] contains at most h entries of the form id = ⟨symbol⟩⟨number⟩. Assuming that each id requires
two characters, then H[i] contains at most 2h characters. Since H contains e entries of list, the space
requirement for H is bounded by 2h · e = 2h(mn − h) = O(hmn).
C in line 12 takes at most O(e) amortized time. Moreover, when the algorithm terminates, we have
C = [conf ig0 , conf ig1 , . . . , conf igd ] for some d ≤ he , such that conf igi = [idi,0 , idi,1 , . . . , idi,e−1 ]
where e = mn − h and idi,j denotes the possible identity for the j-th empty cell according to the i-th
configuration conf igi where 0 ≤ i ≤ d and 0 ≤ j ≤ e − 1. In other words, C is a list containing at
most he lists, where each list is of size e and the j-th entry of such a list represents a possible identity
for the j-th empty cell. This analysis also infers that the space requirement for C is bounded above by
e · he = (mn − h) · hmn−h = O(mn · hmn−h ).
Algorithm 10 C OMBINATION(H) creates a list containing lists of possible identities for all empty cells.
Input: A list H as described in the output of Algorithm 9.
Output: A list C containing lists of all possible identities for all empty cells, an entry of C is a list of size
e = mn − h and is associated with a unique Tatamibari configuration.
1: p ← length of H ▷ here p = e = mn − h
2: C ← an empty list
3: for i ← 0 to p − 1 do
4: indices[i] ← 0 ▷ indices[i] helps us to track the current element in each H[i]
5: end for
6: while true do
7: i←0
8: while i < p do
9: add H[i][indices[i]] to conf ig ▷ adding a possible identity for the i-th empty cell to conf ig
10: i←i+1
11: end while
12: add conf ig to C ▷ storing possible configurations conf ig to C
13: next ← p − 1
14: while next ≥ 0 and indices[next] + 1 ≥ length of H[next]] do
15: next ← next − 1
16: end while
17: if next < 0 then
18: return C
19: end if
20: indices[next] = indices[next] + 1
21: i ← next + 1
22: while i < p do
23: indices[i] ← 0
24: i←i+1
25: end while
26: end while
The worst-case condition of this Algorithm 10 happens when each H[i] contains exactly h members,
which makes C comprises he lists of possible configurations. As an example, the list C obtained from the
Tatamibari instance in Fig. 10 contains 27 = 128 lists, where each list contains exactly seven members,
each member is either −1 or −2. Thus, the asymptotic upper bound for the running time of Algorithm
10 is O(he ) = O(hmn−h ). For related analysis regarding Algorithm 10, see, e.g., [37].
Each component of the list C corresponds to a unique Tatamibari configuration. For example, consider
the following possible entries of C for the Tatamibari instance given in Fig. 10:
C1 = [−1, −1, −1, −1, −1, −1, −1] ,
C2 = [−1, −1, −1, −1, −1, −2, −2] ,
C3 = [−1, −1, −2, −2, −2, −2, −2] ,
C4 = [−2, −2, −2, −2, −2, −2, −2] .
The lists C1 , C2 , C3 , and C4 respectively correspond to the Tatamibari configurations in Fig. 11a, Fig.
11b, Fig. 11c, and Fig. 11d. From these configurations, only C2 and C3 are Tatamibari solutions.
−1 −1 −1 −1 −1 −1
−1 −1 −1 −1 −1 −1
−1 −1 −2 −2 −2 −2
(a) The Tatamibari configuration that corre- (b) The Tatamibari configuration that corre-
sponds to C1 . sponds to C2 .
−1 −1 −1 −1 −2 −2
−2 −2 −2 −2 −2 −2
−2 −2 −2 −2 −2 −2
(c) The Tatamibari configuration that corre- (d) The Tatamibari configuration that corre-
sponds to C3 . sponds to C4 .
Fig. 11: Tatamibari configurations correspond to C1 , C2 , C3 , and C4 . The gray cells denote the positions
of the initial hints.
dimensional array B whose entries are characters of the form +, −, |, or ∗, where ∗ represents an
empty cell). The algorithm performs the following steps:
1) appending a number to every hint (non-empty cell) in B using I DFIER function described in
Algorithm 5,
2) determining the possible identities (possible regions) of every empty cell in B using P OSSIBLE -
E MPTY function described in Algorithm 9,
3) generating all possible Tatamibari configurations from the list of all possible identities (possible
regions) for all empty cells using C OMBINATION function described in Algorithm 10,
4) checking whether each Tatamibari configuration obtained in step 3 is also a Tatamibari solution
using V ERIFIER function described in Algorithm 4.
The objective of Algorithm 11 is to print every possible Tatamibari solution to an arbitrary Tatamibari
configuration B of size m × n.
Reinhard et al.
Solving Tatamibari Puzzle Using Exhaustive... 72
The asymptotic upper bound for the running time of Algorithm 11 is discussed in Theorem 1.
Theorem 1. The asymptotic upper bound for the running time of Algorithm 11 for an arbitrary Tatamibari
instance B of size m × n with h hints where 0 ≤ h ≤ mn is O(max{m2 n2 , hmn−h · hmn}).
Proof. For brevity, we occasionally denote the number of empty cells by e (e = mn − h). From the
aforementioned analyses, the asymptotic upper bounds for line 1, line 2, and line 3 of Algorithm 11
are respectively O(mn), O(m2 n2 ), and O(he ). Thus, the asymptotic upper bound for lines 1–3 of this
algorithm is O(max{m2 n2 , hmn−h }). This means if the number of empty cells is sufficiently small (i.e.,
he < m2 n2 ), then the asymptotic upper bound for lines 1–3 of E XHAUSTIVE (B, m, n) is O(m2 n2 ).
Observe that there is a doubly-nested loop in lines 5–16. The number of iterations for the innermost loop
in lines 7–10 is equal to the length of E, i.e., the number of empty cells (e). For each possible configuration
obtained by replacing the empty cells with particular identities, we check whether such a configuration
is also a solution using V ERIFIER function described in Algorithm 4 whose upper bound is O(hmn).
Assuming that the print procedure in line 13 takes O(mn) time and e = mn − h < hmn, the asymptotic
upper bound for lines 7–14 is O(max{e, hmn, mn}) = O(max{mn − h, hmn, mn}) = O(hmn). Since
the number of possible configurations (the length of the list C) is bounded above by he , we conclude
that the asymptotic upper bound for lines 5–16 of Algorithm 11 is O(he · hmn) = O(hmn−h · hmn).
By combining the asymptotic upper bounds for lines 1–4 and 5–16, we conclude that the asymptotic
upper bound for Algorithm 11 is
Theorem 1 tells us that, if the number of empty cells, e = mn − h, is sufficiently small, i.e., hmn−h <
m n , then the asymptotic upper bound for the running time of Algorithm 11 is O(m2 n2 ). Notice that
2 2
O(m2 n2 ) is the asymptotic upper bound to put a unique number to every hint, check the positions of
every empty cell, and determine the list of all possible identities for such a cell. On the other hand, if
e = mn − h is sufficiently large, i.e., m2 n2 < hmn−h , then the asymptotic upper bound for the running
time of Algorithm 11 is O(hmn−h · hmn). Observe that O(hmn−h · hmn) is the asymptotic upper bound
to generate all possible configurations of an m × n Tatamibari puzzle with h hints and to verify whether
each of these configurations is also a Tatamibari solution.
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 73
V. C OMPUTATIONAL E XPERIMENTS
This section describes the computational experiments of our proposed exhaustive search algorithm for
solving arbitrary Tatamibari puzzles. Experiments were performed using C++ programming language
and g++ version 11.3.0 compiler on a 64-bit Windows 10 version 21H2 operating system. Here, C++ is
chosen because it is relatively faster than other programming languages such as Java or Python [38]. The
system also used Intel(R) Core(TM) i7-8550U CPU @ 1.80 GHz with 16.0 GB of RAM. We provide
source codes, test cases, and more detailed experimental data used in our experiments for interested
readers in https://github.com/chrisalpha5/TatamibariExhaustive.
−1 −1 −1 −1
−2 −2 −2 −2
Suppose we consider a list S containing several distinct solutions to Tatamibari instances of size m×n.
Given a particular solution A to a Tatamibari instance of size m × n, we can check whether A exists in
S using the Boolean function E XISTS described in Algorithm 12. The asymptotic upper bound for the
running time of this algorithm is O(s), where s is the number of elements of S.
Reinhard et al.
Solving Tatamibari Puzzle Using Exhaustive... 74
Suppose we consider two distinct Tatamibari instances T1 and T2 whose solutions are respectively S1
and S2 . Two Tatamibari solutions S1 and S2 of the same size are considered identical if the partitions
that are associated with S1 and S2 are identical regardless of the number put for the hints. In other words,
S1 and S2 are considered identical if S2 can be obtained from S1 by permuting the number associated
with every symbol in S1 . For example, in Fig. 13, both solutions in Fig. 13c and Fig. 13d are considered
identical because they are associated with the same partition in Fig. 13e.
+1 |1
|2 +2
−3 −3
+1 +1 |2 +2 +2 |1
+1 +1 |2 +2 +2 |1
−3 −3 −3 −3 −3 −3
(c) A solution to the Tatamibari instance in Fig. 13a. (d) A solution to the Tatamibari instance in Fig. 13b.
+ + |
+ + |
− − −
Given a list S of distinct Tatamibari solutions of size m × n and a Tatamibari solution A of the same
size, we describe the function S IMILAR (S, A) in Algorithm 13 to check whether there is a solution
Si ∈ S such that Si and A represent an identical Tatamibari solution regardless of the numbering of the
identity. The asymptotic upper bound for the running time of this algorithm is O(smn), where s is the
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 75
number of elements in S.
Algorithm 13 S IMILAR(S, A) checks if a Tatamibari solution A of size m × n is identical to one of the Tatamibari
solutions in S containing several distinct Tatamibari solutions of size m × n, the identicalness of the solution is
considered from the partitions created by the solutions irrespective of the numbering put to the hints.
Input: A list S containing several distinct solutions to Tatamibari instances of size m × n and a Tatamibari instance
A of the same size.
Output: The function returns true if A is identical to one of the solutions in S regardless of the numbering put to
the hints.
1: i ← 0
2: while i < length of S do
3: b ← true
4: j←0
5: while j < length of S[i] and b do
6: if S[i][j][0] ̸= A[j][0] then ▷ checks if S[i] and A do not have identical symbols of hints
7: b ← false
8: end if
9: j ←j+1
10: end while
11: if b then ▷ S[i] and A have identical symbols of hints
12: initialize an array t with ‘0’
13: j←0
14: while j < length of S[i] do
15: if t[S[i][j][1]] = ‘0’ then
16: t[S[i][j][1]] ← A[j][1] ▷ store the identity number of S[i] in t
17: end if
18: j ←j+1
19: end while
20: j←0
21: while j < length of A do
22: A[j][1] ← t[A[j][1]] ▷ assign the corresponding identity of A in t
23: j ←j+1
24: end while
25: if S[i] = A then
26: return true
27: end if
28: end if
29: i←i+1
30: end while
31: return false
Algorithm 14 M ODIFIED E XHAUSTIVE(B, m, n, SL) finds every possible Tatamibari solution to an arbitrary
Tatamibari configuration B represented as a two-dimensional array of size m × n and stores the solution in a
list SL. The solutions are guaranteed to represent different Tatamibari partitions.
Input: A Tatamibari instance B represented as a two dimensional array of size m × n, the entries of the array are
either +, −, |, or ∗, and a list SL containing the solutions to B.
Output: An updated list SL containing every two-dimensional array that is a solution to the Tatamibari instance
B described in the input (if any solution exists). All solutions are guaranteed to represent different Tatamibari
partitions.
1: B ← I DFIER(B, m, n) ▷ appending a number to every hint using Algorithm 5
2: (E, H) ← P OSSIBLE -E MPTY(B) ▷ determining the positions of empty cells and the list of possible identities
for such cells
3: C ← C OMBINATION(H) ▷ generating all possible Tatamibari configurations using Algorithm 10
4: i ← 0
5: while i < length of C do
6: j←0
7: while j < length of E do
8: B[E[j]][0][E[j]][1] ← C[i][j] ▷ filling B with possible identities
9: j ←j+1
10: end while
11: if V ERIFIER(B, m, n) then
12: if SL is not empty then
13: if not E XIST(SL, B) and not S IMILAR(SL, B) then
14: add B to SL ▷ adding the solution B to the solution list SL
15: end if
16: else
17: add B to SL ▷ B is the first solution to the instance
18: end if
19: end if
20: i←i+1
21: end while
22: return SL
To find the number of different ways for filling an m × n grid with Tatamibari solutions, we need
to generate all possible Tatamibari instances of size m × n. Notice that any Tatamibari instance of size
m × n can be represented using two-dimensional array of size m × n whose entries are either +, −, |, or
∗ (∗ signifies an empty cell). If we ignore an empty instance (an instance with no hints), then there are
4mn − 1 possible ways to create an m × n Tatamibari instance. We first describe Algorithm 15 which
constructs a one-dimensional list L of size mn whose entries are the list [∗, |, −, +]. The output of this
algorithm is then used as an input of Algorithm 10 to construct all m × n Tatamibari instances with h
hints where 1 ≤ h ≤ mn. The asymptotic upper bound for the running time of Algorithm 15 is O(mn).
Algorithm 15 I NITIATE -E MPTY(m, n) constructs a one-dimensional list L of size mn whose entries are the list
[∗, |, −, +].
Input: Two integers m and n respectively represent the number of rows and columns in a Tatamibari puzzle.
Output: A one-dimensional list L of size mn whose entries are the list [∗, |, −, +].
1: i ← 0
2: while i < m do
3: j←0
4: while j < n do
5: add [∗, |, −, +] to L
6: j ←j+1
7: end while
8: i←i+1
9: end while
10: return L
For example, if m = n = 2, then Algorithm 15 produces the list L = [[∗, |, −, +], [∗, |, −, +], [∗, |, −, +],
[∗, |, −, +]]. Notice that, using this list as the input for the function C OMBINATION in Algorithm 10 yields
a list C containing every list of four entries, each is associated with a possible Tatamibari instance of
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 77
Algorithm 16 C OUNT S OLUTION E XHAUSTIVE(m, n) counts the number of distinct solutions to an empty m × n
Tatamibari board using exhaustive search technique.
Input: Two integers m and n respectively denoting the number of rows and columns of the Tatamibari board.
Output: The number of ways to fill m × n Tatamibari board with valid Tatamibari solutions.
1: SL ← an empty list
2: L ← I NITIATE -E MPTY(m, n)
3: C ← C OMBINATION(L)
4: i ← 1
5: while i < length of C do ▷ C[0] corresponds to an empty instance
6: change C[i] to a Tatamibari Instance Bi
7: SL ← M ODIFIED E XHAUSTIVE(Bi , m, n, SL)
8: end while
9: print (length of SL)
Since the running time for M ODIFIED E XHAUSTIVE is bounded by O(max{m2 n2 , hmn−h · hmn}) and
the length of C is 4mn , then the asymptotic upper bound for Algorithm 16 is O(max{4mn m2 n2 , 4mn ·
hmn−h · hmn}). We test Algorithm 14 to find the number of solutions of several Tatamibari instances
of sizes m × n, i.e., S(m, n), for m ∈ {1, 2} and n ∈ {1, . . . , 5}, with at least one hint. Furthermore,
since S(m, n) = S(n, m), we only consider the case where m ≤ n. These values are summarized in
Table I. For example, since S(2, 2) = 7, we have seven distinct Tatamibari solutions of size 2 × 2. These
solutions are depicted in Fig. 14.
n
1 2 3 4 5
m
1 1 2 4 8 16
2 7 36 183 898
TABLE I: The value of S(m, n) for several m and n where m ∈ {1, 2} and n ∈ {1, . . . , 5}.
Notice that in Fig. 14, all solutions represent different partitions, but some of them are identical up
to rotation (90◦ clockwise or counterclockwise rotation, 180◦ clockwise or counterclockwise rotation),
reflection (reflection along the horizontal or vertical line), or combination of both rotation and reflection.
Given two Tatamibari solutions T1 and T2 of the same size, we say T1 and T2 are equivalent if T2 can
be obtained from T1 by performing one or more of the following operations and their combinations:
1) 90◦ clockwise rotation,
2) 90◦ counterclockwise rotation,
3) 180◦ clockwise or counterclockwise rotation,
4) horizontal reflection (i.e., flipping the columns),
5) vertical reflection (i.e., flipping the rows).
For instance, in Fig. 14, the solutions in Fig. 14a, Fig. 14b, Fig. 14c, and Fig. 14d are equivalent.
Furthermore, by considering these equivalent classes, we have three different Tatamibari solutions in
Reinhard et al.
Solving Tatamibari Puzzle Using Exhaustive... 78
a 2 × 2 grid, namely the solution with three partitions (Fig. 14a, Fig. 14b, Fig. 14c, and Fig. 14d),
the solution with two partitions (Fig. 14e and Fig. 14f), and the solution with one partition (Fig. 14g).
Suppose we define Sunique (m, n) as the number of different Tatamibari solutions in an m × n up to the
aforementioned rotations and reflections. The value of Sunique (m, n) for m ∈ {1, 2} and n ∈ {1, . . . , 5}
is summarized in Table II.
n
1 2 3 4 5
m
1 1 2 3 6 10
2 3 20 78 303
TABLE II: The value of Sunique (m, n) for several m and n where m ∈ {1, 2} and n ∈ {1, . . . , 5}.
+1 |2 |1 +2 −1 −1
+3 |2 |1 +3 +2 +3
+1 +2 −1 −1 |1 |2
−3 −3 −2 −2 |1 |2
+1 +1
+1 +1
(g)
Fig. 14: All possible solutions of the 2 × 2 empty Tatamibari puzzle.
For a grid of size m × n, we define T (m, n) as the average running time of three runs for finding the
number of valid Tatamibari solutions to such a grid. We measured the values of T (1, n) for n ∈ {1, . . . 10}
and T (2, n) for n ∈ {2, . . . , 5}. The average running time for finding the number of solutions to an empty
Tatamibari instance of size 1×n where 1 ≤ n ≤ 10 is depicted in Fig. 15, while the average running time
for determining the number of solutions to an empty Tatamibari instance of size 2 × n where 2 ≤ n ≤ 5
is depicted in Fig. 16. We do not conduct further experiments due to the limitations of our computing
environment. However, these empirical results concur with the fact that finding the solutions to Tatamibari
instances using the exhaustive search technique requires an exponential amount of time with respect to
the size of the grid and the number of hints as described in Theorem 1.
We have discussed an exhaustive search approach for solving an arbitrary Tatamibari puzzle. In doing
so, we also provide an O(hmn) time algorithm for verifying whether an m × n Tatamibari configuration
with h hints satisfies four rules of the Tatamibari puzzle. In Theorem 1, we prove that the asymptotic
upper bound for the running time of our proposed method is O(max{m2 n2 , hmn−h ·hmn}), where m×n
is the size of the grid and h is the number of the hints in the puzzle. To the best of our knowledge, this
result also provides the first explicit upper bound for solving arbitrary Tatamibari puzzles using algorithms
that can be implemented without using any specific libraries. Our approach might not be as efficient as
Ind. Journal on Computing Vol. 7, Issue. 3, December 2023 79
Fig. 15: The average running time of three runs for finding the number of solutions to empty Tatamibari
instances of size 1 × n where 1 ≤ n ≤ 10.
Fig. 16: The average running time of three runs for finding the number of solutions to empty Tatamibari
instances of size 2 × n where 2 ≤ n ≤ 5.
the method proposed by Adler et al. [25]. However, our exhaustive search technique does not require
an additional library so that it can be directly used in any standard imperative programming language.
Moreover, we believe that the theoretical and experimental comparisons between the exhaustive search
algorithm and SAT-based (including SMT solver) technique need further exploration.
From an experimental point of view, the test cases used in our research are very limited. This
happens partly because of the limitation of our computing environment. In addition, we believe that
some theoretical adjustment regarding Algorithm 16 is required to determine the value of S(m, n) for
larger m and n. For example, one can determine the maximum number of hints in an m × n Tatamibari
puzzle so that such a puzzle has a solution. Another interesting open problem is determining the minimum
number of hints so that a Tatamibari instance is guaranteed to have a unique solution.
R EFERENCES
[7] M. Holzer, A. Klein, and M. Kutrib, “On the NP-completeness of the Nurikabe pencil puzzle and variants thereof,” in
Proceedings of the 3rd International Conference on FUN with Algorithms. Citeseer, 2004, pp. 77–89.
[8] T. Yato and T. Seta, “Complexity and completeness of finding another solution and its application to puzzles,” IEICE
transactions on fundamentals of electronics, communications and computer sciences, vol. 86, no. 5, pp. 1052–1060, 2003.
[9] A. Ishibashi, Y. Sato, and S. Iwata, “NP-completeness of two pencil puzzles: Yajilin and Country Road,” Utilitas Mathematica,
vol. 88, pp. 237–246, 2012.
[10] C. Iwamoto and T. Ibusuki, “Dosun-Fuwari is NP-complete,” Journal of Information Processing, vol. 26, pp. 358–361, 2018.
[11] A. Uejima and H. Suzuki, “Fillmat is NP-complete and ASP-complete,” Journal of Information Processing, vol. 23, no. 3,
pp. 310–316, 2015.
[12] C. Iwamoto and T. Ide, “Five Cells and Tilepaint are NP-Complete,” IEICE TRANSACTIONS on Information and Systems,
vol. 105, no. 3, pp. 508–516, 2022.
[13] D. Andersson, “Hashiwokakero is NP-complete,” Information Processing Letters, vol. 109, no. 19, pp. 1145–1146, 2009.
[14] C. Iwamoto, M. Haruishi, and T. Ibusuki, “Herugolf and Makaro are NP-complete,” in 9th International Conference on Fun
with Algorithms (FUN 2018). Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, 2018.
[15] M. Holzer and O. Ruepp, “The troubles of interior design–a complexity analysis of the game Heyawake,” in International
Conference on Fun with Algorithms. Springer, 2007, pp. 198–212.
[16] D. Andersson, “Hiroimono is NP-complete,” in International Conference on Fun with Algorithms. Springer, 2007, pp. 30–39.
[17] C. Iwamoto and T. Ibusuki, “Polynomial-Time Reductions from 3SAT to Kurotto and Juosan Puzzles,” IEICE Transactions
on Information and Systems, vol. 103, no. 3, pp. 500–505, 2020.
[18] J. Kölker, “Kurodoko is NP-complete,” Information and Media Technologies, vol. 7, no. 3, pp. 1000–1012, 2012.
[19] C. Iwamoto and T. Ide, “Moon-or-Sun, Nagareru, and Nurimeizu are NP-complete,” IEICE Transactions on Fundamentals
of Electronics, Communications and Computer Sciences, p. 2021DMP0006, 2022.
[20] Y. Takenaga, S. Aoyagi, S. Iwata, and T. Kasai, “Shikaku and Ripple Effect are NP-complete,” Congressus Numerantium,
vol. 216, pp. 119–127, 2013.
[21] E. D. Demaine, Y. Okamoto, R. Uehara, and Y. Uno, “Computational complexity and an integer programming model of
Shakashaka,” IEICE Transactions on Fundamentals of Electronics, Communications and Computer Sciences, vol. 97, no. 6,
pp. 1213–1219, 2014.
[22] C. Iwamoto and M. Haruishi, “Computational complexity of Usowan puzzles,” IEICE Transactions on Fundamentals of
Electronics, Communications and Computer Sciences, vol. 101, no. 9, pp. 1537–1540, 2018.
[23] E. D. Demaine, J. Lynch, M. Rudoy, and Y. Uno, “Yin-Yang Puzzles are NP-complete,” in 33rd Canadian Conference on
Computational Geometry (CCCG) 2021, 2021.
[24] C. Iwamoto, “Yosenabe is NP-complete,” Journal of Information Processing, vol. 22, no. 1, pp. 40–43, 2014.
[25] A. Adler, J. Bosboom, E. D. Demaine, M. L. Demaine, Q. C. Liu, and J. Lynch, “Z3-based Tatamibari solver, and figures
from Tatamibari NP-hardness paper,” https://github.com/jbosboom/tatamibari-solver, Feb. 2020, accessed: 2022-07-28.
[26] J. J. W. Bosboom, “Exhaustive search and hardness proofs for games,” Ph.D. dissertation, Massachusetts Institute of
Technology, 2020.
[27] T. Weber, “A SAT-based Sudoku solver,” in LPAR, 2005, pp. 11–15.
[28] I. Lynce and J. Ouaknine, “Sudoku as a SAT Problem,” in AI&M, 2006.
[29] U. Pfeiffer, T. Karnagel, and G. Scheffler, “A Sudoku-Solver for Large Puzzles using SAT,” in LPAR short papers (Yogyakarta),
2010, pp. 52–57.
[30] M. Z. Musa, “Interactive Sudoku Solver Using Propositional Logic in Python,” Bachelor Thesis, Undergraduate Program of
Informatics, School of Computing, Telkom University, 2018.
[31] A. Shaleh, “Solving Shikaku Using Propositional Logic Approach,” Bachelor Thesis, Undergraduate Program of Informatics,
School of Computing, Telkom University, 2019.
[32] M. d. Berg and A. Khosravi, “Optimal binary space partitions in the plane,” in International Computing and Combinatorics
Conference. Springer, 2010, pp. 216–225.
[33] StackOverflow, “What is Constant Amortized Time?” https://stackoverflow.com/questions/200384/
what-is-constant-amortized-time, Oct. 2008, accessed: 2022-12-20.
[34] ——, “Why is the time complexity of Python’s list.append() method O(1)?” https://stackoverflow.com/questions/33044883/
why-is-the-time-complexity-of-pythons-list-append-method-o1, Oct. 2015, accessed: 2022-12-20.
[35] Quora, “What is algorithmic complexity of push_back in std::vector? (Assume default allocator),” https://www.quora.com/
What-is-algorithmic-complexity-of-push_back-in-std-vector-Assume-default-allocator, Dec. 2022, accessed: 2022-12-20.
[36] A. Sharma, “Combinations from n arrays picking one element from each array,” https://www.geeksforgeeks.org/
combinations-from-n-arrays-picking-one-element-from-each-array/, Apr. 2022, accessed: 2022-04-27.
[37] P. Vaillancourt, “Algorithm to generate combinations of n elements from n sets of m elements,” https://cs.stackexchange.
com/questions/125752/algorithm-to-generate-combinations-of-n-elements-from-n-sets-of-m-elements, May 2020, accessed:
2022-12-23.
[38] L. Prechelt, “Are scripting languages any good? A validation of Perl, Python, Rexx, and Tcl against C, C++, and Java.” Adv.
Comput., vol. 57, pp. 205–270, 2003.
[39] E. D. Demaine, “Tatamibari Font,” https://github.com/edemaine/font-tatamibari, Apr. 2022, accessed: 2022-05-11.