Question

假设我有一个包含friends属性的用户对象。这个friends属性是一系列其他用户对象，因此是你的朋友。寻找不是你朋友的朋友的朋友的最快算法是什么，然后更进一步，寻找朋友的朋友，他们既不是你的朋友也不是朋友的朋友。< / p>

这是一个例子，以防上述情况令人困惑：

鲍勃是瑞恩的朋友。瑞恩是雅各布的朋友。雅各布是哈利的朋友。鲍勃不是雅各布的朋友。鲍勃不是哈利的朋友。瑞安不是哈利的朋友。雅各布有资格成为朋友的朋友。哈利有资格成为朋友朋友的朋友。

我在想BFS，但我很想知道是否其他人都解决了这样的问题？

Answer 1

我认为BFS方法在这个问题上最好。

让我们来看看这个简单的朋友树：

             David
           /
       Bob
     /     \ 
    /        Carl
Adam         
    \        Jim
     \     /
      Carl 
           \
             Sam

如果我们采用DFS方法来解决这个问题，我们首先会遍历Bob，看看他是David和Carl的朋友。由于我们采用DFS方法解决了这个问题，我们还不知道Carl是Adam的直接朋友。

如果我们采取了BFS方法，我们就可以确定Bob的朋友是否已经是Adam的朋友。

Answer 2

我认为这可以通过过滤器和三级循环完成：

friends = user.friends        # first- or second-level friends
friends3 = []                 # third-level friends
for friend in user.friends:
    for friend2 in friend.friends:    # friends of friends
        if friend2 not in friends:    # filter out existing friends
            friends.add(friend2)
            for friend3 in friend2.friends:    # friends of friends of friends
                if friend3 not in friends:     # filter out existing friends (of friends)
                    friends3.add(friend3)      # these match the criteria

Answer 3

int levels = 3;
HashSet<User>[] friendsPerLevel = new HashSet<User>[levels];

// set the 0 level with your immediate friends
friendsPerLevel[0] = new HashSet<User>(currentUser.Friends);

// fill the rest of the levels
for(int i = 1; i < levels; i++) {
  friendsPerLevel[i] = new HashSet<User>();

  // get all friends from the previous level
  foreach(User previousFriend in friendsPerLevel[i - 1]) {

    // loop through their friends list
    foreach(User friend in previousFriend.Friends) {

      // check if friend already exists in previous levels
      bool exists = false;
      for(int j = 0; j < i; j++) {
        if(friendsPerLevel[j].Contains(friend)) {
          exists = true;
          break;
        }
      }

      // add the new friend
      if(exists == false) {
        friendsPerLevel[i].Add(friend)
      }
    }
  }
}

寻找朋友的朋友

3 个答案: