PAT 1034&1114（并查集）

PAT1034(用了炒鸡多的map…） (:_」∠)

#include <iostream>
#include <stdio.h>
#include<stdlib.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <unordered_map>
#include <string.h>
#include <map>
#include <stack>
#define INF 0x3f3f3f3f

using namespace std;
const int MAXN = 2000;
int S[MAXN];
int T[MAXN];
map<string, int> nToi; //name to index
map<int, string> iTon; //index to name
map<string, int> tsum; //<root,timesum>
map<string, int> maxt;//<root,maxtime>
map<string, string> head;//<root,head>
map<string, int> ans; //<head,number of nodes>

int N, K;

int FindRoot(int n)
{
	if (S[n] < 0) return n;
	else return S[n] = FindRoot(S[n]);
}
void Union(int n1, int n2, int t)
{
	T[n1] += t;
	T[n2] += t;
	int R1 = FindRoot(n1); 
	int R2 = FindRoot(n2); 

	if (R1 != R2) {
		if (S[R1] < S[R2]) {//R2加到R1
			S[R1] += S[R2];
			S[R2] = R1;
			if (maxt[iTon[R1]] < maxt[iTon[R2]])
			{
				maxt[iTon[R1]] = maxt[iTon[R2]];
				head[iTon[R1]] = head[iTon[R2]];
			}
			
			if (T[n1] > maxt[iTon[R1]]) {
				maxt[iTon[R1]] = T[n1];
				head[iTon[R1]] = iTon[n1];
			}
			if (T[n2] > maxt[iTon[R1]]) {
				maxt[iTon[R1]] = T[n2];
				head[iTon[R1]] = iTon[n2];
			}

			tsum[iTon[R1]] += tsum[iTon[R2]] + t;
			tsum.erase(iTon[R2]);
		}
		else {
			S[R2] += S[R1];
			S[R1] = R2;
			if (maxt[iTon[R2]] < maxt[iTon[R1]])
			{
				maxt[iTon[R2]] = maxt[iTon[R1]];
				head[iTon[R2]] = head[iTon[R1]];
			}

			if (T[n1] > maxt[iTon[R2]]) {
				maxt[iTon[R2]] = T[n1];
				head[iTon[R2]] = iTon[n1];
			}
			if (T[n2] > maxt[iTon[R2]]) {
				maxt[iTon[R2]] = T[n2];
				head[iTon[R2]] = iTon[n2];
			}
			tsum[iTon[R2]] += tsum[iTon[R1]] + t;
			tsum.erase(iTon[R1]);
		}
	}
	else {
		tsum[iTon[R1]] += t;
		if (T[n1] > maxt[iTon[R1]]) {
			maxt[iTon[R1]] = T[n1];
			head[iTon[R1]] = iTon[n1];
		}
		if (T[n2] > maxt[iTon[R1]]) {
			maxt[iTon[R1]] = T[n2];
			head[iTon[R1]] = iTon[n2];
		}
	}


}
int main()
{
#ifdef  LIU
	FILE *ss;
	freopen_s(&ss, "1.txt", "r", stdin);
#endif 
	memset(T, 0, sizeof(T));
	string n1, n2;
	int t,ind;
	cin >> N >> K;
	for (int i = 0; i < N; i++)
	{
	
		cin >> n1 >> n2 >> t;
		if (!nToi.count(n1))
		{
			ind = nToi.size();
			nToi[n1] = ind;
			iTon[ind] = n1;
			S[ind] = -1;
			tsum[n1] = 0;
			maxt[n1] = t;
			head[n1] = n1;
		}
		if (!nToi.count(n2))
		{
			ind = nToi.size();
			nToi[n2] = ind;
			iTon[ind] = n2;
			S[ind] = -1;
			tsum[n2] = 0;
			maxt[n2] = t;
			head[n2] = n2;

		}
		Union(nToi[n1], nToi[n2], t);
	}
	int cnt = 0;
	for (auto &ts : tsum)
	{
		if (ts.second > K)
		{
			if (S[nToi[ts.first]] <- 2)
			{
				++cnt;
				ans[head[ts.first]] = abs(S[nToi[ts.first]]);
			}
		}
	}
	cout << cnt << endl;
	for (auto &a : ans)
	{
		cout << a.first << ' ' << a.second << endl;
	}

	return 0;
}

PAT1114

#include <iostream>
#include <stdio.h>
#include<stdlib.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <unordered_map>
#include <string.h>
#include <map>
#include <set>
#define INF 0x3f3f3f3f

using namespace std;
const int MAXN = 1100;
int N;
map<int,int> S;
typedef struct info
{
	int esum;
	int asum;
	int smallestID;
};

struct ans {
	int ID;
	int M;
	double avsets;
	double avarea;
}A[MAXN];

set<int> mem;

map<int, info> fams;

int findroot(int n)
{
	if (S[n] < 0) return n;
	else return S[n] = findroot(S[n]);
}

void Union(int n1, int n2)
{
	if (!mem.count(n2))
	{
		mem.insert(n2);
		S[n2] = -1;
		fams[n2].asum = 0;
		fams[n2].esum = 0;
		fams[n2].smallestID = n2;
	}

	int R1 = findroot(n1);
	int R2 = findroot(n2);
	if (R1 != R2)
	{
		if (R1 < R2)//R2添加到R1
		{
			S[R1] += S[R2];
			S[R2] = R1;
			fams[R1].asum += fams[R2].asum;
			fams[R1].esum += fams[R2].esum;
			fams[R1].smallestID = min(fams[R1].smallestID, fams[R2].smallestID);
			if (n1 < fams[R1].smallestID) fams[R1].smallestID = n1;
			if (n2 < fams[R1].smallestID) fams[R1].smallestID = n2;
			fams.erase(R2);
		}
		else
		{
			S[R2] += S[R1];
			S[R1] = R2;
			fams[R2].asum += fams[R1].asum;
			fams[R2].esum += fams[R1].esum;
			fams[R2].smallestID = min(fams[R1].smallestID, fams[R2].smallestID);
			if (n1 < fams[R2].smallestID) fams[R2].smallestID = n1;
			if (n2 < fams[R2].smallestID) fams[R2].smallestID = n2;
			fams.erase(R1);
		}
	}
}

bool cmp(ans a, ans b)
{
	if (a.avarea != b.avarea) return a.avarea > b.avarea;
	else return a.ID < b.ID;
}

void updateinfo(int n, int es, int a)
{
	int R = findroot(n);
	fams[R].asum += a;
	fams[R].esum += es;

}

void print()
{
	int cnt = fams.size();
	cout << cnt << endl;
	int i = 0;
	for (auto &f : fams)
	{
		A[i].ID = f.second.smallestID;
		A[i].M = 0 - S[findroot(f.second.smallestID)];
		A[i].avsets = double(f.second.esum) / A[i].M;
		A[i].avarea = double(f.second.asum) / A[i].M;
		++i;
	}
	sort(A, A + cnt, cmp);
	for (i = 0; i < cnt; i++)
	{
		printf("%04d %d %.3f %.3f\n", A[i].ID, A[i].M, A[i].avsets, A[i].avarea);
	}
}

int main()
{
#ifdef  LIU
	FILE *ss;
	freopen_s(&ss, "1.txt", "r", stdin);
#endif 
	int id, p1, p2, k, ch, es, a;
	cin >> N;
	for (int i = 0; i < N; i++)
	{
		cin >> id >> p1 >> p2 >> k;
		if (!mem.count(id)) { 
			mem.insert(id);
			S[id] = -1; 
			fams[id].asum = 0;
			fams[id].esum = 0;
			fams[id].smallestID = id;
		}
		if(p1!=-1)Union(id, p1);
		if(p2!=-1)Union(id, p2);
		for (int j = 0; j < k; j++)
		{
			cin >> ch;
			Union(id, ch);
		}
		cin >> es >> a;
		updateinfo(id, es, a);

	}
	print();

	return 0;
}