Abstract: We establish some general schemes relating the computational complexity of a video game to the presence of certain common elements or mechanics, such as destroyable paths, collecting items, doors activated by switches or pressure plates, etc.. Then we apply such "metatheorems" to several video games published between 1980 and 1998, including Pac-Man, Tron, Lode Runner, Boulder Dash, Deflektor, Mindbender, Pipe Mania, Skweek, Prince of Persia, Lemmings, Doom, Puzzle Bobble 3, and Starcraft. We obtain both new results, and improvements or alternative proofs of previously known results.

Abstract: In this paper we formally prove that the problem of cracking, i.e., correctly guessing, bank PINs used for accessing Automated Teller Machines and the problem of solving the Generalized Mastermind Game are strictly related. The Generalized Mastermind Game with N colors and k pegs is an extension of the well known Mastermind game, played with 6 colors and 4 pegs. The rules are the same, one player has to conceal a sequence of k colored pegs behind a screen and another player has to guess the exact position and colors of the pegs using the minimal number of moves. We first introduce a general game, called the Extended Mastermind Game (EMG), and we then formally prove it includes both the Generalized Mastermind Game and the PIN cracking Problem. We then present some experimental results that we have devised using a computer program that optimizes a well known technique presented by Knuth in 1976 for the standard Mastermind game. We finally show that the program improves the as state-of-the-art Mastermind solvers as it is able to compute strategies for cases which were not yet covered. More interestingly, the same solving strategy is adapted also for the solution of the PIN cracking problem.

Abstract: We investigate the computational complexity of two maze problems, namely rolling block and Alice mazes. Simply speaking, in the former game one has to roll blocks through a maze, ending in a particular game situation, and in the latter one, one has to move tokens of variable speed through a maze following some prescribed directions. It turns out that when the number of blocks or the number of tokens is not restricted (unbounded), then the problem of solving such a maze becomes PSPACE-complete. Hardness is shown via a reduction from the nondeterministic constraint logic (NCL) of [E. D. Demaine, R. A. Hearn: A uniform framework or modeling computations as games. Proc. CCC, 2008] to the problems in question. By using only blocks of size 2×1×1, and no forbidden squares, we improve a previous result of [K. Buchin, M. Buchin: Rolling block mazes are PSPACE-complete. J. Inform. Proc., 2012] on rolling block mazes to best possible. Moreover, we also consider bounded variants of these maze games, i.e., when the number of blocks or tokens is bounded by a constant, and prove close relations to variants of graph reachability problems.

Abstract: Being a firefighter is a tough job, especially when tight city budgets do not allow enough firefighters to be on duty when a fire starts. This is formalized in the Firefighter problem, which aims to save as many vertices of a graph as possible from a fire that starts in a vertex and spreads through the graph. In every time step, a single additional firefighter may be placed on a vertex, and the fire advances to each vertex in its neighborhood that is not protected by a firefighter. The problem is notoriously hard: it is NP-hard even when the input graph is a bipartite graph or a tree of maximum degree 3, it is W[1]-hard when parameterized by the number of saved vertices, and it is NP-hard to approximate within n1−e for any e>0. We aim to simplify the task of a firefighter by providing algorithms that show him/her how to efficiently fight fires in certain types of networks. We show that Firefighter can be solved in polynomial time on various well-known graph classes, including interval graphs, split graphs, permutation graphs, and Pk-free graphs for fixed k. On the negative side, we show that the problem remains NP-hard on unit disk graphs.

Abstract: We investigate the computational complexity of some maze problems, namely the reachability problem for (undirected) grid graphs with diagonal edges, and the solvability of Xmas tree mazes. Simply speaking, in the latter game one has to move sticks of a certain length through a maze, ending in a particular game situation. It turns out that when the number of sticks is bounded by some constant, these problems are closely related to the grid graph problems with diagonals. If on the other hand an unbounded number of sticks is allowed, then the problem of solving such a maze becomes PSPACE-complete. Hardness is shown via a reduction from the nondeterministic constraint logic (NCL) of [E. D. Demaine, R. A. Hearn: A uniform framework or modeling computations as games. Proc. CCC, 2008] to Xmas tree mazes.

Abstract: We study the complexity of the popular one player combinatorial game known as Flood-It. In this game the player is given an n×n board of tiles where each tile is allocated one of c colours. The goal is to make the colours of all tiles equal via the shortest possible sequence of flooding operations. In the standard version, a flooding operation consists of the player choosing a colour k, which then changes the colour of all the tiles in the monochromatic region connected to the top left tile to k. After this operation has been performed, neighbouring regions which are already of the chosen colour k will then also become connected, thereby extending the monochromatic region of the board. We show that finding the minimum number of flooding operations is NP-hard for c?3 and that this even holds when the player can perform flooding operations from any position on the board. However, we show that this `free' variant is in P for c=2. We also prove that for an unbounded number of colours, Flood-It remains NP-hard for boards of height at least 3, but is in P for boards of height 2. Next we show how a (c?1) approximation and a randomised 2c/3 approximation algorithm can be derived, and that no polynomial time constant factor, independent of c, approximation algorithm exists unless P=NP. We then investigate how many moves are required for the `most demanding' n×n boards (those requiring the most moves) and show that the number grows as fast as $\Theta(\sqrt{c}\, n)$ . Finally, we consider boards where the colours of the tiles are chosen at random and show that for c?2, the number of moves required to flood the whole board is Ω(n) with high probability.

Abstract: According to a folk theorem, every program can be transformed into a program that produces the same output and only has one loop. We generalize this to a form where the resulting program has one loop and no other branches than the one associated with the loop control. For this branch, branch prediction is easy even for a static branch predictor. If the original program is of length κ, measured in the number of assembly-language instructions, and runs in t(n) time for an input of size n, the transformed program is of length O(κ) and runs in O(κt(n)) time. Normally sorting programs are short, but still κ may be too large for practical purposes. Therefore, we provide more efficient hand-tailored heapsort and mergesort programs. Our programs retain most features of the original programs--e.g. they perform the same number of element comparisons--and they induce O(1) branch mispredictions. On computers where branch mispredictions were expensive, some of our programs were, for integer data and small instances, faster than the counterparts in the GNU implementation of the C++ standard library.

Abstract: We consider problems related to the combinatorial game (Free-) Flood-It, in which players aim to make a coloured graph monochromatic with the minimum possible number of flooding operations. We show that the minimum number of moves required to flood any given graph G is equal to the minimum, taken over all spanning trees T of G, of the number of moves required to flood T. This result is then applied to give two polynomial-time algorithms for flood-filling problems. Firstly, we can compute in polynomial time the minimum number of moves required to flood a graph with only a polynomial number of connected subgraphs. Secondly, given any coloured connected graph and a subset of the vertices of bounded size, the number of moves required to connect this subset can be computed in polynomial time.

Abstract: We give a simple proof and a generalization of the classical result which says that the (asymptotic) approximation ratio of BestFit algorithm is 1.7. We generalize this result to a wide class of algorithms that are allowed to pack the incoming item to any bin with load larger than 1/2 (if it fits), instead to the most full bin, and at the same time this class includes the bounded-space variants of these algorithms.

Abstract: In the classic Josephus problem, elements 1,2,?,n are placed in order around a circle and a skip value k is chosen. The problem proceeds in n rounds, where each round consists of traveling around the circle from the current position, and selecting the kth remaining element to be eliminated from the circle. After n rounds, every element is eliminated. Special attention is given to the last surviving element, denote it by j. We generalize this popular problem by introducing a uniform number of lives l, so that elements are not eliminated until they have been selected for the lth time. We prove two main results: 1) When n and k are fixed, then j is constant for all values of l larger than the nth Fibonacci number. In other words, the last surviving element stabilizes with respect to increasing the number of lives. 2) When n and j are fixed, then there exists a value of k that allows j to be the last survivor simultaneously for all values of l. In other words, certain skip values ensure that a given position is the last survivor, regardless of the number of lives. For the first result we give an algorithm for determining j (and the entire sequence of selections) that uses O(n 2) arithmetic operations. "un gatto ha sette vite"

Abstract: The train marshalling problem is about reordering the cars of a train using as few auxiliary rails as possible. The problem is known to be NP-complete. We show that it is fixed parameter tractable (FPT) with the number of auxiliary rails as parameter.

Abstract: Finding a good cup of coffee in Paris is difficult even among its world-renowned cafes, at least according to author David Downie (2011). We propose a solution that would allow tourists to create a map of the Paris Metro system from scratch that shows the locations of the cafes with the good coffee, while addressing the problem of the tourists losing interest in the process once they have found good coffee. We map the problem to the black hole search problem in the subway model introduced by Flocchini et al. at Fun with Algorithms 2010. We provide a solution that allows the tourists to start anywhere and at any time, communicate using whiteboards on the subway trains, rely on much less information than is normally available to subway passengers, and work independently but collectively to map the subway network. Our solution is the first to deal with scattered agents searching for black holes in a dynamic network and is optimal both in terms of the team size and the number of carrier moves required to complete the map.

Abstract: We introduce two numeral systems, the magical skew system and the regular skew system, and contribute to their theory development. For both systems, increments and decrements are supported using a constant number of digit changes per operation. Moreover, for the regular skew system, the operation of adding two numbers is supported efficiently. Our basic message is that some data-structural problems are better formulated at the level of a numeral system. The relationship between number representations and data representations, as well as operations on them, can be utilized for an elegant description and a clean analysis of algorithms. In many cases, a pure mathematical treatment may also be interesting in its own right. As an application of numeral systems to data structures, we consider how to implement a priority queue as a forest of pointer-based binary heaps. Some of the number-representation features that influence the efficiency of the priority-queue operations include weighting of digits, carry-propagation and borrowing mechanisms.

Abstract: We try to help Paul and Pinocchio to deserve their trip to Venice where they are planning to continue a 50-year long competition in the 20 question game with lies.

Abstract: Pick a binary string of length n and remove its first bit b. Now insert b after the first remaining 10, or insert \(\overline{b}\) at the end if there is no remaining 10. Do it again. And again. Keep going! Eventually, you will cycle through all 2 n of the binary strings of length n. For example, Open image in new window Open image in new window are the binary strings of length n = 4, where 1 = Open image in new window and 0 = Open image in new window Che bello! And if you only want strings with weight (number of 1s) between l and u? Just insert b instead of \(\overline{b}\) when the result would have too many 1s or too few 1s. For example, Open image in new window are the strings with n = 4, l = 0 and u = 2. Strabello! This generalizes ‘cool-lex’ order by Ruskey and Williams (The coolest way to generate combinations, Discrete Mathematics). We use it to construct de Bruijn sequences for (i) l = 0 and any u (maximum specified weight), (ii) any l and u = n (minimum specified weight), and (iii) odd u − l (even size weight range). For example, all binary strings with n = 6, l = 1, and u = 4 appear once (cyclically) in Open image in new window

Abstract: We study the combinatorial two-player game $\texttt{\rm tron}$. We answer the extremal question on general graphs and also consider smaller graph classes. Bodlaender and Kloks conjectured in [2] PSPACE- completeness. We prove this conjecture.

Abstract: We investigate the hardness of establishing as many stable marriages (that is, marriages that last forever) in a population whose memory is placed in some arbitrary state with respect to the considered problem, and where traitors try to jeopardize the whole process by behaving in a harmful manner. On the negative side, we demonstrate that no solution that is completely insensitive to traitors can exist, and we propose a protocol for the problem that is optimal with respect to the traitor containment radius.

