Low Complexity Algorithms that return an Optimal Solution

computational complexity. Note that the emphasis, here, is on providing a guarantee on the performance of the algorithm in worst-case scenarios. One might intuitively think of this class as being the most preferable of all classes. After all, what we are usually interested in is to find an optimal solution and minimize the computational complex- ity, which is exactly what defines this class of algorithms. However, if such algorithms are to be feasibly applicable, then there is an additional requirement that could even be more crucial than the aforementioned ones, and that is to return a solutionas quickly as possible. This is mainly because we are dealing, here, with an exponentially growing search space, meaning that the algorithm, given large numbers of agents, might require a significant amount of time before returning a solution. Based on this, the agents might prefer to use an algorithm that returns a“good”solution very quickly, instead of using an algorithm for which the agents have no time to run to completion. In other words, the agents might be willing to make a trade-off between the quality of the solution, and the time required to run the algorithm.

Having identified this class, we shall discuss the state of the art algorithms that belong to it. Note that the time required to run these algorithms depends solely on the number of agents involved (i.e. given the same number of agents, and given different coalition values, the algorithm performs exactly the same number of operations, regardless of the differences in the values). Before going into the details of how these algorithms work, we shall first explain the basic method upon which these algorithms are built, namely dynamic programming, and identify the problems that can generally be solved using this method.

Dynamic programming is a method for solving problems that exhibit the properties ofoptimal substructureandoverlapping subproblems[Cormen et al., 2001]:

• Optimal substructure (also known as theprinciple of optimality[Bellman, 1957]) means that, in order to solve a problem, we can break it into subproblems, solve them recursively, and then combine the results to solve the original problem.

• Overlapping subproblems means that the subproblems are not independent, that is, subproblems share subsubproblems.

A dynamic programming algorithm solves every subsubproblem just once and saves its answer in a table, thereby avoiding the work of recomputing the answer every time the subsubproblem is encountered [Cormen et al., 2001]. In our case, the optimization problem is to find the optimal partition of the set of agentsA, and the subproblem is to find the optimal partition of a subset ofA.

In this context, Yeh [1986] developed a dynamic programming algorithm for solving the complete set partitioning problem. A very similar algorithm was later developed by Rothkopf et al. [1995] for solving the winner determination problem in combinatorial auctions. Note that both algorithms can directly be applied to find optimal coalition structures, since the problems they were originally designed to solve are very similar to the CSG problem (see Section 1.1). Also note that both algorithms are very similar in that they use the same techniques, and have the same complexity. Moreover, explaining how one of them works is sufficient to understand how the other one works. Therefore, we shall only discuss one of these algorithms, namely the one developed by Rothkopf et al. (henceforth called DP). We chose this one because it is relatively simpler and easier to implement).

The algorithm is detailed in Figure 2.3, and the way it operates is based on the fol- lowing observation:

.

Observation 1.1. Let CS∗ be an optimal coalition structure and letC∗ ∈ CS∗. Also, letC∗ ⊇C1∪C2∪. . .∪Ck such that these coalitions are pairwise disjoint (i.e.Ci∩Cj =φfor all1≤i < j ≤k). Then,v(C∗)≥

Pk

i=1v(Ci).

In other words, if a coalitionC∗ belongs to the optimal coalition structure CS∗, then dividing C∗ into smaller coalitions can never result in a better value for CS∗. For example, if an optimal partition of the set A = {1,2,3,4,5,6,7,8,9}was as follows:

{{1,2},{3,4,5},{6},{7,8,9}}, then the optimal partition of the set{1,2,3,4,5}must be{{1,2},{3,4,5}}, and similarly, the optimal partition of the set{6,7,8,9}must be

{{6},{7,8,9}}. This can be proved by contradiction. Suppose that this was not the case, and that another partition of{6,7,8,9}, say{{6,7},{8,9}}, had a greater value. In this case, {{1,2},{3,4,5},{6},{7,8,9}} can no longer be an optimal partition of

A, because we could replace {6},{7,8,9} with {6,7},{8,9} and get a greater value (i.e. the optimal partition ofAwould then be{{1,2},{3,4,5},{6,7},{8,9}}).

Chapter 2 Literature Review 24

Input:v(C)for allC ⊆A. If nov(C)is specified thenv(C) = 0.

Output:the optimal coalition structure,CS∗.

1. For alli∈ {1, . . . , n}, setf1({ai}) :={ai}, f2(ai) :=v({ai})

2. Fori:= 2 ton, do:

For allC ⊆Asuch that|C|=i, do:

(a)f2(C) :=max{f2(C\C0) +f2(C0) :C0 ⊆Cand1≤ |C0| ≤1/2|C|}

(b) Iff2(C)≥v(C), setf1(C) :=C∗ whereC∗maximizes the right hand side of (a) (c) Iff2(C)< v(C), then setf1(C) :=C, andf2(C) :=v(C).

3. SetCS∗ :={A}.

4. For everyC ∈CS∗, do: Iff1(C)6=C, then:

(a) SetCS∗ := (CS∗\{C})∪ {f1(C), S\f1(C)}. (b) Goto 4 and start with newCS∗.

FIGURE2.3: The DP algorithm for coalition structure generation.

The algorithm requires maintaining two tables in memory, namelyf1 andf2, each hav- ing an entry for every possible coalition. Specifically, given a coalitionC ⊆ A, f1(C) would be the optimal partition of C, and f2(C) would be the value of that partition.3 Note thatf1 andf2are initially not known, and the algorithm gradually computes them as it scans the input, starting from the coalitions of size 2, then 3, then 4, and so on.

To better understand how the algorithm works, let us consider the following example, whereA = {1,2,3,4}(see Figure 2.4). At first, the algorithm goes through the coali- tions of size 2, and for each of these, determines whether to split the coalition in two, or keep it as it is. For example, givenC ={1,2}, the algorithm determines whether{1,2}

is more beneficial than {{1},{2}}, and that is by comparing the values: v({1,2})and

v({1}) +v({2}). Both the solution and its value are kept inf1(C)and f2(C)respec- tively.4 The algorithm then moves to the coalitions of size 3. Here, the algorithm also determines whether to split each of these in two, but the decision is now made based onf2 rather thanv. For example, given the coalition{1,2,3}, the algorithm compares its value with the following values: f2({1}) +f2({2,3}), f2({2}) +f2({1,3}), and

f2({3}) +f2({1,2}). Similarly, the algorithm determines whether to split the coalition of size 4 in two.

3_{A partition of a coalitionCcan be defined as a set of coalitions{C}

1, . . . , Ck}such that∪ki=1Ci =C,

and for all1≤i < j≤k, we haveCi∩Cj=φ.

4_{Actually, in case it was more beneficial to split the coalition in two, rather than keep it as it is, then}

only one half of the solution needs to be kept inf1. This is because, by knowing one half, the other half

can easily be retrieved. However, to make the example easier to understand, we ignore this fact. Note that this does not affect the performance analysis.

FIGURE 2.4: Example of how the DP algorithm performs, given a set of agents

A = {1,2,3,4}. Here, the arrows show some of the cases where a solution of a subsubproblem is used to find the solution of a subproblem

Note that, by considering all the possible ways of splitting a coalitionCin two, and by usingf2instead ofv, the optimal partition ofCcan be found. This comes from Observa- tion 1.1, which implies that ifCS∗was an optimal partition ofA, then by splittingCS∗

into two disjoint sets of coalitions, namely CS₁∗ = {C1,1, . . . , C1,k1} : ∪ki=11 Ci = A1, andCS₂∗ ={C2,1, . . . , C2,k2}:∪ki=12 Ci =A2, thenCS1∗ must be an optimal partition of

A1, andCS₂∗ must be an optimal partition ofA2. In other words, any optimal partitions (containing more than one coalition) must consist of two optimal partitions of two sub- problems.

The last stage (step 4 in Figure 2.3) would be to find the optimal coalition structure ofA, given that we have finished computingf1 andf2for every possible coalition. This is done as follows. Suppose that the best way to splitAin two was the following: (A1,

A2),5this means that the optimal partition ofAcan be found by combining the optimal partition ofA1 with the optimal partition ofA2. Now, each of these two partitions can be found in a similar way. For example, suppose that the best way to divideA1 in two was as follows: (A1,1, A1,2), this means that the optimal partition ofA1 can be found by combining the optimal partition of A1,1 with the optimal partition of A1,2, and so on. This process is repeated until we find a coalition structure in which f1 for every

5_{We would know this by looking atf}

1(A1))which, in this case, must contain one half of the solution

Chapter 2 Literature Review 26

coalition contains the coalition itself. In other words, every coalition is better left as it is, rather than split in two.

The saving, at this stage, comes from the fact that solutions of subproblems do not need to be recomputed over and over again. For example, we do not need to evalu- ate both{{1},{2,4}}and{{1},{2},{4}}, because we already performed the compar- ison between {2,4} and {2},{4} when calculating the best partition of{2,4}. Simi- larly, we do not need to evaluate{{2},{1,3,4}},{{2},{1},{3,4}},{{2},{3},{1,4}},

{{2},{4},{1,3}},{{2},{1},{3},{4}}, because we have already done the comparison between all the underlined parts before. The arrows in Figure 2.4 show some of the cases where the solution of a subsubproblem is used to find the solution of a subprob- lem.

The biggest advantage of this algorithm is that it runs in O(3n)time [Rothkopf et al., 1995]. This is significantly less than exhaustive enumeration of all coalition structures (which isO(nn)). In more detail, this makes the algorithm polynomial in the size of the input. The reason for this is that the input includes2n_{values, and the algorithm runs in:}

O(3n) = O(2(log23)n) = O((2n)log23) (2.1) time. Thus the complexity is O(ylog23), where y is the number of values in the input. Note that no other algorithm in the literature is guaranteed to find the optimal coalition structure in polynomial time (in the size of the input).

On the other hand, one of the biggest limitations on using this algorithm is that it cannot generate solutions anytime. This is clearly undesirable, especially given large numbers of agents, because the time required to return the optimal solution might be longer than the time available to the agents. Another limitation on this algorithm (and on dynamic programming in general) is the large number of partial solutions that must be kept in memory. Specifically, the algorithm requires maintaining3×2nvalues in memory. This is because for every coalitionC, the algorithm requires maintainingv(C), f1(C), and

f2(C). These limitations make this class of algorithms only suitable for cases where the number of agents is small (e.g. 20 agents or less).

2.2.2

Fast Algorithms that provide no Guarantees on their Solu-