An Algorithmic Analysis of the
HoneyBee Game^{†}^{†}thanks: RF acknowledges
support by
the National Natural Science Foundation of China (No. 60973026),
the Shanghai Leading Academic Discipline Project (project number B114),
the Shanghai Committee of Science and Technology of China (09DZ2272800),
and the Robert Bosch Foundation (Science Bridge China 32.5.8003.0040.0).
GJW acknowledges support by
the Netherlands Organisation for Scientific Research (NWO grant 639.033.403),
and by BSIK grant 03018 (BRICKS: Basic Research in Informatics for Creating
the Knowledge Society).
Abstract
The HoneyBee game is a twoplayer board game that is played on a connected hexagonal colored grid or (in a generalized setting) on a connected graph with colored nodes. In a single move, a player calls a color and thereby conquers all the nodes of that color that are adjacent to his own current territory. Both players want to conquer the majority of the nodes. We show that winning the game is PSPACEhard in general, NPhard on seriesparallel graphs, but easy on outerplanar graphs.
In the solitaire version, the goal of the single player is to conquer the entire graph with the minimum number of moves. The solitaire version is NPhard on trees and split graphs, but can be solved in polynomial time on cocomparability graphs.
Keywords: combinatorial game; computational complexity; graph problem.
1 Introduction
The HoneyBee game is a popular twoplayer board game that shows up in many different variants and at many different places on the web (the game is best be played on a computer). For a playable version we refer the reader for instance to Axel Born’s webpage [1]; see Fig. 1 for a screenshot. The playing field in HoneyBee is a grid of hexagonal honeycomb cells that come in various colors; the coloring changes from game to game. The playing field may be arbitrarily shaped and may contain holes, but must always be connected. In the beginning of the game, each player controls a single cell in some corner of the playing field. Usually, the playing area is symmetric and the two players face each other from symmetrically opposing starting cells. In every move a player may call a color , and thereby gains control over all connected regions of color that have a common border with the area already under his control. The only restriction on is that it cannot be one of the two colors used by the two players in their last move before the current move, respectively. A player wins when he controls the majority of all cells. On Born’s webpage [1] one can play against a computer, choosing from four different layouts for the playing field. The computer uses a simple greedy strategy: “Always call the color that maximizes the immediate gain.” This strategy is shortsighted and not very strong, and an alert human player usually beats the computer after a few practice matches.
In this paper we perform a complexity study of the HoneyBee game when played by two players on some arbitrary connected graph instead of the hexgrid of the original game. We will show in Section 4 that HoneyBee2Players is NPhard even on seriesparallel graphs, and that it is PSPACEcomplete in general. On outerplanar graphs, however, it is quite easy to compute a winning strategy.
In the solitaire (singleplayer) version of HoneyBee the goal is to conquer the entire playing field as quickly as possible. Intuitively, a good strategy for the solitaire game will be close to a strong heuristic for the twoplayer game. For the solitaire version, our results draw a sharp separation line between easy and difficult cases. In particular, we show in Section 3 that HoneyBeeSolitaire is NPhard for split graphs and for trees, but polynomialtime solvable on cocomparability graphs (which include interval graphs and permutation graphs). Thus, the complexity of the game is wellcharacterized for the class and subclasses of perfect graphs; see Fig. 2 for a summary of our results.
2 Definitions
We model HoneyBee in the following graphtheoretic setting. The playing field is a connected, simple, loopless, undirected graph . There is a set of colors, and every node is colored by some color ; we stress that this coloring does not need to be proper, that is, there may be edges with . For a color , the subset contains the nodes of color . For a node and a color , we define the colorneighborhood as the set of nodes in either adjacent to or connected to by a path of nodes of color . Similarly, we denote by the colorneighborhood of a subset . For a subset and a sequence of colors in , we define a corresponding sequence of node sets and , for . We say that sequence started on conquers the final node set in moves, and we denote this situation by . The nodes in are called free nodes.
In the solitaire version of HoneyBee, the goal is to conquer the entire playing field with the smallest possible number of moves. Note that HoneyBeeSolitaire is trivial in the case of only two colors. But as we will see in Section 3, the case of three colors can already be difficult.
Problem HoneyBeeSolitaire Input: A graph ; a set of colors and a coloring ; a start node ; and a bound . Question: Does there exist a color sequence of length such that ?
In the twoplayer version of HoneyBee, the two players and start from two distinct nodes and and then extend their regions step by step by alternately calling colors. Player makes the first move. One round of the game consists of a move of followed by a move of . Consider a round, where at the beginning the two players control node sets and , respectively. If player calls color , then he extends his region to . If afterwards player calls color , then he extends his region to . Note that once a player controls a node, he can never lose it again.
The game terminates as soon as one player controls more than half of all nodes. This player wins the game. To avoid draws, we require that the number of nodes is odd. There are three important rules that constrain the colors that a player is allowed to call.

