Large meetings waste working time. Our aim is to split a large meeting into a number of smaller meetings, so the average number topics that a person discusses is minimized but every person has to be in every meeting they are interested in.


Given is a function from a set of topics \$T\$ to a set of persons \$P\$ that are interested in this topic $$f:T \rightarrow 2^P$$ and maximum partition size \$m\$.

This is encoded as an array of arrays, where element \$f(i)\$ contains the topics of person \$i\$.

Test Case

m = 3
f = [


Find a partition of \$T\$ (a split into subsets that are disjoint and that cover the whole set) into $$X = {T_1, T_2, \ldots, T_n}$$ where \$n\le m\$, so that the following term is minimized: $$r = \sum_{T' \in X}{(|(\bigcup_{t \in T'} f(t))|\times |T'|)} $$

To help understand \$r\$, if each topic takes an hour to discuss, then \$r\$ is the total amount of person hours required for the meetings.

If there are multiple partition sizes with the same \$r\$, \$n\$ should be minimized as well.

The output should contain the partition \$X\$ as a two-dimensional array, such as: $$X = [[0,1,2,3],[4,5,6],[7,8,9]] $$

Winning Condition

I am looking for the fastest algorithm that finds the absolute minimum \$r\$ and \$n\$.

If that is not possible in polynomial time, then I am also looking for an polynomial algorithm that has the lowest upper bound on \$r\$ in relation to the absolute minimum \$r\$ (e.g. double).

  • 1
    \$\begingroup\$ @KevinCruijssen Sorry, I should have stated that more clearly, I will edit the answer. The problem is that I don't know the complexity class of the problem and depending on it, it is either one of those. I will add the other tag and hope that is OK. \$\endgroup\$ Commented Oct 10, 2018 at 13:56
  • 2
    \$\begingroup\$ @KonradHöffner Are we allowed to assume that the input list of interesting topics is sorted l to g? (aka treat it as a set in code as well as equation) \$\endgroup\$ Commented Oct 10, 2018 at 16:56
  • 2
    \$\begingroup\$ I'd like a description of the term r in words. You don't really describe what it is or means. \$\endgroup\$
    – mbomb007
    Commented Oct 11, 2018 at 0:00
  • 1
    \$\begingroup\$ @mbomb007: r is the sum of topics that all persons must discuss. If each topic takes an hour to discuss, then it is the total amount of person hours required for the meetings. \$\endgroup\$ Commented Oct 11, 2018 at 7:07
  • 1
    \$\begingroup\$ @Konrad - that description ("total amount of person hours") is really helpful - you should add that into the question. \$\endgroup\$ Commented Oct 11, 2018 at 8:49

1 Answer 1


R with lpSolve

Turn the problem into an integer linear programming problem with \$2^t\$ variables and \$t+1\$ constraints, where \$t\$ is the number of topics. The cost function is modified by multiplying it with \$m\$ and adding the size of the partition. This makes the size of the partition a secondary optimization goal.


decode <- function(n) {
  res <- c()
  i <- 1
  while (n>0){
    if (n %% 2 == 1)
      res <- c(res,i)
    i <- i+1
    n <- n %/% 2

opt <- function(m,p) {
  nr_pers <- length(p)
  nr_topics <- max(unlist(p))
  x <- array(0,c(nr_topics,nr_pers))
  for (i in 1:nr_pers)
    for (j in 1:length(p[[i]]))
      x[p[[i]][[j]],i] <- 1
  l <- array(0,c(2^nr_topics,nr_pers))
  cb <- rep(0,2^nr_topics)
  w <- rep(1,2^nr_topics)
  mt <- matrix(0,nr_topics+1,2^nr_topics)
  mt[nr_topics+1,1] <- 1
  len <- 1
  for (i in 1:nr_topics) {
    for(j in 1:len) {
      j1 <- len+j
      l[j1,] <- l[j,]+x[i,]
      cb[j1] <- cb[j] + 1
      w[j1] <- m*sum(l[j1,] != 0)*cb[j1]+1
      mt[,j1] <- mt[,j]
      mt[nr_topics+1-i,j1] <- 1
    len <- 2*len
  dir <- c(rep("=",nr_topics),"<=")
  rhs <- c(rep(1,nr_topics),m)
  sol <- lp("min",w,mt,dir,rhs,all.bin=TRUE)$solution
  res <- list()
  j <- 1
  for (i in 1:length(sol))
    if (sol[i]==1) {
      res[[j]] <- decode(i-1)
      j <- j+1

# test case
f <- list(

On debian, this needs the package r-cran-lpsolve. The code assumes that the topics start with 1 and that each topic number up to the maximum is used. Input and output is as list of vectors, which is not too nice. The test case example is defined in the code, but the list can of course also be entered directly.

To use it, start R and then source the code file and use the function like this:

> source("opt.r")
Loading required package: lpSolve
> opt(3,f)
[1] 1 2 3 4

[1] 6 8

[1] 5 7 9


So [[1,2,3,4],[6,8],[5,7,9]] is an optimal partition for the test case.

  • \$\begingroup\$ Wow thanks, I didn't think about ILP at all! What is the complexity of that approach? How long did it run? I can only test it later but accepted it already as the bounty is running out. \$\endgroup\$ Commented Dec 12, 2018 at 9:29
  • 1
    \$\begingroup\$ I think you can and should handle the bounty and acceptance separately. The preparation step is exponential in the number of topics, linear in the number of persons and independent from m. The example test case takes less than a second. \$\endgroup\$ Commented Dec 12, 2018 at 11:37

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.