2021-09-12 秋季PAT甲级满分总结

1.考前准备

我的考试准备经历可能比较特别，今年3月份花了1个月在MOOC看了翁老师的C语言课以及浙大的数据结构与算法分析课程，之前的基础就是大一学过C语言课，如今已经毕业一年了，浙大的数据结构网课是纯用C实现的，所以做起题来比较繁琐，像队列堆栈这种简单的线性结构也要自己实现，不过好处也是很明显的，手动实现多了就会对数据结构有更深的了解，也算是打下了比较好的基础吧。

网课看到哈希映射那里就没继续了，因为4月份有一些工作上的事情，结果这一搁置就到了9月份（对），我本来报名只是想参与一下，9月初甚至还想退款但是发现报名截止前几天不接受退款了，于是赶紧买了算法笔记和上机实战指南，等快递的时间把浙大网课哈希映射的部分看完了，大概4号书到了就开始补STL容器部分，从这时候开始练习用C++做题。

4号到10号基本就是在看书，题都没时间做，把以前的笔记拿出来配合算法笔记一起重温，发现浙大的网课内容还是有一点不足的，比如普通树的存储，最短路的dilkstra + DFS就没讲；但是算法笔记一些内容也没有网课讲的明白，像dilkstra还是陈老师直接演示比较直观，一下就明白了，光看文字确实太枯涩了。

看书一直持续到11号早上，11号下午就是考试时间了，说实话我心里还是很虚的，因为基本上就没怎么刷题，3月份上网课的时候会去做课后的作业，难度其实和PAT甲级一样，网课的内容十分精炼，上几十分钟网课就要去做PAT练习，可想而知有多困难，那时候一道题卡一天是很正常的事情，9月份以来代码量主要集中在测试上，比如动手实现一下STL容器和相关算法，或者自己建一棵树遍历一下，考完试看了一下PTA网站的做题量，PAT难度的题只有25道，还是3月份做的。

2.考试经历（附代码）

2.1第一题

#include <cstdio>
using namespace std;

typedef struct Node ar;
struct Node {
	int adr;
	int num;
};

int main() {
	int arrNum, queries, idxSum = 0, len = 0, idx, decNum = 1;
	scanf("%d%d", &arrNum, &queries);
	ar t[arrNum];
	for (int i = 0; i < arrNum; i++) {
		scanf("%d %d", &t[i].adr, &t[i].num);
		len += t[i].num;
//		printf("len = %d\n", len);
	}
	for (int i = 0; i < queries; i++) {
		scanf("%d", &idx);
//		printf("%d ", idx);
		if (idx >= len) {
			printf("Illegal Access\n");
		} else {
			int j = 0, tmpNum = 1;
			while (idx >= t[j].num) {
				idx -= t[j].num;
				tmpNum++;
				j++;
			}
			if (tmpNum > decNum) decNum = tmpNum;
			printf("%d\n", t[j].adr + idx*sizeof(int));
		}
		
	}
	printf("%d", decNum);
	return 0;
}

题目忘记摘了，等真题出来以后大家再自己对着看吧，题目大意其实就是把一个数组分成n段，每段有自己的初始地址和长度，比如第1段A1从1024开始，长度为5；第2段A2从2048开始，长度为4；那么给出一个下标7，则A[7] = A2【2】 = 2048 + 2 * sizeof(int) = 2056；
是不是很简单？但是原题真的很难读，我第一时间根本没明白是啥意思，这题花了大概五十多分钟，可以说是开门不顺了，后来做完以后，发现这题的通过率是最低的，我感觉难度主要在理解题意上了。

2.2第二题

#include <cstdio>
#include <stack>
#include <algorithm>
#include <map>
using namespace std;

bool cmp(int a, int b) {
	return a > b;
}

struct Node {
	int Weight;
	int Idx;
};

bool cmpw(struct Node a, struct Node b) {
	return a.Weight > b.Weight;
}

