An FPT algorithm for orthogonal buttons and scissors

TL;DR

This paper presents a fixed-parameter tractable algorithm for the Buttons and Scissors puzzle, enabling efficient solutions when the number of cuts is limited, by analyzing the problem's complexity in terms of the number of cuts.

Contribution

The paper introduces a novel fixed-parameter tractable algorithm for Buttons and Scissors based on the number of cuts, improving understanding of its computational complexity.

Findings

Algorithm runs in $2^{O(k^2 \log k)} (n+m)^{O(1)}$ time

Efficiently solves instances with bounded number of cuts

Advances complexity analysis of puzzle games

Abstract

We study the puzzle game Buttons and Scissors in which the goal is to remove all buttons from an $n\times m$ grid by a series of horizontal and vertical cuts. We show that the corresponding parameterized problem has an algorithm with time complexity $2^{O(k^2 \log k)} (n+m)^{O(1)}$, where $k$ is an upper bound on the number of cuts.

Full text

Keywords

Combinatorial puzzles; Parameterized complexity.

1 Introduction

In the Buttons and Scissor puzzle one is given an $n\times m$ grid, where some of the cells of the grid contain buttons. Each button has a color. The goal is to remove all buttons from the grid by applying cuts. A cut is a sequence $C=((i_{1},j_{1}),\ldots,(i_{p},j_{p}))$ of grid cells with the following properties.

The cell $(i_{1},j_{1})$ and $(i_{p},j_{p})$ contain buttons. 2. 2.

All the buttons in the cells of $C$ have the same color. 3. 3.

$C$ has one of the following forms.

1. (a)

$i_{1}=\cdots=i_{p}$ and $j_{l+1}=j_{l}+1$ for all $l<p$. 2. (b)

$j_{1}=\cdots=j_{p}$ and $i_{l+1}=i_{l}+1$ for all $l<p$. 3. (c)

$i_{l+1}=i_{l}+1$ and $j_{l+1}=j_{l}+1$ for all $l<p$.

The cuts of the first, second, and third form above are called horizontal cuts, vertical cuts, and diagonal cuts, respectively. The application of a cut $C$ deletes all the buttons in the cells of $C$. A horizontal cut $C=((i,j_{1}),\ldots,(i,j_{p}))$ will also be denoted $\{i\}\times[j_{1},j_{p}]$ and a vertical cut $C=((i_{1},j),\ldots,(i_{p},j))$ will also be denoted $[i_{1},i_{p}]\times\{j\}$. See Figure 1 for an example.

The Buttons and Scissors puzzle can be formulated as a decision problem as follows. The input is an $n\times m$ matrix $B$ representing the buttons and an integer $k$, and the goal is to decide whether all buttons can be removed using at most $k$ cuts. The matrix $B$ represents the buttons as follows. If $B[i,j]=0$ then there is no button at cell $(i,j)$. If $B[i,j]=c>0$ then there is a button with color $c$ at cell $(i,j)$. The orthogonal buttons and scissor problem is a variant of the buttons and scissors problem in which only vertical and horizontal cuts are allowed.

Both the buttons and scissors problem and the orthogonal button and scissor problem are NP-hard [3]. Some variants of this problem were studied in [2].

Agrawal et al. [1] claimed to give an FTP algorithm for the orthogonal buttons and scissors problem. However, there is an error in their algorithm. In [1], a row block is defined to be a maximal interval $[a,b]$ of rows of $B$ such that all the non-zeros rows in the block are identical. It is claimed that if the number of row blocks is at least $2k+1$ then $(B,k)$ is a no instance. However, this is not true. Suppose that $B$ is an $n\times 2$ matrix defined as follows. For odd $i$, $B[i,1]=1$ and $B[i,2]=0$. For even $i$, $B[i,1]=0$ and $B[i,2]=2$. The number of row blocks is $n/2$ while all the buttons in $B$ can be removed using two vertical cuts.

In this paper we give an algorithm for the orthogonal buttons and scissors problem whose time complexity is $2^{O(k^{2}\log k)}(n+m)^{O(1)}$.

2 The algorithm

Let $(B,k)$ be an instance of the orthogonal buttons and scissors problem. A solution for $(B,k)$ is a sequence of at most $k$ cuts whose application remove all the buttons in $B$. We say that a cut $C$ is contained in row $i$ (resp., column $j$) if $C\subseteq\{i\}\times[1,m]$ (resp., $C\subseteq[1,n]\times\{i\}$). A cut $C$ touches row $i$ if $C\cap(\{i\}\times[1,m])\neq\emptyset$. A row or column of $B$ is called heavy if it contains at least $k+1$ buttons, and light otherwise. A button is heavy if it is in some heavy row or column. Otherwise, the button is light.

