Subsets of n users with r relationships between them - r

Question

What I want
I have a daframe whose first two columns are combinations of m string values. Those values are users ids and the dataframe represents relationships between them. Every row includes a user par (user1, user2) and the number of times user1 has visited user2's profile. There are m different users but there are no rows for every possible relationship, only for those who have visited the other's profile. Mutual pairs can have different values or even don't exist (if user1 has visited user2's profile but not the other way round).
I want to create reduced versions of my dataframe, easier to work with. As a result I want to extract groups of n users (n < m) with at least r relationships between. I need to develop a function that checks if there are at least r rows (relationships), combination of any group of n users (n < m). If so, the function returns a dataframe formed by them.
That is to say, the function should return a daframe (let's name it S) that meets the following requirements:
S is a subset of the original dataframe
NROW(S) >= r
NROW(unique(append(S[1],S[2]))) = n
Small example
This is a minimal example, where users ids are just one letter. There are 5 different users (a,b,c,d,e) and 10 relationships between them:
>df
user1 user2 views
1 a b 1
2 a c 1
3 a d 3
4 b a 1
5 c b 1
6 c d 2
7 c e 4
8 d a 5
9 d e 1
10 d c 2
For r = 8 n = 4, I try to extract a group of 4 users with at least 8 relationships between them. The output should be a dataframe of 8 rows that contain only 4 different user values in the first two columns (if any). There are 5 different 4-users combinations with the values above [(a,b,c,d) ,(a,b,c,e), (a,b,d,e), (a,c,d,e), (b,c,d,e)]. However only of one of them (a,b,c,d) includes 8 relationships between members. Output should be:
[1] "a" "b" "c" "d"
user1 user2 views
1 a b 1
2 a c 1
3 a d 3
4 b a 1
5 c b 1
6 c d 2
7 d a 5
8 d c 2
For r = 6 n = 4, the aim is to find a group of 4 users with 6 relationships between them. In this case there are 2 4-users combinations that meet the requirement of forming at least 6 rows [(a,b,c,d), (a,c,d,e)]. Output could be any of those:
[1] "a" "b" "c" "d"
user1 user2 views
1 a b 1
2 a c 1
3 a d 3
4 b a 1
5 c b 1
6 c d 2
7 d a 5
8 d c 2
[1] "a" "c" "d" "e"
user1 user2 views
1 a c 1
2 a d 3
3 c d 2
4 c e 4
5 d a 5
6 d c 2
7 d e 1
For r > 8, no 4-users combination is valid. There are no 4-users group with more than 8 relationships between them. Then, output should be NULL.
Solution (if dataframe was small)
A solutions for a small dataframe (that works for this minimal example) could be to get all possible combinations of n-users and iterate over them, checking if one of them meets the requirement of forming r relationships in df. Code could be something like this:
library(dplyr)
library(trotter)
obtainUserGroup <- function(df,n,r){
## Get unique letter _users_ in dataframe
us <- unique(append(df$user1,df$user2))
## All possible combinations of users in _us_ in groups of _n_ users
users <- cpv(n,us)
## Iterate over any possible group of _n_ users
for(i in 1:NROW(users)){
l <- as.character(users[i])
l <- as.data.frame(permutations(n,2,l),stringAsFactors=FALSE)
names(l) <- c("user1","user2")
# Check which combinations in l are part of df
dc <- semi_join(df,l,by = c("user1", "user2"))
if(NROW(dc) >= r) return(dc)
}
return(NULL)
}
df <- data.frame(c("a","a","a","b","c","c","c","d","d","d"), c("b","c","d","a","b","d","e","a","e","c"), c(1,1,3,1,1,2,4,5,1,2), stringsAsFactors=FALSE)
names(df) <- c("user1","user2","views")
n <- 4
r <- 8
obtainUserGroup(df,n,r)
Problem
My user dataframe is quite large. Trying to reduce a dataframe including thousand of users (m > 7000) users to one much smaller of just a hundred or a few hundreds (n << m) is troublesome. Iterating over the number of possible combinations is not feasible.
Is it possible to check all combinations in a different (much faster) way than the for-loop?
Is there any other way to approach this problem, different than checking all possible combinations?