PAT (Advanced Level) 1034——搜索连通块 ( 附1006代码 )

#1034

这道题还是蛮曲折的
一开始看到电话网维护连通性的结构，第一个反映就是并查集
但是并查集多用来快速判断两个元素是否连通，不始于列举连通块中的元素

所以这道题本质上是一道利用搜索算法的图论
我们只要构造出电话网，使用dfs或者bfs搜索连通块即可

注意
通信关系是双向的，因此图中的边是双向边
一开始我使用数组模拟邻接表，添加单向边
就会出现这样的错误：

---

A -> B，time=10
B -> A，time=20
从A开始搜索，A打上 " vis " 标志，累计（A -> B）的时间，走到 " B "
在B点发现A已经打上了 " vis " 标志，就不会累计（B -> A）的时间

---

如果使用数组模拟邻接表，添加双向边，就可以解决上述的问题
但是当我意识到这个问题后，直接果断使用邻接矩阵实现图的存储，两个人之间通信时间直接累加即可
实际上数组模拟邻接表需要的空间更少，即使是双向边，N*2的空间就可以了（N个关系）
邻接矩阵确需要2N×2N（N个关系最多可能涉及2N个人）

Tip

第一次提交出现了段错误
是因为N个关系最多可能涉及2N个人
所以数据范围需要翻倍

//The output must be sorted according to 
//the alphabetical order of the names of the heads.
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<algorithm>
using namespace std;

const int N = 2000;
int n, K;
struct node1 {
	char name[5];
	int rela;
};
node1 po[N + 1];
int way[N + 1][N + 1] = {0};
int cnt = 0;
bool vis[N + 1];

int cmp(const node1& A, const node1& B) {
	if (A.name[0] < B.name[0]) return 1;
	else if (A.name[0] == B.name[0] && A.name[1] < B.name[1]) return 1;
	else if (A.name[0] == B.name[0] && A.name[1] == B.name[1] && A.name[2] < B.name[2]) return 1;
	else return 0;
}

bool eql(char* A, char* B) {
	return (A[0] == B[0] && A[1] == B[1] && A[2] == B[2]);
}

int fd(char* A) {
	for (int i = 1; i <= cnt; ++i)
		if (eql(A, po[i].name)) return i;
	return -1;
}

int init(char* A, int x) {
	int index = fd(A);
	if (index == -1) {
		index = ++cnt;
		for (int i=0;i<3;++i)
			po[index].name[i] = A[i];
		po[index].name[3] = '\0';
		po[index].rela = 0;
	}
	po[index].rela += x;
	return index;
}

int maxRela, person;
int sz, amount;
node1 ans[N / 2];
int ans_cnt = 0;

void ss(int t) {
	for (int i = 1; i <= cnt; ++i) {
		if (i != t && way[t][i] && !vis[i]) {
			vis[i] = 1;
			sz++;                         //size of gang
			amount += po[i].rela;  //amount of relation
			if (po[i].rela > maxRela) {
				maxRela = po[i].rela;
				person = i;
			}
			ss(i);
		}
	}
}

int main()
{
	scanf("%d%d",&n,&K);
	for (int i = 1; i <= n; ++i) {
		char A[5], B[5];
		int x;
		scanf("%s%s%d",&A,&B,&x);
		int _A = init(A, x);
		int _B = init(B, x);
		way[_A][_B] += x;
		way[_B][_A] += x;
	}
	for (int i = 1; i <= cnt; ++i) vis[i] = 0;
	for (int i = 1; i <= cnt; ++i) {
		if (!vis[i]) {
			vis[i] = 1;
			sz = 1;
			amount = po[i].rela;
			maxRela = po[i].rela;
			person = i;
			ss(i);
			if (sz > 2 && amount / 2 > K) {
				ans_cnt++;
				ans[ans_cnt].rela = sz;
				for (int i = 0; i < 3; ++i)
					ans[ans_cnt].name[i] = po[person].name[i];
				ans[ans_cnt].name[3] = '\0';
			}
		}
	}
	sort(ans + 1, ans + 1 + ans_cnt, cmp);
	printf("%d\n",ans_cnt);
	for (int i=1;i<=ans_cnt;++i) {
		printf("%s %d", ans[i].name, ans[i].rela);
		if (i < ans_cnt) printf("\n");
    }
	return 0;
}

---

#1006

我一开始还疑惑为什么没有给M的范围
因为一边读一边找最大最小值就可以了，根本不需要存储
注意字符串操作即可

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>

using namespace std;

const int N = 20;
char name1[N],name2[N];
int inTime = 1e9+7;
int outTime = 0;

int changeToInt(char *s) {
	int h, m, se;
	h = (s[0] - '0') * 10 + s[1] - '0';
	m = (s[3] - '0') * 10 + s[4] - '0';
	se = (s[6] - '0') * 10 + s[7] - '0';
	return h * 3600 + m * 60 + se;
}

int main()
{
	int n;
	scanf("%d",&n);
	for (int i = 1; i <= n; ++i) {
		char s[N];
		char t1[N], t2[N];
		scanf("%s%s%s",&s,&t1,&t2);
		int tm1 = changeToInt(t1);
		int tm2 = changeToInt(t2);
		if (tm1 < inTime) {
			inTime = tm1;
			for (int j = 0; j < strlen(s); ++j)
				name1[j] = s[j];
			name1[strlen(s)] = '\0';
		}
		if (tm2 > outTime) {
			outTime = tm2;
			for (int j = 0; j < strlen(s); ++j)
				name2[j] = s[j];
			name2[strlen(s)] = '\0';
		}
	}
	printf("%s %s",name1,name2);
	return 0;
}