For a set of rows $X$ and a set of column $Y$, $B[X,Y]$ is a sub-matrix of $B$ containing the elements $B[x,y]$ for $x\in X$ and $y\in Y$. A row block is a set $X$ of consecutive row indices such that for every column $j$, all the buttons in $B[X,\{j\}]$ have the same color. For a row block $X$, let $J_{X}$ be a set containing every column index $j$ such that $B[X,\{j\}]$ contains at least one button, and let $J^{\prime}_{X}$ be a set containing every column index $j$ such that $B[X,\{j\}]$ contains between $1$ and $k+1$ buttons.

We now present our algorithm. The algorithm first repeatedly applies the reduction rules given below. When no reduction rule is applicable, the algorithm solves the reduced instance.

(1)  If there are at more than $k$ heavy rows or more than $k$ heavy columns, return no.

Lemma 1**.**

Rule (1) is safe.

Proof.

Suppose that $(B,k)$ is yes instance and let $\mathcal{S}$ be a solution for $(B,k)$. If no cut of $\mathcal{S}$ is contained in row $i$ then row $i$ is light since a cut in $\mathcal{S}$ can remove at most one button from row $i$ of $B$. Therefore, the number of heavy rows is at most $|\mathcal{S}|\leq k$. Similarly, the number of heavy rows is at most $k$. Therefore, Rule (1) is safe. ∎

(2)  If there are more than $k^{2}$ light buttons, return no.

Lemma 2**.**

Rule (2) is safe.

Proof.

Suppose that $(B,k)$ is yes instance and let $\mathcal{S}$ be a solution for $(B,k)$. Let $C\in\mathcal{S}$ be a horizontal cut that is contained in row $i$. If row $i$ is heavy then $C$ does not remove light buttons. Otherwise, $C$ removes at most $k$ light buttons. Similarly, a vertical cut $C\in\mathcal{S}$ removes at most $k$ light buttons. Since every button must be removed by a cut in $\mathcal{S}$, it follows that there are at most $k^{2}$ light buttons. ∎

(3)  If row $i$ (resp., column $j$) does not contain buttons, delete row $i$ (resp., column $j$) from $B$.

The following reduction rule is adapted from Rule 2 in [1]. For completeness, we give a full proof of the safeness of the rule.

(4)  Suppose that there is row block $X=[a,b]$ and an index $i_{0}\in X$ such that for every column $j$, either (1) $B[X,\{j\}]$ does not contain buttons, or (2) there are at least $k$ buttons in $B[[a,i_{0}-1],\{j\}]$ and at least $k$ buttons in $B[[i_{0}+1,b],\{j\}]$. Return the instance $(B^{\prime},k)$, where $B$ is a matrix obtained from $B$ by deleting all the buttons in row $i_{0}$ of $B$.

Lemma 3**.**

Rule (4) is safe.

Proof.

We need to show that $(B,k)$ is a yes instance if and only if $(B^{\prime},k)$ is a yes instance. To prove the first direction we use following claim.

Claim 4**.**

If $(B,k)$ is a yes instance, there is a solution $\mathcal{S}$ for $(B,k)$ such that no cut of $\mathcal{S}$ is contained in a row of $X$. Additionally, there is no vertical cut in $\mathcal{S}$ with endpoint $(i_{0},j)$ for some column $j$.

Proof.

Suppose that $(B,k)$ is yes instance, and let $\mathcal{S}_{0}$ be a solution for $(B,k)$. We construct a new solution $\mathcal{S}$ by generating a cut $C^{\prime}$ for every cut $C$ in $\mathcal{S}_{0}$. If $C$ is cut in $\mathcal{S}_{0}$ that does not touch any row in $X$ then the corresponding cut in $\mathcal{S}$ is $C^{\prime}=C$. If $C$ is a horizontal cut in $\mathcal{S}_{0}$ that is contained in a row in $X$ then the corresponding cut in $\mathcal{S}$ is $C^{\prime}=\emptyset$.