A player must never call the color that has just been called by the other player.

A player must never call the color that he has called in his previous move.

A player must always call a color that strictly enlarges his territory, unless rules R1 and R2 prevent him from doing so.
What is the motivation for these three rules? Rule R1 is a technical condition that arises from the graphical implementation [1] of the game: Whenever a player calls a color , his current territory is entirely recolored to color . This makes it visually easier to recognize the territories controlled by both players. Rule R2 prevents the players from permanently blocking some color for the opponent. Fig. 3 shows a situation where rule R2 actually prevents the game from stalling. Rule R3 is quite delicate, and is justified by situations as depicted in Fig. 4. Rule R3 guarantees that every game must terminate with either a win for player A or a win for player B. Note that rule R2 is redundant except in the case when a player has no move to gain territory (see Fig. 3.
Problem HoneyBee2Players Input: A graph with an odd number of nodes; a set of colors and a coloring ; two start nodes . Question: Can player enforce a win when the game is played according to the above rules?
Note that HoneyBee2Players is trivial in the case of only three colors: The players do not have the slightest freedom in choosing their next color, and always must call the unique color allowed by rules R1 and R2. However we will see in Section 4 that the case of four colors can already be difficult.
Finally we observe that calling a color always conquers all connected components induced by that are adjacent to the current territory. Hence an equivalent definition of the game could use a graph with node weights (that specify the size of the corresponding connected component) and a proper coloring of the nodes. Any instance under the original definition can be transformed into an equivalent instance under the new definition by contracting each connected component of , for some , into a single node of weight . However, we are interested in restrictions of the game to particular graph classes, some of which are not closed under edge contractions (as for instance the hexgrid graph of the original HoneyBee game).
3 The Solitaire Game
In this section we study the complexity of finding optimally short color sequences for HoneyBeeSolitaire. We will show that this is easy for cocomparability graphs, while it is NPhard for trees and split graphs. Since the family of cocomparability graphs contains interval graphs, permutation graphs, and cographs as subfamilies, our positive result for cocomparability graphs implies all other positive results in Fig. 2.
A first straightforward observation is that HoneyBeeSolitaire lies in NP: Any connected graph can be conquered in at most moves, and hence such a sequence of polynomially many moves can serve as an NPcertificate.
3.1 The Solitaire Game on CoComparability Graphs
A cocomparability graph is an undirected graph whose nodes correspond to the elements of some partial order and whose edges connect any two elements that are incomparable in that partial order, i.e., if neither nor holds. For simplicity, we identify the nodes with the elements of the partial order. Golumbic et al. [3] showed that cocomparability graphs are exactly the intersection graphs of continuous realvalued functions over some interval . If two function curves intersect, the corresponding elements are incomparable in the partial order; otherwise, the curve that lies complete above the other one corresponds to the larger element in the partial order. The function graph representation readily implies that the class of cocomparability graphs is closed under edge contractions. Therefore, we may w.l.o.g. restrict our analysis of HoneyBeeSolitaire to cocomparability graphs with a proper node coloring, i.e., adjacent nodes have distinct colors (in the solitaire game we do not care about the weight of a node after an edge contraction). In this case, every color class is totally ordered because incomparable node pairs have been contracted.
Consider an instance of HoneyBeeSolitaire with a minimal start node (in the partial order on ); a maximal start node could be handled similarly. The function graph representation implies the following observation.
Observation 3.1
Conquering a node will simultaneously conquer all smaller nodes of the same color.
For any color , let denote the largest node of color . By Obs. 3.1, it suffices to find the shortest color sequence conquering all nodes , for all colors . We can do that by a simple shortest path computation. We assign every node weight , and all other nodes weight . Then we compute a shortest path (with respect to the nodeweights) from to every node that is a maximal element in the partial order (which is actually exactly the set of all maximal elements). Let denote the smallest cost over all such paths.
For a color sequence , we define the length of as . We also define the essential length of as minus the number of steps where conquers a maximal node of some color class . Obviously, . Note that is the minimal essential cost of any color sequence conquering one of the maximal nodes.
Lemma 3.2
The optimal solution for HoneyBeeSolitaire has cost .
Proof. Let be a shortest color sequence conquering the entire graph starting at . After conquering , only needs to conquer all free nodes to conquer the entire graph. Thus, .
Theorem 3.3
HoneyBeeSolitaire starting at an extremal node can be solved in polynomial time on cocomparability graphs.
Proof. Given the cocomparability graph , we can compute the underlying partial order in polynomial time [3]. Assigning the weights and solving one single source shortest path problem starting at also takes polynomial time.
We can also formulate this algorithm as a dynamic program. For any node , let denote the essential length of the shortest color sequence that can conquer when starting at . For any color , let denote the smallest node of color connected to , if such nodes exist. Then we can compute recursively as follows:
and
where if is undefined, and () if is (not) a maximal node for some color class.
Clearly, this dynamic program simulates the shortest path computation of our first algorithm and we have , where we minimize over all maximal nodes . We now extend the dynamic program to the case that is not an extremal element. The problem is that we now must extend our territory in two directions. If we choose a move that makes good progress upwards it may make little progress downwards, or vice versa. In particular, the optimal strategy cannot be decomposed into two independent optimal strategies, one conquering upwards and one conquering downwards. Analogously to the algorithm above, for a clor define as the smallest node of color , and as the largest node of color connected to a node .
Unfortunately, we must now redefine the essential length of a color sequence . In our original definition, we did not count coloring steps that conquered maximal elements of some color class. This is intuitively justified by the fact that these steps must be done by any color sequence conquering the entire graph at some time, therefore it is advantageous to do them as early as possible (which is guaranteed by giving these moves cost 0). But now we must also consider the minimal nodes of each color class. An optimal sequence conquering the entire graph will at some time have conquered a minimal node and a maximal node. Afterwards, it will only call extremal nodes for some color class. If both extremal nodes of a color class are still free, we only need one move to conquer both simultaneously. If one of them had been captured earlier, we still need to conquer the other one. This indicates that we should charge 1 for the first extremal node conquered while the second one should be charged 0, as before. If both nodes are conquered in the same move, we should also charge 0. Therefore, we now define the essential length of as minus the number of steps where conquers the second extremal node of some color class.
For a node below or incomparable to and a node above or incomparable to let denote the essential length of the shortest color sequence that can conquer and when starting at . Note that we do not need to keep track of which first extremal nodes of a color class have been conquered because we can deduce this from the two nodes and currently under consideration. In particular, we can compute recursively as follows:
and
where if and only if is an extremal node of some color class and the other extremal node of color class is either between and , or incomparable to either or , or both (it was either conquered earlier, or it will be conquered in this step); otherwise, . Obviously, .
Lemma 3.4
The optimal solution for HoneyBeeSolitaire has cost , where we minimize over all minimal nodes and all maximal nodes .
Proof. Let be a shortest color sequence conquering the entire graph starting at . Let be the first minimal node conquered by and the first maximal node. After conquering and , only needs to conquer all free nodes to conquer the entire graph. Thus, .
Theorem 3.5
HoneyBeeSolitaire can be solved in polynomial time on cocomparability graphs.
3.2 The Solitaire Game on Split Graphs
A split graph is a graph whose node set can be partitioned into an induced clique and into an induced independent set. We will show that HoneyBeeSolitaire is NPhard on split graphs. Our reduction is from the NPhard Feedback Vertex Set (FVS) problem in directed graphs; see for instance Garey and Johnson [2].
Problem FVS Input: A directed graph ; a bound . Question: Does there exist a subset with such that the directed graph induced by is acyclic?
Theorem 3.6
HoneyBeeSolitaire on split graphs is NPhard.
Proof. Consider an instance of FVS. To construct an instance of HoneyBeeSolitaire, we first build a clique from the nodes in together with a new node , the start node of HoneyBeeSolitaire, where each node has a different color . Next, we build the independent set. For every arc , we introduce a corresponding node of color which is only connected to node in the clique, i.e., it has degree one. Finally, we set . We claim that the constructed instance of HoneyBeeSolitaire has answer YES, if and only if the instance of FVS has answer YES.
Assume that the FVS instance has answer YES. Let be a smallest feedback set whose removal makes acyclic. Let be a topological order of the nodes in , and let be an arbitrary ordering of the nodes in . Consider the color sequence of length that starts with , followed by , and followed by again. We claim that . Indeed, first runs through and and thereby conquers all clique nodes. Every independent set node with is conquered during the second transversal of . Every independent set node with is conquered during the transversal of , since first conquers with color , and afterwards with color .
Next assume that the instance of HoneyBeeSolitaire has answer YES. Let be a color sequence of length conquering . Define as the set of nodes such that color occurs at least twice in ; clearly, . Consider an arc with . Since contains color only once, it must conquer node of color after node of color . Hence, induces a topological order of .
The construction in the proof above uses linearly many colors. What about the case of few colors? On split graphs, HoneyBeeSolitaire can always be solved by traversing the color set twice; the first traversal conquers all clique nodes, and the second traversal conquers all remaining free independent set nodes. Thus, every split graph can be completely conquered in at most steps. If there are only few colors, we can simply check all color sequences of this length .
Theorem 3.7
If the number of colors is bounded by a fixed constant, HoneyBeeSolitaire on split graphs is polynomialtime solvable.
3.3 The Solitaire Game on Trees
In this section we will show that HoneyBeeSolitaire is NPhard on trees, even if there are at only three colors. We reduce HoneyBeeSolitaire from a variant of the Shortest Common Supersequence (SCS) problem which is know to be NPcomplete (see Middendorf [4]).
Problem SCS Input: A positive integer ; finite sequences with elements from with the following properties: (i) All sequences have the same length. (ii) Every sequence contains exactly two 1s, and these two 1s are separated by at least one 0. Question: Does there exist a sequence of length that contains as subsequences?
Middendorf’s hardness result also implies the hardness of the following variant of SCS:
Problem Modified SCS (MSCS) Input: A positive integer ; finite sequences with elements from with the following property: In every sequence any two consecutive elements are distinct, and no sequence starts with 2. Question: Does there exist a sequence of length that contains as subsequences?
Theorem 3.8
MSCS is NPcomplete.
Proof. Here is a reduction from SCS to MSCS. Consider an arbitrary sequence with elements from . We define as the sequence we obtain from replacing every occurrence of the element 0 in by two consecutive elements 0 and 2. Now consider an instance of SCS. We construct an instance of MSCS by setting , for . Then, for any sequence with elements from , is a common supersequence of if and only if is a common supersequence of . This implies the NPhardness of MSCS.
Theorem 3.9
HoneyBeeSolitaire is NPhard on trees, even in case of only three colors.
Proof. We reduce MSCS to HoneyBeeSolitaire on trees. Consider an instance of MSCS. We use color set . We first construct a root of color . Then we attach a path of length to for each sequence , where an element is colored . See the left half of Fig. 6 for an example. Finally, we set . It its straightforward to see that the constructed instance of HoneyBeeSolitaire has answer YES if and only if the instance of MSCS has answer YES.
4 The TwoPlayer Game
In this section we study the complexity of the twoplayer game. While on outerplanar graphs the players can compute their winning strategies in polynomial time, this problem is NPhard for seriesparallel graphs with four colors, and PSPACEcomplete with four colors on arbitrary graphs. Our positive result for outerplanar graphs works for an arbitrary number of colors. Our negative results work for four colors, which is the strongest possible type of result (recall that instances with three colors are trivial to solve).
4.1 The TwoPlayer Game on OuterPlanar Graphs
A graph is outerplanar if it contains neither nor as a minor. Outerplanar graphs have a planar embedding in which every node lies on the boundary of the socalled outer face. For example, every tree is an outerplanar graph.
Consider an outerplanar graph as an instance of HoneyBee2Players with starting nodes and in , respectively. The starting nodes divide the nodes on the boundary of the outer face into an upper chain and a lower chain , where and are the two neighbors of on , while and are the two neighbors of on . We stress that this upper and lower chain are not necessarily disjoint (for instance, articulation nodes will occur in both chains).
Now consider an arbitrary situation in the middle of the game. Let (respectively ) denote the largest index such that player has conquered node (respectively node ). See Fig. 5 to illustrate these definitions and the following lemma.
Lemma 4.1
Let denote the set of nodes among and that currently do neither belong to nor to . Then no node in can have a neighbor among .
Proof. The existence of such a node in would lead to a minor in the outerplanar graph.
Theorem 4.2
HoneyBee2Players on outerplanar graphs is polynomialtime solvable.
Proof. The two indices and encode all necessary information on the future behavior of player . Eventually, he will own all nodes and , and the possible future expansions of his area beyond and only depend on and . Symmetric observations hold true for player .
As every game situation can be concisely described by just four indices, there is only a polynomial number of relevant game situations. The rest is routine work in combinatorial game theory: We first determine the winner for every endsituation, and then by working backwards in time we can determine the winners for the remaining game situations.
4.2 The TwoPlayer Game on SeriesParallel Graphs
A graph is seriesparallel if it does not contain as a minor. Equivalently, a seriesparallel graph can be constructed from a single edge by repeatedly doubling edges, or removing edges, or replacing edges by a path of two edges with a new node in the middle of the path. We stress that we do not know whether the twoplayer game on seriesparallel graphs is contained in the class NP (and we actually see no reason why it should lie in NP); therefore the following theorem only states NPhardness.
Theorem 4.3
For four (or more) colors, problem HoneyBee2Players on seriesparallel graphs is NPhard.
Proof. We use the color set . A central feature of our construction is that player will have no real decision power, but will only follow the moves of player : If player starts a round by calling color or , then player must follow by calling the other color in (or waste his move). And if player starts a round by calling color or , then player must call the other color in (or waste his move). In the even rounds the players will call the colors in and in the odd rounds they will call the colors in . Both players are competing for a set of honey pots in the middle of the battlefield, and need to get there as quickly as possible. If a player deviates from the evenodd pattern indicated above, he might perhaps waste his move and delay the game by one round (in which neither player comes closer to the honey pots), but this remains without further impact on the outcome of the game.
The proof is by reduction from the supersequence problem SCS with binary sequences; see Section 3.3. Consider an instance of SCS, and let denote the common length of all sequences . We first construct two start nodes and of colors and , respectively. For each sequence with we do the following:

We construct a path that consists of nodes and that is attached to : The nodes with odd numbers mimic sequence , while the nodes with even numbers along the path all receive color . The first node of is adjacent to , and its last node is connected to a socalled honey pot .

The honey pot is a long path consisting of nodes of color . Intuitively, we may think of a honey pot as a single node of large weight, because conquering one of the nodes will simultaneously conquer the entire path.

Every honey pot can also be reached from by another path that consists of nodes. Nodes with odd numbers get color , and nodes with even numbers get color . The first node of is adjacent to , and its last node is connected to . Furthermore, we create for each oddnumbered node (of color ) a new twin node of color that has the same two neighbors as the color node. Note that for every path there are twin pairs.
Finally we create a private honey pot for player , that is connected to node and that consists of nodes of color . This completes the construction; see Fig. 6 for an example.
Assume that the SCS instance has answer YES. During his first steps, player can only conquer the paths and his private honey pot . At the same time, player can conquer all paths by calling color in his even moves and by following a shortest 01 supersequence in his odd moves. Then, in round player will simultaneously conquer all the honey pots with . This gives a territory of at least nodes, and a smaller territory of at most nodes. Hence can enforce a win.
Next assume that player has a winning strategy. Player can always conquer his starting node and his private honey pot . If also manages to conquer one of the pots , then he gets a territory of at least nodes and surely wins the game. Hence player can only win if he conquers all honey pots . To reach them before player does, player must conquer them within his first moves. In every odd round, player will call a color or and player will call the other color in . Hence, in the even rounds, colors and are forbidden for player , and the only reasonable move is to call color . Note that the slightest deviation of these forced moves would give player a deadly advantage. In order to win, the odd moves of player must induce a supersequence of length at most for all sequences . Therefore, the SCS instance has answer YES.
4.3 The TwoPlayer Game on Arbitrary Graphs
In this section we will show that problem HoneyBee2Players is PSPACEcomplete on arbitrary graphs. Our reduction is from the PSPACEcomplete Quantified Boolean Formula (QBF) problem; see for instance Garey & Johnson [2].
Problem QBF Input: A quantified Boolean formula with variables in conjunctive normal form: , where the are clauses of the form , where the are literals. Question: Is the formula true?
Theorem 4.4
For four (or more) colors, problem HoneyBee2Players on arbitrary graphs is PSPACEcomplete.
Proof. We reduce from QBF. Let be an instance of QBF. We construct a bee graph with four colors (white, lightgray, darkgray, and black) such that player has a winning strategy if and only if is true. Let (colored lightgray) and (colored darkgray) denote the start nodes of players and , respectively.
Each player controls a pseudopath, that is, a path where some nodes may be duplicated as parallel nodes in a diamondshaped structure; see Fig. 7. A socalled choice pair consists of a node on a pseudopath together with some duplicated node in parallel. The start nodes are at one end of the respective pseudopaths, and the players can conquer the nodes on their own path without interference from the other player. However, they must do so in a timely manner because either path ends at a humongous honey pot, denoted respectively by and . A honey pot is a large clique of identicallycolored nodes (we may think of it as a single node of large weight, because conquering one node will simultaneously conquer the entire clique). Both honey pots have the same size but different colors, namely black () and white (), and they are connected to each other by an edge. Consequently, both players must rush along their pseudopaths as quickly as possible to reach their honey pot before the opponent can reach it and to prevent the opponent from winning by conquering both honey pots. The last nodes before the honey pots are denoted by and , respectively. They separate the last variable gadgets (described below) from the honey pots.
Fig. 7 shows an overview of the pseudopaths and one variable gadget in detail. A variable gadget is a part of the two pseudopaths corresponding to a pair of variables , for some . For player , the gadget starts at node with a choice pair and , colored white and black, respectively. The first node conquered by will determine the truth value for variable . In the same round, player has a choice on his pseudopath between nodes and . Since these nodes have the same color as ’s choices in the same round, actually does not have a choice but must select the other color not chosen by .
Three rounds later, player has a choice pair and , assigning a truth value to variable . In the next step (which is in the next round), player has a choice pair and with the same colors as ’s choice pair for . Again, this means that does not really have a choice but must select the color not chosen by in the previous step. Since we want to conquer those clauses containing a literal set to true by player , the colors in ’s choice pair have been switched, i.e., is black and is white.
Note that all the nodes are lightgray and all the nodes are darkgray. This allows us to concatenate as many variable gadgets as needed. Further note that is white, while is lightgray.
The clause gadgets are very simple. Each clause corresponds to a small honey pot of color white. The size of the small honey pots is smaller than the size of the large honey pots and , but large enough such that player loses if he misses one of them. Player should conquer if and only if is true in the assignment chosen by the players while conquering their respective pseudopaths. We could connect directly with if contains literal , however then player could in subsequent rounds shortcut his pseudopath by entering variable gadgets for the other variables in from . To prevent this from happening, we place waiting gadgets between the variable gadgets and the clauses.
Let denote the node on right after the choice pair and , for ; similarly, are the nodes on right after ’s choice pairs. A waiting gadget consists of two copies and of the subpath of starting at and ending at , see Fig. 8. If clause contains literal , is connected to the node corresponding to in ; if contains literal , is connected to the node corresponding to in . If (i.e., we have an existential variable whose value is assigned by player ), then and are connected to , and and are connected to . If (i.e., we have a universal variable whose value is assigned by player ), then and are connected to , and and are connected to .
Finally, we connect with all clause honey pots to give player the opportunity to conquer all those clauses that contain no true literal. This completes the construction of . Fig. 9 shows the complete graph for a small example formula .
We claim that player has a winning strategy on if and only if formula is true. It is easy to verify that player can indeed win if is true. All he has to do is to conquer those nodes in his existential choice pairs corresponding to the variable values in a satisfying assignment for . For the existential variables, he has full control to select any value, and for the universal variables he must pick the opposite color as selected by player in the previous step, which corresponds to setting the variable to exactly the value that player has selected. Hence player can block a move of player by appropriately selecting a value for a universal variable. Note that no other blocking moves of player are advantageous: If blocks ’s next move by choosing a color that does not make progress on his own pseudopath, then will simply make an arbitrary waiting move and then in the next round cannot block again. When player conquers node , he will simultaneously conquer the last nodes in all waiting gadgets corresponding to true literals. Since every clause contains a true literal for a satisfying assignment, player can then in the next round conquer together with all clause honey pots (which all have color white). Player will respond by conquering , and the game ends with both players conquering their own large honey pots and , respectively. Since player got all clause honey pots, he wins.
To make this argument work, we must carefully chose the sizes of the honey pots. Each pseudopath contains nodes, of which at most can be conquered by the other player. The waiting gadgets contain two paths of length for existential variables and for universal variables. At the end, player will have conquered one of the two paths completely and maybe some parts of the sibling path, that is, we do not know exactly the final owner of less than nodes. The clause honey pots should be large enough to absorb this fuzzyness, which means it is sufficient to give them nodes. The honey pots and should be large enough to punish any foul play by the players, that is, when they do not strictly follow their pseudopaths. It is sufficient to give them nodes.
To see that is true if player has a winning strategy note that player must strictly follow his pseudopath, as otherwise player could beat him by reaching the large honey pots first. Thus player ’s strategy induces a truth assignment for the existential variables. Similarly, player ’s strategy induces a truth assignment for the universal variables. Player can only win if he also conquers all clause honey pots, and hence the players must haven chosen truth values that make at least one literal per clause true. This means that formula is satisfiable.
5 Conclusions
We have modeled the Honey Bee game as a combinatorial game on colored graphs. For the solitaire version, we have analyzed the complexity on many classes of perfect graphs. For the two player version, we have shown that even the highly restricted case of seriesparallel graphs is hard to tackle. Our results draw a clear separating line between easy and hard variants of these problems.
6 Acknowledgements
Part of this research was done while G. Woeginger visited Fudan University in 2009.
References

[1]
A. Born.
Flash application for the computer game “Biene” (HoneyBee),
2009.
http://www.ursulinen.asngraz.ac.at/Bugs/htm/games/biene.htm.  [2] M. R. Garey and D. S. Johnson. Computers and Intractability — A Guide to the Theory of NPCompleteness. W. H. Freeman and Company, New York, 1979.
 [3] M. C. Golumbic, D. Rotem, and J. Urrutia. Comparability graphs and intersection graphs. Discrete Mathematics, 43(1):37–46, 1983.
 [4] M. Middendorf. More on the complexity of common superstring and supersequence problems. Theoretical Computer Science, 125:205–228, 1994.