1 Introduction
This paper combines four lines of research: (a) studying variations of domination problems, here the Roman domination [17, 21, 28]; (b) input-sensitive enumeration of minimal solutions, a topic that has drawn attention in particular from people also interested in domination problems [2, 18, 19, 26, 27]; (c) related to (and motivated by) enumeration, extension problems have been introduced and studied in particular in the context of domination problems111Historically, a logical extension problem [10] should be mentioned, as it has led to [40, Théorème 2.16], dealing with an extension variant of 3-Hitting Set; also see [40, Proposition 3.39] concerning implications for Extension Dominating Set. in [3, 9, 11, 12, 32, 33, 40]: is a given set a subset of any minimal dominating set?; (d) the Hitting Set Transversal Problem is the question if all minimal hitting sets of a hypergraph can be enumerated with polynomial delay (or even output-polynomial) only: this question is open for four decades by now and is equivalent to several enumeration problems in logic, database theory and also to enumerating minimal dominating sets in graphs, see [20, 22, 25, 31]. By way of contrast, we show that enumerating all minimal Roman domination functions is possible with polynomial delay, a result which is quite surprising in view of the general similarities between the complexities of domination and Roman domination problems.

Roman Domination comes with a nice (hi)story: namely, it should reflect the idea of how to secure the Roman Empire by positioning the armies (legions) on the various parts of the Empire in a way that either (1) a specific region is also the location of at least one army or (2) one region neighboring has two armies, so that can afford sending off one army to the region (in case of an attack) without diminishing self-defense capabilities. More specifically, Emperor Constantine had a look at a map of his empire (as discussed in [49], also see Fig. 1).222 The historical background is also nicely described in the online Johns Hopkins Magazine, visit http://www.jhu.edu/~jhumag/0497web/locate3.html to pre-view [45]. Related is the island hopping strategy pursued by General MacArthur in World War II in the Pacific theater to gradually increase the US-secured areas.
Roman Domination has received a lot of attention from the algorithmic community in the past 15 years [4, 15, 21, 24, 35, 36, 39, 43, 44, 47]. Relevant to our paper is the development of exact algorithms for Roman Domination: combining ideas from [35, 46], an exponential-time and -space algorithm (making use of known Set Cover algorithms via a transformation to Partial Dominating Set) was presented in [48]. In [14, 16, 23, 30, 34, 38, 37, 42, 50, 51, 52], more combinatorial studies can be found. This culminated in a chapter on Roman domination, stretching over nearly 50 pages in the monograph [29]. There is also an interesting link to the notion of a differential of a graph, introduced in [41], see [7], also adding further algorithmic thoughts, as expressed in [1, 5, 6]. For instance, in [5] an exponential-time algorithm was published, based on a direct Measure-and-Conquer approach.
One of the ideas leading to the development of the area of extension problems (as described in [12]) was to cut branches of search trees as early as possible, in the following sense: to each node of the search tree, a so-called pre-solution can be associated, and it is asked if it is possible to extend to a meaningful solution . In the case of Dominating Set, this means that is a set of vertices and a ‘meaningful solution’ is an inclusion-wise minimal dominating set. Notice that such a strategy would work not only for computing smallest dominating sets, but also for computing largest minimal dominating set, or for counting minimal solutions, or for enumerating them. Alas, as it has been shown by many examples, extension problems turn out to be quite hard problems. Even for combinatorial problems whose standard decision version is solvable in polynomial time (for instance, Edge Cover), its extension variation is NP-hard. In such a case, the approach might still be viable, as possibly parameterized algorithms exist with respect to the parameter ‘pre-solution size’. This would be interesting, as this parameter is small when a big gain can be expected in terms of an early abort of a search tree branch. In particular for Extension Dominating Set, this hope is not fulfilled. To the contrary, with this parameterization , Extension Dominating Set is one of the few problems known to be complete for the parameterized complexity class W[3], as shown in [8].
With an appropriate definition of the notion of minimality, Roman Domination becomes one of the few examples where the hope seeing extension variants being efficiently solvable turns out to be true, as we will show in this paper. This is quite a surprising result, as in nearly any other way, Roman Domination behaves most similar to Dominating Set. Together with its combinatorial foundations (a characterization of minimal Roman domination functions), this constitutes the first main result of this paper. The main algorithmic exploit of this result is a non-trivial polynomial-space enumeration algorithm for minimal Roman domination functions that guarantees polynomial delay only, which is the second main result of the paper. As mentioned above, the corresponding question for enumerating minimal dominating sets is open since decades, and we are not aware of any other modification of the concept of domination that seems to preserve any other of the difficulties of Dominating Set, like classical or parameterized or approximation complexities, apart from the complexity of extension and enumeration. Our enumeration algorithm is a branching algorithm that we analyzed with a simple Measure & Conquer approach, yielding a running time of , which also gives an upper bound on the number of minimal Roman dominating functions of an -vertex graph. This result is complemented by a simple example that proves a lower bound of for the number of minimal Roman dominating functions on graphs of order .
2 Definitions
Let be the set of positive integers. For , let . We only consider undirected simple graphs. Let be a graph. For , denotes the graph induced by . For , denotes the open neighborhood of , while is the closed neighborhood of . We extend such set-valued functions to by setting . Subset is a dominating set, or ds for short, if . For and , define the private neighborhood of with respect to as . A function is called a Roman dominating function, or rdf for short, if for each with , there exists a with . To simplify the notation, we define for . The weight of a function equals . The classical Roman Domination problem asks, given and an integer , if there exists an rdf for of weight at most . Connecting to the original motivation, models a map of regions, and if the region vertex belongs to , then we place armies on .
For the definition of the problem Extension Roman Domination, we need to define the order on first: for , let if and only if for all . In other words, we extend the usual linear ordering on to functions mapping to in a pointwise manner. We call a function a minimal Roman dominating function if and only if is a rdf and there exists no rdf , , with .333According to [29], this notion of minimality for rdf was coined by Cockayne but then dismissed, as it does not give a proper notion of upper Roman domination number. However, in our context, this definition seems to be the most natural one, as it also perfectly fits the extension framework proposed in [13]. We will propose in section 7 yet another notion of minimal rdf that also fits the mentioned extension framework. The weights of minimal rdf can vary considerably. Consider for example a star with center . Then, , otherwise; for all vertices ; , for one , otherwise, define three minimal rdf with weights , and .
Problem name: Extension Roman Domination, or ExtRD for short Given: A graph and a function Question: Is there a minimal rdf with ?
As our first main result, we are going to show that ExtRD can be solved in polynomial time in section 4. To this end, we need some understanding of the combinatorial nature of this problem, which we provide in section 3.
The second problem that we consider is that of enumeration, both from an output-sensitive and from an input-sensitive perspective.
Problem name: Roman Domination Enumeration, or RDEnum for short Given: A graph . Task: Enumerate all minimal rdf of !
From an output-sensitive perspective, it is interesting to perform this enumeration without repetitions and with polynomial delay, which means that there is a polynomial such that between the consecutive outputs of any two minimal rdf of a graph of order that are enumerated, no more than time elapses, including the corner-cases at the beginning and at the end of the algorithm. From an input-sensitive perspective, we want to upper-bound the running time of the algorithm, measured against the order of the input graph. The obtained run-time bound should not be too different from known lower bounds, given by graph families where one can prove that a certain number of minimal rdf must exist. Our algorithm will be analyzed from both perspectives and achieves both goals. This is explained in section 5 and in section 6.
3 Properties of Minimal Roman Dominating Functions
Theorem 3.1
Let be a graph and be a minimal rdf. Then holds.
Proof
Assume that there exists a with and . Let
We show that is a rdf, which contradicts the minimality of , as and are given by construction. Consider . If , is dominated by , as . Consider . Since is a rdf and , there exists a . By construction of , holds. This implies . Hence, is a rdf. ∎
Theorem 3.2
Let be a graph and be a minimal rdf. Then for all , holds.
Proof
Define . In contrast to the claim, assume that there exists a with . Define
We show that is a rdf, which contradicts the minimality of , as and are given by construction. Let . We must show that some neighbor of belongs to . Then, is a rdf.
First, assume that is a neighbor of . By the choice of , is not a private neighbor of . Hence, there exists a . Secondly, if is not a neighbor of , then there exists a that dominates , i.e., . ∎
As each has to be dominated by a , the next claim follows.
Corollary 1
Let be a graph and be a minimal rdf. Then, is a minimal ds of , with .
Remark 1
We can generalize the last statement as follows: Let be a graph and be a minimal rdf. Let be an independent set in . Then, is a minimal ds of . If is a maximal independent set in , then is a minimal ds of .
This allows us to deduce the following characterization result.
Theorem 3.3
Let be a graph, and abbreviate . Then, is a minimal rdf if and only if the following conditions hold:
-
,
-
, also called privacy condition, and
-
is a minimal dominating set of .
Proof
The “only if” follows by Theorem 3.1, Theorem 3.2 and 1.
Let be a function that fulfills the three conditions. Since is a dominating set on , for each , there exists a . Therefore, is a rdf.
Let be a minimal rdf with . Therefore, (also) satisfies the three conditions by Theorem 3.1, Theorem 3.2 and 1.
Assume that there exists a with . Hence, .
Case 1: . Therefore, there exists a with . This contradicts Condition 1.
Case 2: . Let with . This implies and
holds. Therefore, . This contradicts Condition 2.
Thus, holds and is minimal. ∎
We conclude this section with an upper bound on the size of .
Lemma 1
Let be a graph and be a minimal rdf. Then holds.
Proof
Consider a graph and a minimal rdf . For each , let . By Theorem 3.2, these sets are not empty and, by definition, they do not intersect. Hence, we get:
Therefore, the claim is true. ∎
4 A Polynomial-time Algorithm for ExtRD
With Theorem 7.1, we can construct an algorithm that solves the problem Extension Roman domination in polynomial time.
Input: A graph and a function .
Output: Is there a minimal Roman dominating function with ?
Theorem 4.1
Proof
First observe that the invariants stated in Lines 3 and 4 of Algorithm 1 are true whenever entering or leaving the while-loop.
Let the answer of the algorithm be yes and be the function computed by the algorithm. We will show that satisfies the conditions formulated in Theorem 7.1.
Observing the if-condition in Line 8, clearly after the while-loop, no neighbor of fulfills . Hence, satisfies Condition 1. If the function would contradict Condition 2 of Theorem 7.1, then we would get to Line 14 and the algorithm would answer no. As we are considering a yes-answer of our algorithm, we can assume that this privacy condition holds after the for-loop of Line 12. We also can assume that is a minimal ds of the graph . Otherwise, for such a and each , there would exist a . In this case, the algorithm would return no in Line 14. In the for-loop of Line 15, we update for all the value to . With the while-loop, this implies . Therefore, is a minimal ds of . Since we do not update the values of to two in this last for-loop, Condition 2 from Theorem 7.1 holds. By the while-loop and the for-loop starting in Line 15, it is trivial to see that Condition 1 also holds for the final . We can now use Theorem 7.1 to see that is a minimal rdf.
Since we never decrease in this algorithm, starting with in Line 2, we get . Therefore, is a yes-instance of ExtRD.
Now we assume that is a yes-instance, but the algorithm returns no. Therefore, there exists a minimal rdf with . Since , holds for the function in Line 12. This implies . The algorithm returns no if and only if there exists a with
Applying again Theorem 7.1, we see that cannot be a minimal rdf, contradicting our assumption. ∎
In 1, we prove that our algorithm needs polynomial time only.
Proposition 1
Algorithm 1 runs in time cubic in the order of the input graph.
Proof
Let be the input graph. Define . Up to Line 4, the algorithm can run in linear time. As each vertex can only be once in and we look at the neighbors of each element in , the while-loop runs in time . In the for-loop starting in Line 12, we build for all the set . This needs time. The other steps of this loop run in time . The last for-loop requires linear time. Hence, the algorithm runs in time . ∎
5 Enumerating Minimal RDF for General Graphs
For general graphs, our general combinatorial observations allow us to strengthen the (trivial) -algorithm for enumerating all minimal rdf for graphs of order down to , as displayed in Algorithm 2. To understand the correctness of this enumeration algorithm, the following lemma is crucial.
Input: A graph .
Output: Enumeration of all minimal rdf .
Lemma 2
Let be a graph with such that for each holds. Then there exists exactly one minimal rdf with . Algorithm 1 can calculate .
Proof
Define
Hence, . With the assumption , is a minimal ds of . Furthermore, . As , all conditions of Theorem 7.1 hold and is a minimal rdf.
Let be a minimal rdf with . If there exists some , this contradicts Condition 1, as . Therefore, holds. By the assumption that is a rdf, for each there exists a . This implies . Therefore, holds. This implies .
Define:
It is trivial to see that . By Theorem 4.1, Algorithm 1 returns yes for the input . Let be the the minimal rdf produced by Algorithm 1, given . We want to show that . We do this by looking at the steps of the algorithm. Since , the algorithm never gets into the If-clause in Line 8. This is the only way to update a vertex to the value 2. Therefore, . ∎
Proposition 2
Let be a graph. For minimal rdf with , it holds .
Proof
By Theorem 3.2, fulfills the conditions of 2. Therefore, there exists a unique minimal rdf with . Thus. holds. ∎
Hence, there is a bijection between the minimal rdf of a graph and subsets that satisfy the condition of 2.
Proposition 3
All minimal rdf of a graph of order can be enumerated in time .
Proof
Consider Algorithm 2. The running time claim is obvious. The correctness of the algorithm is clear due to Theorem 7.1 and 2. ∎
The presented algorithm clearly needs polynomial space only, but it is less clear if it has polynomial delay. Below, we will present a branching algorithm that has both of these desirable properties, and moreover, its running time is below . How good or bad such an enumeration is, clearly also depends on examples that provide a lower bound on the number of objects that are enumerated. The next lemma explains why the upper bounds for enumerating minimal rdf must be bigger than those for enumerating minimal dominating sets.
Lemma 3
A disjoint collection of cycles on five vertices yields a graph of order that has many minimal rdf.
Proof
Let be a cycle of length 5 with and . For a there are at least the following sixteen possibilities for :
-
zero occurrences of 2: ;
-
one occurrence of 2: and four more cyclic shifts;
-
two adjacent occurrences of 2: and four more cyclic shifts;
-
two non-adjacent occurrences of 2: and four more cyclic shifts.
Therefore, there are at least 16 minimal rdf on . To prove that these are all the minimal rdf, we use Lemma 1, which implies . Hence, the number of minimal rdf on is at most . ∎
Corollary 2
There are graphs of order that have at least many minimal rdf.
We checked with the help of a computer program that there are no other connected graphs of order at most eight that yield (by taking disjoint unions) a bigger lower bound.
6 A Refined Enumeration Algorithm
In this section, we are going to prove the following result, which can be considered as the second main result of this paper.
Theorem 6.1
There is a polynomial-space algorithm that enumerates all minimal rdf of a given graph of order with polynomial delay and in time .
Notice that this is in stark contrast to what is known about the enumeration of minimal dominating sets, or, equivalently, of minimal hitting sets in hypergraphs. Here, it is a long-standing open problem if minimal hitting sets in hypergraphs can be enumerated with polynomial delay.
The remainder of this section is dedicated to describing the proof of this theorem.
6.1 A bird’s eye view on the algorithm
As all along the search tree, from inner nodes we branch into the two cases if a certain vertex is assigned or not, it is clear that (with some care concerning the final processing in leaf nodes) no minimal rdf is output twice. Hence, there is no need for the branching algorithm to store intermediate results to test (in a final step) if any solution was generated twice. Therefore, our algorithm needs only polynomial space, as detailed in 7 and 4.
Because we have a polynomial-time procedure that can test if a certain given pre-solution can be extended to a minimal rdf, we can build (a slightly modified version of) this test into an enumeration procedure, hence avoiding unnecessary branchings. Therefore, whenever we start with our binary branching, we know that at least one of the search tree branches will return at least one new minimal rdf. Hence, we will not move to more than nodes in the search tree before outputting a new minimal rdf, where is upper-bounded by twice the order of the input graph. This is the basic explanation for the claimed polynomial delay, as detailed in 5.
Let be a graph. Let us call a(ny partial) function
a generalized Roman domination function, or grdf for short. Extending previously introduced notation, let , and . A vertex is said to be active if it has not been assigned a value (yet) under ; these vertices are collected in the set . Hence, for any grdf , we have the partition .
After performing a branching step, followed by an exhaustive application of the reduction rules, any grdf considered in our algorithm always satisfies the following (grdf) invariants:
-
,
-
,
-
,
-
if , then .444This condition assumes that our graphs have non-empty vertex sets.
For the extension test, we will therefore consider the function that is derived from a grdf as follows:
The enumeration algorithm uses a combination of reduction and branching rules, starting with the nowhere defined function , so that . The schematics of the algorithm is shown in Algorithm 3. To understand the algorithm, call an rdf as consistent with a grdf if implies and implies and implies . Below, we start with presenting some reduction rules, which also serve as (automatically applied) actions at each branching step, whenever applicable. The branching itself always considers a most attractive vertex and either gets assigned 2 or not. The running time analysis will be performed with a measure-and-conquer approach. Our simple measure is defined by for some constants and that have to be specified later.
The measure never increases when applying a reduction rule.
Input: A graph , a grdf .
Assumption: There exists at least one minimal rdf consistent with .
Output: Enumeration of all minimal rdf consistent with .
We are now presenting details of the algorithm and its analysis.
6.2 How to achieve polynomial delay and polynomial space
In this section, we need a slight modification of the problem ExtRD in order to cope with pre-solutions. In this version, we add to an instance, usually specified by and , a set with . The question is if there exists a minimal RDF with and . We call this problem a generalized rdf extension problem, or GenExtRD for short. In order to solve this problem, we modify Algorithm 1 to cope with GenExtRD by adding an if-clause after Line 8 that asks if . If this is true, then the algorithm returns no, because it is prohibited that is set to 2, while this is necessary for minimal rdf, as there is a vertex in the neighborhood of such that has been set to 1. We call this algorithm GenExtRD Solver.
Lemma 4
Let be a graph, be a function and be a set with . GenExtRD Solver gives the correct answer when given the GenExtRD instance .
Proof
In Algorithm 1, the only statement where we give a vertex the value is in the if-clause of Line 8. The modified version would first check if the vertex is in . If this is true, there will be no minimal RDF solving this problem. Namely, if we give the vertex the value , this would contradict . If the value stays , this would contradict Condition 1. By Theorem 4.1, will be a minimal rdf with if the algorithm returns yes.
Assume there exists a minimal RDF with but the algorithm returns no. First we assume that no is returned by the new if-clause. This implies that a vertex is in the neighborhood of a vertex that has to have the value 2 in any minimal rdf that is bigger than (because Theorem 4.1). But this would lead to a similar contradiction as above.
Let
be a generalized rdf at any moment of the branching algorithm. The next goal is to show that
GenExtRD Solver could tell us in polynomial time if there exists a minimal rdf that could be enumerated by the branching algorithm from this point on.Proposition 4
Let be a graph, be a partial function. Then, GenExtRD Solver correctly answers if there exists some minimal rdf that is consistent with when GenExtRD Solver is given the instance .
The following proof makes use of the grdf invariants presented above, which are only formally proved to hold in the next subsection, in 8.
Proof
We have to show two assertions: (1) If GenExtRD Solver answers yes on the instance , then there exists a minimal rdf that is consistent with . (2) If there exists a minimal rdf that is consistent with , then GenExtRD Solver answers yes on the instance .
ad (1): Assume GenExtRD Solver found a minimal rdf such that and . Let . First assume that . Clearly, vertices in do not get changed, as they cannot be made bigger. Hence, assume exists with . As GenExtRD Solver will only explicitly set the value 2 for vertices originally set to 1 (by their -assignment) that are in the neighborhood of vertices already set to value 2 and that do not belong to , we have to reason about a possible . By the third grdf invariant, the neighborhood of contains no vertex from , so that the case of some with can be excluded.
Secondly, assume that . The case is not critical, and is not possible, as reasoned above. Notice that was set in the last lines of the algorithm. In particular, . As , also . By the first grdf invariant, . Hence, only remains as a possibility.
Thirdly, assume that . As is clearly impossible, must follow. Hence, is consistent with .
ad (2): Assume that there exists a minimal rdf that is consistent with . We have to prove that and that , because then GenExtRD Solver will correctly answer yes by 4. For , then consistency implies , and trivially . For , , and hence , so that . If , then