Minimal Roman Dominating Functions: Extensions and Enumeration

Roman domination is one of the many variants of domination that keeps most of the complexity features of the classical domination problem. We prove that Roman domination behaves differently in two aspects: enumeration and extension. We develop non-trivial enumeration algorithms for minimal Roman domination functions with polynomial delay and polynomial space. Recall that the existence of a similar enumeration result for minimal dominating sets is open for decades. Our result is based on a polynomial-time algorithm for Extension Roman Domination: Given a graph G = (V,E) and a function f:V→{0,1,2}, is there a minimal Roman domination function f with f≤f? Here, ≤ lifts 0< 1< 2 pointwise; minimality is understood in this order. Our enumeration algorithm is also analyzed from an input-sensitive viewpoint, leading to a run-time estimate of (^n) for graphs of order n; this is complemented by a lower bound example of Ω(^n).



page 1

page 2

page 3

page 4


Enumerating Connected Dominating Sets

The question to enumerate all inclusion-minimal connected dominating set...

Estimating the Longest Increasing Subsequence in Nearly Optimal Time

Longest Increasing Subsequence (LIS) is a fundamental statistic of a seq...

Enumerating minimal dominating sets in the (in)comparability graphs of bounded dimension posets

Enumerating minimal transversals in a hypergraph is a notoriously hard p...

Counting Minimal Transversals of β-Acyclic Hypergraphs

We prove that one can count in polynomial time the number of minimal tra...

A Note on the Maximum Number of Minimal Connected Dominating Sets in a Graph

We prove constructively that the maximum possible number of minimal conn...

Minimal Dominating Sets in a Tree: Counting, Enumeration, and Extremal Results

A tree with n vertices has at most 95^n/13 minimal dominating sets. The ...

On the Complexity of Solution Extension of Optimization Problems

The question if a given partial solution to a problem can be extended re...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

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.

Figure 1: The Roman Empire in the times of Constantine

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 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.


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.


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:

  1. ,

  2. , also called privacy condition, and

  3. is a minimal dominating set of .


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.


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.

1:procedure ExtRD Solver()
Input: A graph and a function .
Output: Is there a minimal Roman dominating function with ?
2:     .
3:     . { Invariant: }
4:     . { All are considered below; invariant: . }
5:     while  do
6:         Choose . { Hence, . }
7:         for  do
8:              if  then
9:                  .
10:                  Add to and to .                        
11:         Delete from .      
12:     for  do
13:         if  then
14:              Return No.               
15:     for  do
16:         .      
17:     Return Yes.
Algorithm 1 Solving instances of ExtRD
Theorem 4.1

Let be a graph and . For the inputs , Algorithm 1 returns yes if and only if is a yes-instance of ExtRD. In this case, the function  computed by Algorithm 1 is a minimal rdf.


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.


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.

1:procedure RD Enumeration()
Input: A graph .
Output: Enumeration of all minimal rdf .
2:     for all functions  do
3:         for all with  do
4:              if  then
5:                  .                        
6:         Build graph induced by .
7:         .
8:         for all with  do
9:              if  then
10:                  .                        
11:         if  and if is a minimal ds of  then
12:              Output the current function .               
Algorithm 2 A simple enumeration algorithm for 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 .



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 .


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 .


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 .


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.


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:

  1. ,

  2. ,

  3. ,

  4. 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.

1:procedure Refined RD Enumeration()
Input: A graph , a grdf .
Assumption: There exists at least one minimal rdf consistent with .
Output: Enumeration of all minimal rdf consistent with .
2:     if  is everywhere defined and  then
3:         Output and return.      
4:     { We know that . }
5:     Pick a vertex of highest priority for branching.
6:     ; .
7:     Exhaustively apply reduction rules to . { Invariants are valid for . }
8:     if  then
9:         .      
10:     ; if then else .
11:     Exhaustively apply reduction rules to . { Invariants are valid for . }
12:     if  then
13:         .      
Algorithm 3 A refined enumeration algorithm for minimal rdf

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 .


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.

Therefore, the answer no has to be returned in Line 14. That would contradict Condition 2 or Condition 3. Thus the algorithm would correctly return yes. ∎


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.


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