求微信群的覆盖

微信有很多群，现进行如下抽象：

(1) 每个微信群由一个唯一的gid标识；

(2) 微信群内每个用户由一个唯一的uid标识；

(3) 一个用户可以加入多个群；

(4) 群可以抽象成一个由不重复uid组成的集合，例如：

g1{u1, u2, u3}

g2{u1, u4, u5}

可以看到，用户u1加入了g1与g2两个群。

画外音，注意：

gid和uid都是uint64；

集合内没有重复元素；

 

假设微信有M个群(M为亿级别)，每个群内平均有N个用户(N为十级别).

 

现在要进行如下操作：

(1)  如果两个微信群中有相同的用户，则将两个微信群合并，并生成一个新微信群；

例如，上面的g1和g2就会合并成新的群：

g3{u1, u2, u3, u4, u5}；

画外音：集合g1中包含u1，集合g2中包含u1，合并后的微信群g3也只包含一个u1。

(2) 不断的进行上述操作，直到剩下所有的微信群都不含相同的用户为止；

将上述操作称：求群的覆盖。

 

设计算法，求群的覆盖，并说明算法时间与空间复杂度。 

#encoding: utf-8
######
#算法思想：
#1. 首先遍历所有群，得到uid到gid的映射, 比如输入：gid1:[uid1,uid2, uid3] gid2:[uid1,uid2, uid4] 
#   uid到gid的映射为：uid1-->[gid1, gid2] uid2-->[gid1, gid2] uid3->[gid1] uid4-->[gid2]
#2. 然后根据 uid到gid的映射 和 gid到uid的映射 就可以大大减少算法复杂度。算法复杂度为：O(m*n)
######
#本实现没有对空间复杂度进行优化 
def merge_group(groups ={}):
	#遍历group_list,得到用户到群的映射，此处复杂度为：O(m*n)
	#形如：uid1-->[gid1, gid3] uid2-->[gid2, gid4] uid3->[gid3, gid5]
	usr_map_group = {} #此处耗空间 O(m*n)
	for gid in groups:
		for uid in groups[gid]:
			if uid not in usr_map_group:
				usr_map_group[uid] = []
			usr_map_group[uid].append(gid)
			
	#print usr_map_group 
	
	#合并
	merged_uids = set() #记录用户是否已被合并到新的分组里面了 此处耗空间：用户数
	merged_gids = set() #记录分组是否已被合并到新的分组里面了 #此处消耗空间 m
	"""
	#内部函数，也可以不用递归实现
	def merge(uid, new_group):
		if uid in merged_uids:
			return
		merged_uids.add(uid)
		new_group.append(uid)
		group_list = usr_map_group[uid]
		for gid in group_list:
			if gid in merged_gids:
				continue
			for tmp_uid in groups[gid]:
				if tmp_uid not in merged_uids:
					merge(tmp_uid, new_group)
			merged_gids.add(gid)
	"""
	#非递归版本
	def merge(uid, new_group):
		if uid in merged_uids: #该用户已被合并
			return
		group_list = usr_map_group[uid] #此处可能会消耗较大空间， 用来记录需要合并的组
		while len(group_list) > 0:
			gid = group_list.pop(0)
			if gid in merged_gids: #该组已被合并
				continue
			merged_gids.add(gid)
			for tmp_uid in groups[gid]:
				if tmp_uid in merged_uids: #该用户已被合并
					continue
				merged_uids.add(tmp_uid)
				new_group.append(tmp_uid)
				group_list.extend(usr_map_group[tmp_uid])
		
	new_groups = [] #此处消耗空间 m*n, 保存合并后的所有分组
	#此处复杂度为： O(m*n)
	for uid in usr_map_group:
		#每次循环将uid（没被合并过）以及可以和uid一组的，放到新的分组里面
		new_group = []
		merge(uid, new_group)
		if new_group:
			new_groups.append(new_group)
	
	return new_groups
 
def main():
	test = {"group1": [11,12,13,14,15],"group2": [1,2,3,4,6,5],
	        "group3": [20,23,48],  "group4": [7,45,67,89],
			"group5": [34,35,36,20],"group6": [2,7,8,9,9,10]}
	print merge_group(test)
		
if __name__ == "__main__":		
	main()