Abstract: The crossword puzzle is a classic pastime that is well-known all over the world. We consider the crossword manufacturing process in more detail, investigating a two-step approach, first generating a mask, which is an empty crossword puzzle skeleton, and then filling the mask with words from a given dictionary to obtain a valid crossword. We show that the whole manufacturing process is NP-complete, and in particular also the second step of the two-step manufacturing, thus reproving in part a result of Lewis and Papadimitriou mentioned in Garey and Johnson's monograph [M. R. Garey and D. S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman and Company, 1979.] but now under real world crossword puzzle conditions. Moreover, we show how to generate high-quality masks via a memetic algorithm, which is used and tested in an industrial manufacturing environment, leading to very good results.

Abstract: We show how to hang a picture by wrapping rope around n nails, making a polynomial number of twists, such that the picture falls whenever any k out of the n nails get removed, and the picture remains hanging when fewer than k nails get removed. This construction makes for some fun mathematical magic performances. More generally, we characterize the possible Boolean functions characterizing when the picture falls in terms of which nails get removed as all monotone Boolean functions. This construction requires an exponential number of twists in the worst case, but exponential complexity is almost always necessary for general functions.

Abstract: Scientific literature has itself been the subject of much scientific study, for a variety of reasons: understanding how results are communicated, how ideas spread, and assessing the influence of areas or individuals. However, most prior work has focused on extracting and analyzing citation and stylistic patterns. In this work, we introduce the notion of ‘scienceography', which focuses on the writing of science. We provide a first large scale study using data derived from the arXiv e-print repository. Crucially, our data includes the "source code" of scientific papers--the $\hbox{\LaTeX }$ source--which enables us to study features not present in the "final product", such as the tools used and private comments between authors. Our study identifies broad patterns and trends in two example areas--computer science and mathematics--as well as highlighting key differences in the way that science is written in these fields. Finally, we outline future directions to extend the new topic of scienceography.

Abstract: Prefetching is a basic mechanism for faster data access and efficient computing. An important issue in prefetching is the tradeoff between the amount of network's resources wasted by the prefetching and the gain of time. For instance, in the Web, browsers may download documents in advance while a Web surfer is surfing on the Web. Since the Web surfer follows the hyperlinks in an unpredictable way, the choice of the Web pages to be prefetched must be computed online. The question is then to determine the minimum amount of resources used by prefetching that ensures that all documents accessed by the Web surfer have previously been loaded in the cache. We model this problem as a two-players game similar to Cops and Robber Games in graphs. The first player, a fugitive, starts on a marked vertex of a (di)graph G. The second player, an observer, marks k≥1 vertices, then the fugitive moves along one edge/arc of G to a new vertex, then the observer marks k vertices, etc. The observer wins if he prevents the fugitive to reach an unmarked vertex. The fugitive wins otherwise, i.e., if she succeed to enter an unmarked vertex. The surveillance number of a (di)graph is the minimum k≥1 allowing the observer to win against any strategy of the fugitive. We study the computational complexity of the game. We show that deciding whether the surveillance number of a chordal graph equals 2 is NP-hard. Deciding if the surveillance number of a DAG equals 4 is PSPACE-complete. Moreover, computing the surveillance number is NP-hard in split graphs. On the other hand, we provide polynomial time algorithms computing surveillance numbers of trees and interval graphs. Moreover, in the case of trees, we establish a combinatorial characterization, related to isoperimetry, of the surveillance number.