Let $j$ be some column. If $B[X,\{j\}]$ does not contain buttons then for every vertical cut $C$ in $\mathcal{S}_{0}$ such that $C$ is contained in column $j$ and $C$ touches at least one row of $X$, the corresponding cut in $\mathcal{S}$ is $C^{\prime}=C$.

Now suppose that $B[X,\{j\}]$ contains buttons. Due to the condition of Rule (4), $B[X,\{j\}]$ contains at least $2k$ buttons. Therefore, there is an index $i^{\prime}\in X$ such that $B[i^{\prime},j]\neq 0$ and there is no cut in $\mathcal{S}_{0}$ that is contained in row $i^{\prime}$. Therefore, the cut in $\mathcal{S}_{0}$ that removes the button $B[i^{\prime},j]$ is a vertical cut.

Let $C^{*}=[a^{*},b^{*}]\times\{j\}$ be the last vertical cut in $\mathcal{S}_{0}$ such that the application of $C^{*}$ (after the application of the preceding cuts in $\mathcal{S}_{0}$) removes at least one button in $B[X,\{j\}]$. Note that $C^{*}$ exists since $B[i^{\prime},j]$ is removed by a vertical cut. If $C$ is a vertical cut in $\mathcal{S}_{0}$ that is contained in column $j$, touches at least one row of $X$, and appears after $C^{*}$ in $\mathcal{S}_{0}$, then the corresponding cut in $\mathcal{S}$ is $C^{\prime}=C$. Now, let $C=[a^{\prime},b^{\prime}]\times\{j\}$ be a vertical cut in $\mathcal{S}_{0}$ that touches at least one row of $X$ and appears before $C^{*}$ in $\mathcal{S}_{0}$. The interval $[a^{\prime},b^{\prime}]$ cannot contain the interval $[a,b]$ otherwise we get a contradiction to the definition of $C^{*}$. Therefore, there are three possible cases.

$a^{\prime}\geq a$ and $b^{\prime}\leq b$, and at least one inequality is strict. 2. 2.

$a^{\prime}<a$ and $a\leq b^{\prime}<b$. 3. 3.

$a<a^{\prime}\leq b$ and $b^{\prime}>b$.

If $C$ is a cut in $\mathcal{S}_{0}$ of the first type above then the corresponding cut in $\mathcal{S}$ is $C^{\prime}=\emptyset$. Now, let $C_{1},\ldots,C_{s}$ be the cuts in $\mathcal{S}_{0}$ of the second type, according to their order in $\mathcal{S}_{0}$ (note that $s$ can be zero). Denote $C_{l}=[a_{l},b_{l}]\times\{j\}$. Since the application of $C_{l}$ removes all buttons in $B[[a_{l},b_{l}],\{j\}]$, we have that $a\leq b_{1}<b_{2}<\cdots<b_{s}$. Let $i_{1}<\cdots<i_{k}$ be the row indices of the top $k$ buttons in $B[X,\{j\}]$. For each cut $C_{l}$, the corresponding cut in $\mathcal{S}$ is $C^{\prime}_{l}=[a_{l},i_{l}]\times\{j\}$. The cuts of the third type are handled analogously: Let $\hat{C}_{1},\ldots,\hat{C}_{t}$ be the cuts $\mathcal{S}_{0}$ of the third type, where $\hat{C}_{l}=[\hat{a}_{l},\hat{b}_{l}]\times\{j\}$. Let $\hat{\imath}_{1}>\cdots>\hat{\imath}_{k}$ be the row indices of the bottom $k$ buttons in $B[X,\{j\}]$. For each cut $\hat{C}_{l}$, the corresponding cut in $\mathcal{S}$ is $\hat{C}^{\prime}_{l}=[\hat{\imath}_{l},\hat{b}_{l}]\times\{j\}$. Finally, the cut that corresponds to $C^{*}$ is $[\min(a^{*},i_{s}),\max(b^{*},\hat{\imath}_{t})]\times\{j\}$.

It is easy to show by induction that the cuts in $\mathcal{S}$ are valid cuts (namely, every cut contains buttons of the same color, and the endpoints of the cut contains buttons) and that the application of the cuts of $\mathcal{S}$ removes all the buttons of $B$. Therefore, $S$ is a solution for $(B,k)$. ∎

Suppose that $(B,k)$ is a yes instance. Let $\mathcal{S}$ be the solution of Claim 4 for $(B,k)$. Since there is no cut in $\mathcal{S}$ with endpoint $(i_{0},j)$ for some $j$, $\mathcal{S}$ is also a solution for $(B^{\prime},k)$. Therefore, $(B^{\prime},k)$ is a yes instance.

