Solving Target Set Selection with Bounded Thresholds Faster than 2^n

07/27/2018 ∙ by Ivan Bliznets, et al. ∙ 0

In this paper we consider the Target Set Selection problem. The problem naturally arises in many fields like economy, sociology, medicine. In the Target Set Selection problem one is given a graph G with a function thr: V(G) →N∪{0} and integers k, ℓ. The goal of the problem is to activate at most k vertices initially so that at the end of the activation process there is at least ℓ activated vertices. The activation process occurs in the following way: (i) once activated, a vertex stays activated forever; (ii) vertex v becomes activated if at least thr(v) of its neighbours are activated. The problem and its different special cases were extensively studied from approximation and parameterized points of view. For example, parameterizations by the following parameters were studied: treewidth, feedback vertex set, diameter, size of target set, vertex cover, cluster editing number and others. Despite the extensive study of the problem it is still unknown whether the problem can be solved in O^*((2-ϵ)^n) time for some ϵ >0. We partially answer this question by presenting several faster-than-trivial algorithms that work in cases of constant thresholds, constant dual thresholds or when the threshold value of each vertex is bounded by one-third of its degree. Also, we show that the problem parameterized by ℓ is W[1]-hard even when all thresholds are constant.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

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

In this paper we consider the Target Set Selection problem. In the problem one is given a graph with a function (a threshold function), and two integers . The question of the problem is to find a vertex subset (a target set) such that and if we initially activate then eventually at least vertices of become activated. The activation process is defined by the following two rules: (i) if a vertex becomes activated it stays activated forever; (ii) vertex

becomes activated if either it was activated initially or at some moment there is at least

activated vertices in the set of its neighbours . Often in the literature by Target Set Selection people refer to the special case of Target Set Selection where , i.e. where we need to activate all vertices of the graph. We refer to this special case as Perfect Target Set Selection.

Target Set Selection problem naturally arises in such areas as economy, sociology, medicine. Let us give an example of a scenario [1, 2] under which Target Set Selection may arise in the marketing area. Often people start using some product when they find out that some number of their friends are already using it. Keeping this in mind, it is reasonable to start the following advertisement campaign of a product: give out the product for free to some people; these people start using the product, and then some friends of these people start using the product, then some friends of these friends and so on. For a given limited budget for the campaign we would like to give out the product in a way that eventually we get the most users of the product. Or we may be given the desired number of users of the product and we would like to find out what initial budget is sufficient. It is easy to see that this situation is finely modelled by the Target Set Selection problem.

The fact that Target Set Selection naturally arises in many different fields leads to a situation that the problem and its different special cases were studied under different names: Irreversible -Conversion Set [3, 4], P-Hull Number [5], -Neighbour Bootstrap Percolation [6], -Influence [7], monotone dynamic monopolies [8], a generalization of Perfect Target Set Selection on the case of oriented graphs is known as Chain Reaction Closure and -Threshold Starting Set [9]. In [3], Centeno et al. showed that Perfect Target Set Selection is NP-hard even when all threshold values are equal to two.

There is an extensive list of results on Target Set Selection from parameterized and approximation point of view. Many different parameterizations were studied in the literature such as size of the target set, treewidth, feedback vertex set, diameter, vertex cover, cluster editing number and others (for more details, see Table 1). Most of these studies consider the Perfect Target Set Selection problem, i.e. the case where . However, FPT membership results for parameters treewidth [2] and cliquewidth [10] were given for the general case of Target Set Selection. From approximation point of view, it is known that the minimization version (minimize the number of vertices in a target set for a fixed ) of the problem is very hard and cannot be approximated within factor for any , unless . This inappoximability result holds even for graphs of constant degree with all thresholds being at most two [11]. Also, the maximization version of the problem (maximize the number of activated vertices for a fixed ) is NP-hard to approximate within a factor of for any [1].

Parameter Thresholds Result Reference

Bandwidth
general Chopin et al. [12]

Clique Cover Number
general NP-hard for Chopin et al. [12]

Cliquewidth cw
constant Hartmann [10]

Cluster Editing Number
general Nichterlein et al. [13]

Diameter
general NP-hard for Nichterlein et al. [13]

