获取一个字符串对数组并返回一个包含所有连接项的数组

Question

我有一组名称对，例如：

[
  ['alison', 'jason'],
  ['alison', 'chris'],
  ['john', 'bill'],
  ['bill', 'alex'],
  ['alex', 'jack']
]

我正在尝试编写一个可以接受它并返回的方法

[
  ['alison', 'jason', 'chris'],
  ['john', 'bill', 'alex', 'jack']
]

优于 O(N^2) 时间。我的尝试是这样的：

def teams(arr)
  pair_hash = {}
  arr.each do |pair|
    if pair_hash[pair[0]].nil?
      pair_hash[pair[0]] = [pair[1]]
    else
      pair_hash[pair[0]].push(pair[1])
    end
  end
  teams = []
  pair_hash.map do |leader, team|
    teams.push(find_teammates(pair_hash, leader, team))
  end
  teams
end

def find_teammates(hash, leader, team)
  result = [leader]
  team.each do |member|
    if hash[member].nil?
      result += [member]
    else
      result += find_teammates(hash, member, hash[member])
    end
  end
  result
end

但是这个解决方案的结果是有额外的团队，而且我能想到的每个解决方案都涉及非常糟糕的时间复杂度。如果您知道如何解决这个问题，而无需暴力破解所有配对，我很想知道。

Answer 1

你很幸运，不相交集是我最喜欢的数据结构。这是一个快速的'n'dirty实现：

pairs = [['alison', 'jason'], ['alison', 'chris'], ['john', 'bill'], ['bill', 'alex'], ['alex', 'jack'], ['steve', 'alex']]

parents = {}

pairs.each do |x, y|
  # each person starts as their own set, and their own representative
  parents[x] ||= x
  parents[y] ||= y

  # find representative of x set
  x_parent = parents[x]
  loop do
    break if parents[x_parent] == x_parent
    x_parent = parents[x_parent]
  end

  # find representative of y set
  y_parent = parents[y]
  loop do
    break if parents[y_parent] == y_parent
    y_parent = parents[y_parent]
  end

  # union by changing y's representative
  parents[y_parent] = x_parent
  # path compression to speed up later unions
  parents[x] = x_parent
  parents[y] = x_parent
end

# group by set representative (some paths might not be compressed)
groups = parents.each_key.group_by do |person|
  parent = parents[person]
  loop do
    break if parents[parent] == parent
    parent = parents[parent]
  end
  parent
end

p groups.values
[["alison", "jason", "chris"], ["john", "bill", "alex", "jack", "steve"]]

这大约是 O(N+M)，其中 N 是人数，M 是对数。注意重复，例如在寻找一个集合的代表。如果你定义一个合适的类来进行查找，算法看起来会更简洁。

另外，我的路径压缩并不理想，如果将压缩放在代表性查找而不是联合中，则可以加快速度。