The proof of the opposite direction is similar. Suppose that $(B^{\prime},k)$ is a yes instance. Using the same arguments used to prove Claim 4, we have that there is a solution $\mathcal{S}$ for $(B^{\prime},k)$ such that no cut of $\mathcal{S}$ is contained in a row of $X$. We now generate a solution $\mathcal{S}_{2}$ for $(B,k)$ by generating a cut $C^{\prime}$ for every cut $C$ in $\mathcal{S}$. Let $j$ be a column of $B$ such that $B[i_{0},j]\neq 0$. Let $i_{1}$ be the minimum index such that $i_{1}>i_{0}$ and $B[i_{1},j]\neq 0$. Let $C_{j}=[a_{j},b_{j}]\times\{j\}$ be the cut in $\mathcal{S}$ whose application removes the button $B[i_{1},j]$. If $a_{j}=i_{1}$ then the corresponding cut in $\mathcal{S}_{2}$ is $[i_{0},b_{j}]\times\{j\}$. Otherwise, the corresponding cut in $\mathcal{S}_{2}$ is $C^{\prime}_{j}=C_{j}$. For a cut $C$ in $\mathcal{S}$ that is not one of the cuts $C_{j}$ above, the corresponding cut in $\mathcal{S}_{2}$ is $C^{\prime}=C$. It is easy to verify that $\mathcal{S}_{2}$ is a solution for $(B,k)$. Therefore, $(B,k)$ is a yes instance. ∎

(5)  If the number of rows is more than $(4k^{2}+1)(k+1)k(4k+6)^{k}$ return no.

Lemma 5**.**

Rule (5) is safe.

Proof.

Suppose that $(B,k)$ is yes instance and let $\mathcal{S}$ be a solution for $(B,k)$.

We first show that the rows of $B$ can be partitioned into at most $4k^{2}+1$ row blocks. Define $I_{0}$ to be a set containing $i$ and $i+1$ for every heavy row $i$. Let $j$ be some column. If $j$ is a light column, define $I_{j}=\{i,i+1\colon B[i,j]\neq 0\}$. If $j$ is a heavy column, let $I_{j}$ be the set of all indices $i$ such that $B[i,j]\neq 0$ and $B[i,j]\neq B[i^{\prime},j]$, where $i^{\prime}$ is the maximum index such that $i^{\prime}<i$ and $B[i^{\prime},j]\neq 0$ (if the index $i^{\prime}$ does not exist, the index $i$ is not in $I_{j}$). Let $I=\bigcup_{j=0}^{m}I_{j}$. We partition $[1,n]$ into row blocks according to $I$ as follows. Suppose that $I=\{i_{1},\ldots i_{p}\}$ where $i_{1}<i_{2}<\cdots<i_{p}$ and denote $i_{p+1}=n$. The row blocks are $[i_{l},i_{l+1}-1]$ for every $l\leq p$. Additionally, if $i_{1}>1$ we define the row block $[1,i_{1}-1]$. It is clear from the definition of $I$ that each generated interval is a row block.

We now give an upper bound on $|I|$. The heavy rows generate at most $2k$ elements in $I$ (since there are at most $k$ heavy rows). We next consider the contribution of the light columns to $I$. Since we already bounded the number of indices generated by the heavy rows, we only need to consider the light buttons in the light columns. These buttons generate at most $2k^{2}$ elements in $I$ (since there are at most $k^{2}$ light buttons).

We now consider some heavy column $j$. Suppose we remove buttons from $B$ according to the cuts of $\mathcal{S}$, and after each removal we update $I_{j}$. Each cut $C$ in $\mathcal{S}$ (except the last) can decrease the size of $I_{j}$ by at most 2: The cut $C$ can remove all the buttons in $B[[i_{l},i_{l+1}-1],\{j\}]$ for some specific $l$. This causes the removal of $i_{l}$ from $I_{j}$. Additionally, if $B[i_{l-1},j]=B[i_{l+1},j]$ then $i_{l+1}$ will also be removed from $I_{j}$. After all the cuts of $\mathcal{S}$ are applied, $I_{j}=\emptyset$. It follows that before applying the cuts, $|I_{j}|\leq 2(k-1)$. Therefore, column $j$ generates at most $2k$ elements in $I$. Since there are at most $k$ heavy columns, we conclude that $|I|\leq 2k+2k^{2}+2(k-1)k=4k^{2}$. Therefore, the number of generated row blocks is at most $4k^{2}+1$.

We now partition the row blocks generated above to sub-blocks. We perform a recursive procedure on every block $X_{0}$ generated above whose size is at least 2. Note that for such block, $B[X_{0},[1,m]]$ contains buttons only in heavy columns and therefore $|J_{X_{0}}|\leq k$. Denote by $X=[a,b]$ the current block given to the recursive procedure. The recursion stops when $J^{\prime}_{X}=J_{X}$. Note that in this case, $|X|\leq(k+1)k$ since every row of $X$ contains at least one button (otherwise Rule (2) can be applied) and by the definition of $J^{\prime}_{X}$, the number of buttons in $B[X,[1,m]]$ is at most $(k+1)|J_{X}|\leq(k+1)k$ ($|J_{X}|\leq k$ since every column $j\in J_{X}$ is heavy).

Now suppose that $J^{\prime}_{X}\neq J_{X}$. We consider two cases. In Case 1, $J^{\prime}_{X}\neq\emptyset$. In this case, arbitrarily pick $j\in J^{\prime}_{X}$. Let $i_{1}<i_{2}<\cdots<i_{p}$ be the row numbers of the buttons in $B[X,\{j\}]$, and define $i_{0}=0$ and $i_{p+1}=n+1$. We partition $X$ into sub-blocks $\{i_{l}\}$ for every $1\leq l\leq p$, and $[i_{l}+1,i_{l+1}-1]$ for every $0\leq l\leq p$ such that $i_{l+1}>i_{l}+1$. We then continue recursively on each of these sub-blocks. Note that the number of sub-blocks generated from $X$ is at most $2k+3$. Moreover, for every generated sub-block $X^{\prime}$ of size at least 2 we have $j\notin J_{X^{\prime}}$ and therefore $|J_{X^{\prime}}|\leq|J_{X}|-1$. Since $|J_{X_{0}}|\leq k$ for the initial block $X_{0}$, it follows that the number of times Case 1 can occur during a chain of recursive calls is at most $k$.

In Case 2, $J^{\prime}_{X}=\emptyset$. For every $j\in J_{X}$, let $i_{j}$ be the row number of the $(k+1)$-th button from the top in $B[X,\{j\}]$. Let $i=\max\{i_{j}\colon j\in J_{X}\}$ and let $j^{*}$ be the column such that $i=i_{j^{*}}$. We create two sub-blocks $X_{1}=[a,i]$ and $X_{2}=[i+1,b]$ and continue recursively on each of these sub-blocks. Note that $j^{*}\in J^{\prime}_{X_{1}}$ and in particular $J^{\prime}_{X_{1}}\neq\emptyset$. Additionally, there is at least one column $j\in J_{X}$ such that the number of buttons in $B[X_{2},\{j\}]$ is less than $k$, since otherwise Rule (2) can be applied on $X$ with $i_{0}=i$. Therefore, $J^{\prime}_{X_{2}}\neq\emptyset$. It follows that the number of times Case 2 can occur during a chain of recursive calls is bounded by the number of times Case 1 can occur.

From the above, we have that the number of sub-blocks generated from some block $X_{0}$ is at most $(4k+6)^{k}$. Therefore, the number of rows in $B$ is at most $(4k^{2}+1)(4k+6)^{k}(k+1)k$. It follows that Rule (5) is safe. ∎

We also use additional reduction rules, Rule (2) and Rule (2), that are analogous to Rule (2) and Rule (3), respectively. If these rules cannot be applied, the number of columns in $B$ is at most $(4k^{2}+1)(k+1)k(4k+6)^{k}$.

(8)  If the number of buttons is at least $k\cdot\max(n,m)+1$, return no.

The safeness of Rule (8) is proved in [1]. The following lemma is also proved in [1].

Lemma 6**.**

Let $(B,k)$ be an instance of orthogonal buttons and scissors such that $B$ contains $l$ buttons. Then, the instance can be solved in $l^{2k}(n+m)^{O(1)}$ time.

Let $(B,k)$ be an instance on which the above reduction rules cannot be applied. Since Rule (3), Rule (2), and Rule (5) cannot be applied, the number of buttons in $B$ is $2^{O(k\log k)}$. By Lemma 6, the instance $(B,k)$ can be solved in $2^{O(k^{2}\log k)}(n+m)^{O(1)}$ time.