Feedback Edge Set Number
general Nichterlein et al. [13]

Feedback Vertex Set Number
general W[1]-hard Ben-Zwi et al. [2]

Neighborhood Diversity nd
majority Dvořák et al. [14]

general W[1]-hard Dvořák et al. [14]

Target Set Size
constant W[P]-complete
Abrahamson et al. [9],
Bazgan et al. [7]

Treewidth
constant Ben-Zwi et al. [2]

majority W[1]-hard Chopin et al. [12]

Vertex Cover Number
general Nichterlein et al. [13]

Table 1: Some known results on different parameterizations of Perfect Target Set Selection. In the Thresholds column we indicate restrictions on the threshold function under which the results were obtained. Here denotes the maximum threshold value.

Taking into account many intractability results for the problem, it is natural to ask whether we can beat a trivial brute-force algorithm for this problem or its important subcase Perfect Target Set Selection. In other words, can we construct an algorithm with running time for some

. Surprisingly, the answer to this question is still unknown. Note that the questions whether we can beat brute-force naturally arise in computer science and have significant theoretic importance. Probably, the most important such question is SETH hypothesis which informally can be stated as:

Hypothesis 1 (Seth).

There is no algorithm for SAT with running time for any .

Another example of such question is the following hypothesis:

Hypothesis 2.

[15] For every hereditary graph class that can be recognized in polynomial time, the Maximum Induced -Subgraph problem can be solved in time for some .

There is a significant number of papers [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26] with the main motivation to present an algorithm faster than the trivial one.

As in the stated hypotheses and mentioned papers, our goal is to come up with an algorithm that works faster than brute-force. We partially answer this question by presenting several running time algorithms for Target Set Selection when thresholds, i.e. the values of , are bounded by some fixed constant and in case when the values of , so-called dual thresholds, are bounded by some fixed constant for every . We think that this result may be interesting mainly because of the following two reasons. Firstly, the result is established for a well-studied problem with many applications and hence can reveal some important combinatorial or algorithmic structure of the problem. Secondly, maybe by resolving the asked question we could make progress in resolving hypotheses 1, 2.

Our results. In this paper, we establish the following algorithmic results.

Perfect Target Set Selection can be solved in

  • if for every we have ;

  • if for every we have ;

  • randomized time if for every we have .

Target Set Selection can be solved in

  • if for every we have ;

  • if for every we have .

We also prove the following lower bound.

Target Set Selection parameterized by is W[1]-hard even if

  • for every .

2 Preliminaries

2.1 Notation and problem definition

We use standard graph notation. We consider only simple graphs, i.e. undirected graphs without loops and multiple edges. By we denote the set of vertices of and by we denote the set of its edges. We let . denotes the set of neighbours of vertex , and . denotes the maximum degree of . By we denote the subgraph of induced by a set of its vertices. Define by the degree of in the subgraph .

By we denote the disjoint union of sets , i.e.  with the additional restriction that for any distinct .

For a graph , threshold function and we put and for every we define We say that becomes activated in the round, if , i.e.  is not activated in the round and is activated in the round. By activation process yielded by we mean the sequence Note that as and rounds is always enough for the activation process to converge. By we denote the set of vertices that eventually become activated, and we say that activates in . Thus, .

We recall the definition of Target Set Selection.

We call a solution of Target Set Selection a target set of .

By Perfect Target Set Selection we understand a special case of Target Set Selection with . We call a perfect target set of , if it activates all vertices of , i.e. .

Most of the algorithms described in this paper are recursive algorithms that use branching technique. Such algorithms are described by reduction rules, that are used to simplify a problem instance, and branching rules, that are used to solve an instance by recursively solving smaller instances. If a branching rule branches an instance of size into instances of size , we call a branching vector of this branching rule. By a branching factor of a branching rule we understand a constant

that is a solution of a linear reccurence corresponding to some branching vector of this rule; such constants are used to bound the running time of an algorithm following the rule with

. Note that a branching rule may have multiple corresponding branching vectors and multiple corresponding branching factors. By the worst branching factor of a branching rule (or multiple branching rules, if they are applied within the same algorithm) we understand the largest among its branching factors. We refer to [27] for a more detailed explanation of these aspects.