int main() {
	int Num;
	scanf("%d", &Num);
	int Hat[Num];
	struct Node W[Num];
	int tmpH[Num];
	stack<int> H;
	for (int i = 0; i < Num; i++) {
		scanf("%d", &Hat[i]);
		tmpH[i] = Hat[i];
//		H.push(tmpH);
	}
//	printf("%d\n", H.size());
	sort(Hat, Hat + Num, cmp);
	map<int, int> HatMap;
	for (int i = 0; i < Num; i++) {
		HatMap[Hat[i]] = i;
	}
	
	for (int i = 0; i < Num; i++) {
		scanf("%d", &W[i].Weight);
		W[i].Idx = i + 1;
	}
	sort(W, W + Num, cmpw);
	int check = 1;
	for (int i = Num - 1; i >= 0; i--) {
//		int tmp = H.top();
//		H.pop();
//		printf("%d ", tmpH[i]);
		if (check) {
			printf("%d", W[HatMap[tmpH[i]]].Idx);
			check = 0;
		} else {
			printf(" %d", W[HatMap[tmpH[i]]].Idx);	
		}
		
	}
	
	return 0;
}

题意：给一个N，然后第二行给N个帽子的Size（以压入堆栈的形式）， 第三行给N个人的体重（序号从1到N）；体重越大的人戴越大的帽子，然后让你输出拿帽子的顺序，就是把第二行的数据一个个弹出堆栈，然后匹配相应的体重，输出那个人的序号；N的数值大概是10的5次方还是6次方，我给忘了。
说实话这题我没想到什么巧妙的方法，当时的思路就是先读入帽子Size，存到堆栈和一个数组里，对数组排序以后用map映射到0、1、2、3这些序号上；体重的话把序号和体重绑在一起存进数组，然后按体重排序，最后弹出一个帽子Size --> 序号 -->体重数组下标，然后输出下标.序号。
这题写完只剩一个半小时了，因为中途出了点小问题，用stack容器存第二行数据不知道为什么只能存一半，排查了一会才发现，最后临时用一个数组代替stack。

2.3第三题

#include <cstdio>
#include <stack>
#include <algorithm>
#include <map>
using namespace std;

#define MaxVNum 110
#define Null -1
int Nv, Ne;
int G[MaxVNum][MaxVNum];
int Visit[MaxVNum] = {false};
int MaxSpotNum = 0;
void DFS(int V, int spotNum) {
	Visit[V] = true;
	if (spotNum > MaxSpotNum) {
		MaxSpotNum = spotNum;
	}
	for (int i = 1; i <= Nv; i++) {
		if (!Visit[i] && G[V][i] != Null) {
			DFS(i, spotNum + 1);
		}
	}
}

void Init() {
	for (int i = 0; i <= Nv; i++) {
		Visit[i] = false;
	}
}

int main() {
	int v1, v2, V;
	scanf("%d%d", &Nv, &Ne);
	for (int i = 1; i <= Nv; i++) {
		for (int j = 1; j <= Nv; j++) {
			G[i][j] = Null;
		}
	}
	for (int i = 1; i <= Ne; i++) {
		scanf("%d%d", &v1, &v2);
		G[v1][v2] = G[v2][v1] = 1;
	}
	for (int i = 1; i <= Nv; i++) {
		int CurSpotNum = MaxSpotNum;
		DFS(i, 1);
		Init();
		if (CurSpotNum != MaxSpotNum) {
			V = i;
			CurSpotNum = MaxSpotNum;
		}
	}
	
	printf("%d %d", V, MaxSpotNum);
	return 0;
}

非常简单的DFS，今年的图题应该算特别简单了，一个无向无权图的DFS，问从哪个顶点DFS能访问最多的顶点，输出该顶点以及访问最多的顶点数。
有两个条件，一个是优先从顶点编号最小的开始访问，另一个是同一个顶点不会访问两次，前者其实就是DFS的时候从1到N还是从N到1的问题，但是按照惯例大家都是从1到N遍历的，所以基本上相当于无条件，后者用一个Visit数组记录每个顶点是否被访问过就可以；最后每个顶点用一次DFS，记录最大访问数即可。

2.4第四题

//第四题
#include <cstdio>
#include <stack>
#include <algorithm>
#include <map>
#include <queue>
using namespace std;

typedef struct Node Nd;
struct Node {
	int P;
	int Val;
};

bool cmp(Nd a, Nd b) {
	return a.P < b.P;
}