Abstract: Counting perfect matchings is an interesting and challenging combinatorial task. It has important applications in statistical physics. As the general problem is #P complete, it is usually tackled by randomized heuristics and approximation schemes. The trivial running times for exact algorithms are O*((n−1)!!)=O*(n!!)=O*((n/2)! 2n/2) for general graphs and O*((n/2)!) for bipartite graphs. Ryser's old algorithm uses the inclusion exclusion principle to handle the bipartite case in time O*(2n/2). It is still the fastest known algorithm handling arbitrary bipartite graphs. For graphs with n vertices and m edges, we present a very simple argument for an algorithm running in time O*(1.4656m−n). For graphs of average degree 3 this is O*(1.2106n), improving on the previously fastest algorithm of Bjorklund and Husfeldt. We also present an algorithm running in time O*(1.4205m−n) or O*(1.1918n) for average degree 3 graphs. The purpose of these simple algorithms is to exhibit the power of the m−n measure. Here, we don't investigate the further improvements possible for larger average degrees by applying the measure-and-conquer method.

Abstract: We prove that it is NP-hard to decide whether two points in a polygonal domain with holes can be connected by a wire. This implies that finding any approximation to the shortest path for a long snake amidst polygonal obstacles is NP-hard. On the positive side, we show that snake's problem is "length-tractable": if the snake is "fat", i.e., its length/width ratio is small, the shortest path can be computed in polynomial time.

Abstract: Removing noise in a given binary image is a common operation. A generalization of the operation is to erase an arbitrarily specified component by reversing pixel values in the component. This paper shows that this operation can be done without using any data structure like a stack or queue, or more exactly using only constant extra memory (consisting of a constant number of words of O(log?n) bits for an image of n pixels) in O(mlog?m) time for a component consisting of m pixels. This is an in-place algorithm, but the image matrix cannot be used as work space since it has just one bit for each pixel. Whenever we flip a pixel value in a target component, the component shape is also deformed, which causes some difficulty. The main idea for our constant work space algorithm is to deform a component so that its connectivity is preserved.

Abstract: In job scheduling with precedence-constraints, i≺j means that job j cannot start being processed before job i is completed. In this paper we consider selfish bully jobs who do not let other jobs start their processing if they are around. Formally, we define the selfish precedence-constraint where i≺ s j means that j cannot start being processed if i has not started its processing yet. Interestingly, as was detected by a devoted kindergarten teacher whose story is told below, this type of precedence-constraints is very different from the traditional one, in a sense that problems that are known to be solvable efficiently become NP-hard and vice-versa. The work of our hero teacher, Ms. Schedule, was initiated due to an arrival of bully jobs to her kindergarten. Bully jobs bypass all other nice jobs, but respect each other. This natural environment corresponds to the case where the selfish precedence-constraints graph is a complete bipartite graph. Ms. Schedule analyzed the minimum makespan and the minimum total flow-time problems for this setting. She then extended her interest to other topologies of the precedence-constraints graph and other special instances with uniform length jobs and/or release times.

Abstract: We show that single-digit "Nishio" subproblems in n×n Sudoku puzzles may be solved in time o(2n), faster than previous solutions such as the pattern overlay method. We also show that single-digit deduction in Sudoku is NP-hard.

Abstract: In the game of Kal-toh depicted in the television series Star Trek: Voyager, players attempt to create convex polyhedra by adding to a jumbled collection of metal rods. Inspired by this fictional game, we formulate graph-theoretical questions about polyhedral subgraphs, i.e., subgraphs that are triconnected and planar. The problem of determining the existence of a polyhedral subgraph within a graph G is shown to be NP-complete, and we also give some non-trivial upper bounds for the problem of determining the minimum number of edge additions necessary to guarantee the existence of a polyhedral subgraph in G.

Abstract: Consider a situation where people have to choose among a sequence of n linearly ordered positions to perform some task requiring a certain amount of privacy. Which position should one choose so as to maximize one's privacy, i.e., minimize the chances that one of your neighboring positions becomes occupied by a later arrival? In this paper, we attempt to answer this question under a variety of models for the behavior of the later arrivals. Our results suggest that for the most part one should probably choose one of the extreme positions (with some interesting exceptions). We also suggest a number of variations on the problem that lead to many open problems.