In our work we also use the following folklore result.

Lemma 1.

For any positive integer and any such that , we have where .

2.2 Minimal partial vertex covers

Definition 1.

Let be a graph. We call a subset of its vertices a -partial vertex cover of for some , if the set of edges covered by vertices in is exactly , i.e.

We call a -partial vertex cover of a minimal partial vertex cover of if there is no -partial vertex cover of with . Equivalently, there is no vertex so that is a -partial vertex cover of .

The following theorem bounds the number of minimal partial vertex covers in graphs of bounded degree. We note that somewhat similar results were proven by Björklund et al. [28].

Theorem 1.

For any positive integer , there is a constant and an algorithm that, given an -vertex graph with as input, outputs all minimal partial vertex covers of in time.

Proof.

We present a recursive branching algorithm that lists all minimal partial vertex covers of . Pseudocode of the algorithm is presented in Figure 1. As input, the algorithm takes three sets such that . The purpose of the algorithm is to enumerate all minimal partial vertex covers that contain as a subset and do not intersect with . So the algorithm outputs all minimal partial vertex covers of satisfying . It easy to see that then enumerates all minimal partial vertex covers of .

Algorithm:  
Input: Graph with , vertex subsets such that .
Output: All minimal partial vertex covers of such that .
if  then
       foreach  do
            
      
else
       foreach  do
             if  is a minimal partial vertex cover of  then
                   output
            
      
Figure 1: Algorithm enumerating all minimal partial vertex covers of a graph.

The algorithm uses only the following branching rule. If there is a vertex such that then consider branches. In each branch, take some and run . In other words, we branch on which vertices in belong to minimal partial vertex cover and which do not. Note that if is a minimal partial vertex cover then it cannot contain , since otherwise is its proper subset and covers the same edges. Hence, above branching consider all possible cases. Since , the worst branching factor is .

If the branching rule cannot be applied then we apply brute-force on all possible variants of the intersection of the minimal partial vertex cover and the set . So we consider all variants of , and filter out variants that do not correspond to a minimal partial vertex cover. Minimality of a partial vertex cover can be checked in polynomial time, so filtering out adds only a polynomial factor.

Note that we run brute-force only if every vertex in has at least one neighbour in , in other words, is a dominating set of . Since , any dominating set of consists of at least vertices. Hence, . This leads to the following upper bound on the running time of the algorithm:

Hence, we can put

3 Algorithms for bounded thresholds

3.1 Algorithm for thresholds bounded by fixed constant

In this subsection we prove the following theorem.

Theorem 2.

Let be a fixed constant. For Target Set Selection with all thresholds bounded by there is a -time algorithm, where is a positive constant that depends only on .

Our algorithm consists of three main stages. In the first stage we apply some simple reduction and branching rules. If the instance becomes small enough we then apply brute-force and solve the problem. Otherwise, we move to the second stage of the algorithm. In the second stage we perform branching rules that help us describe the activation process. After that we move to the third stage in which we run special dynamic program that finally solves the problem for each branch. Let us start the description of the algorithm.

3.1.1 Stage I

In the first stage our algorithm applies some branching rules. In each branch we maintain the following partition of into three parts . These parts have the following meaning: is the set of vertices that are known to be in our target set, — the set of vertices that are known to be not in the target set, — the set of all other vertices (i.e. vertices about that we do not know any information so far). At the beginning, we have and .

We start the first stage with exhaustive application of reduction rule 1 and branching rule 1.

Reduction rule 1.

If there is any vertex , but , then assign to .

Reduction rule 1 is correct as there is no need to put a vertex in a target set if it will become activated eventually by the influence of its neighbours.

Branching rule 1.

If there is a vertex such that then arbitrarily choose a subset such that and branch on the following branches:

  1. For each subset of vertices of size less than consider a branch in which we put into and we put other vertices into ;

  2. Additionally consider the branch in which we assign all vertices from to and is assigned to .