typedef struct TNode *BinTree;
struct TNode {
	Nd data;
	BinTree Left;
	BinTree Right;
};

void Insert(BinTree &T, Nd X) {
	if (!T) {
		T = new TNode;
		T->data = X;
		T->Left = T->Right = NULL;
		return;
	}
	if (T->data.Val > X.Val) {
		Insert(T->Left, X);
	} else if (T->data.Val < X.Val){
		Insert(T->Right, X);
	}
} 

void LayerOrder(BinTree T) {
	queue<BinTree> q;
	q.push(T);
	int check  = 1;
	while (!q.empty()) {
		BinTree tmp = q.front();
		q.pop();
		if (check) {
			printf("%d", tmp->data.Val);
			check = 0;	
		} else {
			printf(" %d", tmp->data.Val);
		}
		
		if (tmp->Left) q.push(tmp->Left);
		if (tmp->Right) q.push(tmp->Right);
	}
	printf("\n");
	q.push(T);
	check  = 1;
	while (!q.empty()) {
		BinTree tmp = q.front();
		q.pop();
		if (check) {
			printf("%d", tmp->data.P);
			check = 0;
		} else {
			printf(" %d", tmp->data.P);
		}
		
		if (tmp->Left) q.push(tmp->Left);
		if (tmp->Right) q.push(tmp->Right);
	}
}

int main() {
	int N;
	scanf("%d", &N);
	Nd t[N];
	for (int i = 0; i < N; i++) {
		scanf("%d %d", &t[i].Val, &t[i].P);
	}
	sort(t, t+N, cmp);
	BinTree T = new TNode;
	T->Left = T->Right = NULL;
	T->data = t[0];
	for (int i = 1; i < N; i++) {
		Insert(T, t[i]);
	}
	LayerOrder(T);
	return 0;
}

说实话这题我一开始也没看懂，做到这一题的时候还剩一个小时，题目大概说的是有一种树，结点是一个结构体，包括值和优先级，给出N个结点，让你自己建树然后输出层序遍历结果，第一行输出值，第二行输出优先级。可见题目唯一难度在于如何建树。
题目里还用到了heapSort这种词，我一开始以为是堆排序，看了一下好像也没关系，因为题目里面示例建出来的树也不是一棵完全二叉树，就这样看了二十多分钟题目，也没有什么思路，出来看了一下这道题居然是通过率最高的，赶紧再回头看了下题目，试着往简单的方向去想，最后发现把数据按照优先级排好，然后按照二叉搜索树的插入方式就可以建出和示例一样的树。。。虽然不知道为什么，但是就这样去写了。
建树加层序遍历应该是最基本的东西了，写了不到十分钟写完了，层序遍历那里着急了直接复制粘贴遍历两次，一次输出值，一次输出优先级，结果一次就AC了，到最后也没明白这题啥意思，等以后大佬解答吧

3.总结和感想

21秋季的题应该算是比较简单了，第一次参加PAT，我感觉难度更多是在理解题意上面，理解题目以后这四道题都是一次AC了，都不用花时间测试和调试，结合自己的经验和经历给大家几个小建议吧

1、STL容器和algorithm头文件的一些算法（特别是sort）非常非常非常有用，不是说不会就写不出题目，但是会了能节省很多时间，能把精力集中在解决问题而不是编码上；
2、我个人建议是先看完浙大网课，同时把课后编程题做完（用C语言），再用算法笔记学习STL容器等应试的技巧，最后有时间再配合上机实战指南刷PAT（最后这一步我都没做），这些事情做完我相信在PAT甲级可以取得优良的成绩。

复习重点的话其实很多大佬总结过了，我这就做个小总结吧，当作参考
1、基本线性结构肯定要熟练，数组链表是实现各种数据结构的基础；
2、建树以及基本操作（插入删除等），尤其是二叉搜索树；时间紧张的话AVL和哈夫曼不看也行，但是堆的调整插入删除还是要理解的；
3、建图以及图的遍历，要结合树一起深刻理解DFS和BFS的思想及实现方法；最短路径Dilkstra配合DFS也要会，时间紧张的话最小生成树Prim之类的不看也行，其实写法和Dilkstra差不多。
4、理解映射的思想。