题目例如以下：
One way that the police finds the head of a gang is to check people‘s phone calls. If there is a phone call between A and B, we say that A and B is related. The weight of a relation is defined to be the total time length of all the phone calls made between
the two persons. A "Gang" is a cluster of more than 2 persons who are related to each other with total relation weight being greater than a given threshold K. In each gang, the one with maximum total weight is the head. Now given a list of phone calls, you
are supposed to find the gangs and the heads.
Input Specification:
Each input file contains one test case. For each case, the first line contains two positive numbers N and K (both less than or equal to 1000), the number of phone calls and the weight threthold, respectively. Then N lines follow, each in the following format:
Name1 Name2 Time
where Name1 and Name2 are the names of people at the two ends of the call, and Time is the length of the call. A name is a string of three capital letters chosen from A-Z. A time length is a positive integer which is no more than 1000 minutes.
Output Specification:
For each test case, first print in a line the total number of gangs. Then for each gang, print in a line the name of the head and the total number of the members. It is guaranteed that the head is unique for each gang. The output must be sorted according
to the alphabetical order of the names of the heads.
Sample Input 1:
8 59 AAA BBB 10 BBB AAA 20 AAA CCC 40 DDD EEE 5 EEE DDD 70 FFF GGG 30 GGG HHH 20 HHH FFF 10
Sample Output 1:
2 AAA 3 GGG 3
Sample Input 2:
8 70 AAA BBB 10 BBB AAA 20 AAA CCC 40 DDD EEE 5 EEE DDD 70 FFF GGG 30 GGG HHH 20 HHH FFF 10
Sample Output 2:
0
这道题我最初想到的方法是用map中套map来表示全部人之间的通话关系，当中map第一层代表一个人，它内部的map记录着和他通话的全部人以及时长。这样对于单个人的统计是方便的，可是难以确定一个团体，后来我想到了用并查集来解决问题，我在这里遇到了麻烦，原因是我把三位字母依照26进制规则相应为了数字，这种相应关系不easy实现并查集。后来看了sunbaigui的解法，豁然开朗。我是比較完整的參考了他的代码。因此以下是对他代码的分析。
他是通过两个map和一个set实现了人名从0到N-1的编号：
map<string, int> name2id; map<int, string> id2name; set<string> name;
在输入姓名时。因为无法推断人数，因此无法马上生成相应关系表。因此在输入时把通话记录暂存在Call结构体中，同一时候把每一个名字都压入set。
在输入结束后，通过set就可以推断人数。这时候利用迭代器从头到尾遍历set，设立一个id变量。每处理一个人id+1，保证每一个名字相应的id不一样，相应方法为：
对于name2id图。将名字相应的索引存放id；对于id2name图。将id相应的索引存放名字。从而实现双向查找：
set<string>::iterator it1;
int id = 0;
for (it1=name.begin(); it1!=name.end(); it1++,++id){
name2id[*it1] = id, id2name[id]=*it1;
}
经过这种处理。每一个名字都能够相应为一个0到N-1的序号，从而能够实现正常的并查集。
对于0到N-1的这些结点，每一个结点有两个属性，权值和父结点。初始化集合时将父结点所有初始化为自己，对于每一个通话记录Call，仅仅要发生在A、B之间，A和B的权值均添加这个值（这也就造成了在这之后对权值和与阈值进行比較时要考虑二倍阈值，由于双向记录造成了时间的翻倍）。
然后合并集合A、B，处理完所有通话记录后就得到了并查集S。
接下来建立一张图map<int,Gang>来表示黑帮。当中第一维的int表示每一个集合的父结点，第二维黑帮结构体记录着帮内人数、通话总时长（推断是否满足阈值）、最大通话时长（推断老大）、老大的编号。
通过并查集的合并，会形成多个连通子图，对于同一个连通子图，仅仅要进行过路径压缩，通过findSet找到的父结点是一致的，通过这个特性，能够保证一个黑帮相应一个连通子图。
这时候仅仅须要遍历整个并查集中全部元素。先找到父结点top。假设map中不存在top这一维，说明这个黑帮还没有被建立。则建立新的黑帮，初始化黑帮的人数为1。通话总时长和最大通话时长（用于推断老大是谁）都是这个人的通话时长，老大也初始化为这个人。此后再发现属于同一个黑帮的人（父结点一致），这个黑帮人数+1，通话总时长加上这个人的时长，假设这个人的总时长大于当前最大通话时长，则把头目更新为这个人，如此下来，得到的就是全部黑帮的信息。
以下就是对黑帮进行筛选，注意要推断是否大于二倍阈值，最后输出就可以，为了保证依照人名字母顺序，能够先建立一个容器存放老大的名字和人数。然后对人名排序。最后输出。
以下是sunbaigui的代码：
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <stdio.h>
using namespace std;
typedef struct Node
{
int weight, parent;
}Node;
typedef struct Call
{
string a, b;
int t;
}Call;
typedef struct Gang
{
int head, num, sum, maxw;
Gang(){head=-1;num=0;sum=0;maxw=-1;}
};
vector<Node> p;//disjoint set
vector<Call> call;
map<string, int> name2id;
map<int, string> id2name;
set<string> name;
int n, k;
int realn;//number of distinct node
void InitSet()
{
p.resize(realn);
for (int i = 0; i < realn; ++i)
{
p[i].parent = i; p[i].weight = 0;
}
}
void CompressSet(int top, int x)
{
if (top != p[x].parent)
{
CompressSet(top, p[x].parent);
p[x].parent = top;
}
}
int FindSet(int x)
{
if (x != p[x].parent)
{
int top = FindSet(p[x].parent);
CompressSet(top, x);
}
return p[x].parent;
}
void UnionSet(int x, int y)
{
int a = FindSet(x);
int b = FindSet(y);
p[a].parent = b;
}
int main()
{
int n,k;
cin >> n >> k;
call.resize(n);
name.clear();
for (int i = 0; i < n; ++i)
{
cin>>call[i].a; cin>>call[i].b; cin>>call[i].t;
name.insert(call[i].a); name.insert(call[i].b);
}
//get the person number
realn = name.size();
name2id.clear();
id2name.clear();
set<string>::iterator it1;
int id = 0;
for (it1=name.begin(); it1!=name.end(); it1++,++id){
name2id[*it1] = id, id2name[id]=*it1;
}
//build disjoint set
InitSet();
for (int i = 0; i < call.size(); ++i)
{
int u = name2id[call[i].a]; int v = name2id[call[i].b]; int t = call[i].t;
p[u].weight += t; p[v].weight += t;
UnionSet(u, v);
}
//collect all set
map<int,Gang> allSet;//father and weight of set
map<int,Gang>::iterator it;
for (int i = 0; i < realn; ++i)
{
int top = FindSet(i);
it = allSet.find(top);
if (it != allSet.end())
{
allSet[top].sum += p[i].weight;
allSet[top].num++;
if (p[i].weight > allSet[top].maxw)
{
allSet[top].head = i;
allSet[top].maxw = p[i].weight;
}
}
else
{
Gang tmp;
tmp.head = i; tmp.maxw = p[i].weight;
tmp.num = 1; tmp.sum = p[i].weight;
allSet[top] = tmp;
}
}
//threthold gang
std::vector<Gang> gang;
for (it = allSet.begin(); it!=allSet.end(); it++)
if (it->second.sum > k * 2 && it->second.num > 2)
gang.push_back(it->second);
//output
vector<pair<string, int> > head;
for (int i = 0; i < gang.size(); ++i)
head.push_back(make_pair(id2name[gang[i].head],gang[i].num));
sort(head.begin(), head.end());
printf("%d\n",head.size());
for (int i = 0; i < head.size(); ++i)
cout<<head[i].first<<" "<<head[i].second<<endl;
return 0;
}