It is enough to consider only above-mentioned branches. All other possible branches assign at least vertices from to , and we always can replace such branch with the branch assigning to , since it leads to the activation of all vertices in and adds at most the same number of vertices into a target set. Branching rule 1 considers options for vertices, thus it gives the biggest branching factor of (here and below ).

Branching rule 2.

If , where is a constant to be chosen later, then simply apply brute-force on how vertices in should be assigned to and .

If branching rule 2 is applied in all branches then the running time of the whole algorithm is at most and we do not need to use stages II and III, as the problem is already solved in this case.

3.1.2 Stage II

After exhaustive application of reduction rule 1 and branching rules 1 and 2, in each branch we either know the answer or we have the following properties:

  1. ;

  2. ;

  3. .

Now, in order to solve the problem it is left to identify the vertices of a target set that belong to . It is too expensive to consider all subsets of as is too big. Instead of this direct approach (brute-force on all subsets of ) we consider several subbranches. In each such branch we almost completely describe the activation process of the graph. For each branch, knowing this information about the activation process, we find an appropriate target set by solving a special dynamic program in stage III.

Let be an answer (a target set). can be expressed as where . At the beginning of the activation process only vertices in are activated, after the first round vertices in are activated, and so on. It is clear that . Unfortunately, we cannot compute the sequence of as we do not know . Instead we compute the sequence such that and for any .

First of all, using Theorem 1 we list all minimal partial vertex covers of the graph . For each minimal partial vertex cover we create a branch that indicates that and, moreover, covers exactly the same edges in as does. In other words, any edge in has at least one endpoint in if and only if it has at least one endpoint in . Note that such exists for any . One can obtain by removing vertices from one by one while it covers the same edges as . When no vertex can be removed, then, by definition, the remaining vertices form a minimal partial vertex cover.

Put . It is correct since . We now show how to find having . Recall that to do such transition from to it is enough to find vertices with the number of neighbours in being at least the threshold value of that vertex. As for and , it is sufficient to check that the number of activated neighbours has reached the threshold only for vertices that are not in . Thus any transition from to can be done by using a procedure that, given and any vertex , checks whether becomes activated in the round or not, under the assumption that .

Given it is not always possible to find a unique as we do not know . That is why in such cases we create several subbranches that indicate potential values of .

Let us now show how to, for each vertex , figure out whether is in (see pseudocode in Figure 2). Since we know and , we assume that .

If then we simply include in . We claim that this check is enough for .

Claim 1.

If , then becomes activated in the round if and only if .

Proof.

We show that by proving that for every . Note that by definition of . So it is enough to prove that , which is equivalent to , as . Since , then any is covered by if and only if . covers the same edges in as does, and also , hence . Thus, since , we get . ∎

If , the decision for does not matter. Thus if and , we may simply not include in .

If , at this point, we cannot compute the number of activated neighbours of exactly as we do not know what neighbours of are in . Note that we do not need the exact number of such neighbours if we know that this value is at least . Thus we branch into subbranches corresponding to the value of , from now on we denote this value as .

On the other hand, we know all activated neighbours of that are in since , as . Let this number be . So the number of activated neighbours of is at least . Also there may be some activated neighbours of in . However, we cannot simply add to since vertices in will be computed twice. So we are actually interested in the value of . That is why for vertices from we simply branch whether they are in or not. After that we compare with and figure out whether becomes activated in the current round or not.

Note that once we branch on the value of , or on whether or not for some , we will not branch on the same value or make a decision for the same vertex again as it makes no sense. Once fixed, the decision should not change along the whole branch and all of its subbranches, otherwise the information about would just become inconsistent.

Let us now bound the number of branches created. There are three types of branchings in the second stage:

  1. Branching on the value of the minimal partial vertex cover . By Theorem 1, there is at most such branches.

  2. Branching on the value of with . There is at most such possibilities since .

  3. Branching on whether vertex is in or not. We perform this branching only for vertices in the set with only when its size is strictly smaller than . Hence we perform a branching of this type on at most vertices.

Hence, the total number of the branches created in stage II is at most

Algorithm:  
Input: as usual, such that for some , and a vertex .
Output: True, if and ;
False, if and ;
any answer, otherwise.
if  then
       return True
else if  then
       return False
branch on the value of foreach  do
       branch on whether if  then
            
      
