1034. Head of a Gang (30) -string离散化 -map应用 -并查集

题目如下：

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进制规则对应为了数字，这样的对应关系不容易实现并查集，后来看了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;
}