return
Figure 2: Procedure determining whether a vertex becomes activated in the current round.

3.1.3 Stage III

Now, for each branch our goal is to find the smallest set which activates at least vertices and agrees with all information obtained during branching in a particular branch. That is,

  • (branchings made in stage I);

  • (branching of the first type in stage II);

  • information about (second type branchings in stage II);

  • additional information whether certain vertices belong to or not (third type branchings in stage II).

From now on we assume that we are considering some particular branching leaf. Let be the set of vertices that are known to be in for a given branch and be the set of vertices known to be not in (note that and ). Let and . So actually it is left to find (in these new terms, ) such that , and for each the value equals . This is true since the information obtained during branching completely determines the value of .

In order to solve the obtained problem we employ dynamic programming. We create a table of size . For all such that and , in the field we store any set of minimum size such that is a potential solution, i.e.  and for every we have . Note that the choice of depends only on values , but not on the value of directly. In other words, stores one of optimal ways of how the remaining vertices in should be chosen into if the first vertices in was chosen correspondingly to the values of and .

Note that for some fields in the table there may be no appropriate value of (there is no appropriate solution). In such cases, we put the corresponding element to be equal to . It is a legitimate operation since we are solving a minimization problem. Note that the desired value of will be stored as

We assign for every such that . We do this since values indicate that is already a solution. In all other fields of type we put the value of . We now show how to evaluate values for any smaller than . We can evaluate any in polynomial time if we have all values evaluated. For each , let . In order to compute , we need to decide whether is in a target set or not. If is taken into then becomes equal to for each , if it is not, none of should change. Hence,

Since for any , the table has fields. Each field of the table is evaluated in polynomial time. So the desired is found (hence, the solution is found) in time for any branch fixed in stage II. Stages II and III together run in time for any fixed subbranch of stage I.

Actually, the multiplier in the upper bound can be improved. Recall that it corresponds to the number of possible variants of and the number of possible variants of . However, note that . So after each of is fixed in stage II, for there is only options in stage III. Hence, each of the pairs can be presented only in variants. This gives an improvement of the multiplier to a multiplier. So, the upper bound on the running time in stages II and III becomes .

We rewrite this upper bound in terms of and . Since , the upper bound is

Now we are ready to choose . We set the value of so that computation in each branch created at the end of stage I takes at most time. Note that the upper bound on the running time required for stages II and III increases while the value of decreases. So we can find as the solution of equation . Hence, . So the overall running time is

which is for some since .

3.2 Two algorithms for constant thresholds in the perfect case

Here, we present two algorithms for special cases of Perfect Target Set Selection with thresholds being at most two or three. These algorithms use the idea that cannot be used in the general case of Target Set Selection, so the running times of these algorithms are significantly faster than the running time of the algorithm from the previous subsection.

Theorem 3.

Perfect Target Set Selection with thresholds being at most two can be solved in time.

Proof.

To make the proof simpler, we firstly prove the following useful lemma.

Lemma 2.

There is a polynomial-time algorithm that, given an integer constant and a graph with thresholds , where for every , outputs a graph with thresholds , such that and . Moreover, has a perfect target set of size if and only if has a perfect target set of size .

Proof.

We prove the lemma by providing a construction of graph . In this construction, is obtained by introducing several new vertices and edges to . It is as follows.

For each integer , introduce a vertex and vertices to , then for each introduce an edge between and . Suchwise for each a star graph with leaves is introduced, with being the center vertex of the star graph. Finally, for each vertex of the initial graph introduce an edge between and for each , that is, connect with the centers of the first introduced star gadgets. Recall that in we consider thresholds all-equal to .

Let now show that if has a perfect target set of size , then has a perfect target set of size at most . Observe that any should be presented in every perfect target set of , since it has only one (that is, less than ) neighbour vertex. Thus, any perfect target set of contains all leaves of the star gadgets. For any fixed , the initial activation of all activates in the first round. Hence, each star gadget provides a vertex that is always activated. Since each vertex is connected to exactly vertices in , after activation of all requires more vertices to become activated, that is the same as it does in . Thus, if we remove the newly-introduced vertices from a perfect target set of , we obtain a perfect target set of . So if the perfect target set of has size , we obtain a perfect target set of of size at most .

In the other direction, if has a perfect target set of size , then has a perfect target set of size . One can obtain a perfect target set of from a perfect target set of by adding all vertices to it. ∎

Lemma 2 allows us to reduce the case when all thresholds are bounded by two to the case when they are equal to two, introducing only a constant number of vertices.

Let be a graph with thresholds, where all thresholds equal two. For this case, we present an algorithm with running time that finds a perfect target set of of minimum possible size.

We set . The algorithm consists of two parts. In the first part, the algorithm applies brute-force on all possible subsets of size at most , in ascending order of their size. If the algorithm finds that is a perfect target set, i.e. , then it outputs the set and stops. Otherwise, the algorithm runs its second part.

The second part of the algorithm is a recursive branching algorithm that maintains sets similarly to the algorithm in subsection 3.1. The branching algorithm consists of two reduction and two branching rules. Here, we reuse reduction rule 1 and branching rule 1 from the previous subsection. Additionally, we introduce the following rules.

Reduction rule 2.

If there is a vertex with , assign to .

Reduction rule 2 is correct since such vertex cannot be activated other than being put in a target set.

Branching rule 3.

If there are two vertices with and , then consider three branches:

  • , ;

  • , ;

  • .

Branching rule 3 is correct since if none of is in a target set, none of them will eventually have two activated neighbours and thus the set cannot be completed to a perfect target set.

If none of the rules can be applied, the algorithm applies brute-force on all possibilities of how vertices in should be assigned to and . This finishes the description of the second part and the whole algorithm. We now give a bound on its running time.

By Lemma 1, the first part of the algorithm runs in time. If the algorithm does not stop in this part, then any perfect target set of consists of at least vertices and the second part is performed.

Branching rules 1 and 3 give branching vectors (five variants are considered for three vertices) and (three variants are considered for two vertices) respectively, and the second vector gives bigger branching factor equal to .

Observe that if branching rules 1, 3 and reduction rules 1, 2 cannot be applied, then is in fact a perfect target set of . Indeed, in that case consists only of isolated vertices and isolated edges, as if there was a vertex with , then branching rule 1 would be applied. Note that if some vertex is isolated in , then it has at least neighbours in , hence it becomes activated in the first round. Consider an isolated edge . Note that and cannot simultaneously have degree two in , since branching rule 3 excludes this case. It means that either or has degree at least three and thus has at least two neighbours in . Hence, it becomes activated in the first round. Since the other vertex has at least one neighbour in , at the end of the first round it will have at least two activated neighbours. Thus, it becomes activated no later than the second round.

We conclude that if we need to apply brute-force on variants, then is a perfect target set of . Hence, and . It follows that the second part running time is at most . So, the running time of the whole algorithm is . ∎

Theorem 4.

Perfect Target Set Selection with thresholds being at most three can be solved in time.

Proof.

Here, we adapt the algorithm working for thresholds equal to two to the case when all thresholds equal three. Again, we then use Lemma 2 to complete the proof.

Let . At first, algorithm applies brute-force over all subsets of size at most and stops if it finds a perfect target set among them. If the algorithm has not found a perfect target set on this step then we run a special branching algorithm.

As with thresholds equal to two we use branching rules 1, 3 and reduction rules 1, 2. The only difference is that now in reduction rule 2 and in branching rule 3 we use constant instead of . We also introduce a new branching rule for this algorithm.

Branching rule 4.

Let , and . Consider all branches that split between and and assign at least one vertex to .

The rule is correct as we omit only one branch that put all three vertices into . Note that if none of the vertices is activated initially then none of them will become activated. Hence, this branch cannot generate any perfect target set.

We apply the above-stated rules exhaustively. When none of the rules can be applied we simply apply brute-force on all possible subsets of . That is the whole algorithm. Now, it is left to bound the running time of the algorithm.

The first part runs in time. If the algorithm does not stop after the first part then any perfect target set of contains at least vertices. Branching rules 1, 3, 4 give the following branching factors respectively: (since options are considered for vertices), ( options for vertices) and