2022 PAT 甲级（秋季）

今天第一次考 PAT 甲级，线上考点。
没有拿到满分，第二题卡了一个点，死活不知道哪里的问题，加上题目也没大读懂，不知道快排的原理，最后 97 分遗憾收场。。

没事，尽力了就行，以后再来！！

题目还没开放，凭记忆复述下题目吧：

第一题

题意
给定 n 个气球，每个气球有位置 pi。
要选择一个位置 x，使得从这个位置开始，往后的 m 个位置上的气球都可以扎破。
问，能扎破气球最多的位置 x 是多少？如果有多个，输出最小值。

$n\le 1e5,-1e6\le pi\le 1e6,m\le 1e3$

思路
因为位置只有 2e6 个，所以遍历所有位置作为 x 位置即可。
但是因为有负数，可以用 map，但是试了一下发现很耗时。
所以要考虑搞个偏移量，把所有位置加上 1e6 把负数平移成正数。

然后发现有一个点没过去，想了一下不知道哪的问题，就去看后面的题了。这个题花的时间太多了。

然后回过头来最后才看到错误所在：一开始平移加上的是 1e6，然后 -1e6就平移到 1e6 了，然后从 0 开始枚举的 x。但是发现答案 x 的值可以在 -1e6 之前，所以就不能从 0 开始枚举了。干脆平移多点，平移了 2e6 就行了。

Code

#include
using namespace std;

const int N = 6000010;
int n, m;
int a[N];
int mp[N], pre[N];

int main(){
	cin >> n >> m;
	for(int i=1;i<=n;i++){
		cin >> a[i];
		mp[a[i] + 2000000] ++;
	}
	
	for(int i=0;i<=4e6;i++)
	{
		if(i) pre[i] = pre[i-1];
		pre[i] += mp[i];
	}
	
	int ans, maxa = 0;
	for(int i=0;i<=4e6;i++)
	{
		int sum;
		if(i) sum = pre[i + m] - pre[i - 1];
		else sum = pre[i + m];
		
		if(sum > maxa){
			maxa = sum;
			ans = i;
		}
	}
	cout << ans - 2000000 << " " << maxa;
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

第二题

这道题没读懂，什么 run 什么的，样例解释里有个单词不认识，只是看样例和样例解释发现了点规律就直接写了，然后有一个点没过去，到最后也没看出来。。

第三题

题意
一共 n 个人，每个人有 mi 个崇拜者。
如果 x 崇拜 y 那么 y 为 x 的跟随者。
预选者为所有 跟随者个数 / 崇拜者个数 > T 的人。
定义最终 bos 为所有预选者中，其他预选者是其跟随者最多的人。
输出所有 boss。

思路
第三题也是个模拟题，直接记录就行了。
有个小技巧，在后面找最大的人的时候，不用二重循环判断和其他预选者的关系，而是先标记出来预选人数，然后记录每个人的跟随者中有多少预选人。
因为每个人的跟随者个数很少，这样就不超时了。（回过头来想起来的）

Code

#include
using namespace std;

const int N = 10010;
int n, m;
int in[N], ou[N];
unordered_map<int, bool> fol[N];
int ans[N];
int v[N];
bool mp[N];
vector<int> vv[N];

int main(){
	scanf("%d%d", &n, &m);
	
	for(int i=1;i<=n;i++)
	{
		int cnt; scanf("%d", &cnt);
		ou[i] = cnt;
		while(cnt --)
		{
			int x; scanf("%d", &x);
			in[x] ++;
			vv[x].push_back(i);
		}
	}
	
	int idx = 0;
	for(int i=1;i<=n;i++)
	{
		if(in[i]/ou[i] >= m) v[++idx] = i, mp[i] = 1;
	}
	
	int maxa = 0;
	for(int i=1;i<=idx;i++)
	{
		int x = v[i];
		for(int y : vv[x])
		{
			if(mp[y]) ans[x]++, maxa = max(maxa, ans[x]);
		}
	}
	
//	for(int i=1;i<=idx;i++)
//	{
//		int x = v[i];
//		for(int j=1;j<=idx;j++)
//		{
//			int y = v[j];
//			if(fol[y][x]) ans[x] ++, maxa = max(maxa, ans[x]);
//		}
//	}
	
	int id = 0;
	for(int i=1;i<=idx;i++)
	{
		int x = v[i];
		if(ans[x] == maxa) in[++id] = x;
	}
	
	for(int i=1;i<=id;i++)
	{
		cout << in[i];
		if(i != id) cout << ' ';
	}
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

第四题

题意
给定一棵二叉树的前序和中序遍历，判断其是不是 完美二叉树，完全二叉树，除了最后一层不满足的完美二叉树 和 其他二叉树。然后输出后序遍历。

思路
前序和中序遍历建树，输出后序遍历都是板子了，关键是如何判断是哪种二叉树。
除了完全二叉树，其他的三种都好判断，那就把其余三个都判了，不是的话就是完全二叉树。

• 首先判断是不是其他二叉树，如果层数 > $\lceil \sqrt{n+1}\rceil$ 的话，那就不可能是其余三种，那就是其他二叉树；
• 然后判断完美二叉树，如果 $2^{floor}=n+1$ 的话，就说明是；
• 然后判断最后一层非完美二叉树，这个比较难判断，需要将层序遍历求出来，然后当作完美二叉树依次编号，然后判断每个节点和其左右儿子的节点编号是不是 x 和 2x+1, 2x+2 的关系，如果发现有不满足，那么就是；
• 以上都不满足，那就是完全二叉树。

Code

#include
using namespace std;

const int N = 100010;
int n, m;
int in[N], pre[N];
int root;
vector<int> v, ans;
int maxdep;
unordered_map<int, int> dep, mp;

struct node{
	int l, r;
	int id;
};
map<int, node> a;

int build(int pl, int pr, int il, int ir)
{
	int root = pre[pl];
	int k = mp[root];
	
	if(k > il) a[root].l = build(pl+1, k-il+pl, il, k-1);
	if(k < ir) a[root].r = build(k-il+pl+1, pr, k+1, ir);
	
	return root;
}

void bfs()
{
	queue<int> que;
	que.push(root);
	dep[root] = 1;
	maxdep = 1;
	
	while(que.size())
	{
		int x = que.front(); que.pop();
		v.push_back(x);
		
		if(a[x].l){
			dep[a[x].l] = dep[x] + 1;
			maxdep = max(maxdep, dep[x] + 1);
			que.push(a[x].l);
		}
		if(a[x].r){
			dep[a[x].r] = dep[x] + 1;
			maxdep = max(maxdep, dep[x] + 1);
			que.push(a[x].r);
		}
	}
}

void dfs(int x)
{
	if(a[x].l) dfs(a[x].l);
	if(a[x].r) dfs(a[x].r);
	ans.push_back(x);
}

int main(){
	cin >> n;
	for(int i=1;i<=n;i++) cin >> in[i], mp[in[i]] = i;
	for(int i=1;i<=n;i++) cin >> pre[i];
	
	build(1, n, 1, n);
	
	root = pre[1];
	
	bfs();
	
	int flag = -1;
	
	int idx = -1;
	for(int x : v)
	{
		a[x].id = ++idx;
	}
	
	if(maxdep > ceil(log(n+1)*1.0/log(2))) flag = 0;
	
	for(int i=1;i<=n;i++)
	{
		if(a[i].l)
		{
			if(a[a[i].l].id != a[i].id * 2 + 1){
				if(flag == -1) flag = 3;
			}
		}
		if(a[i].r)
		{
			if(a[a[i].r].id != a[i].id * 2 + 2){
				if(flag == -1) flag = 3;
			}
		}
	}
	
	if(n == (1<<maxdep) - 1 && flag == -1) flag = 1;
	else if(flag == -1) flag = 2;
	
	cout << flag << endl;
	
	dfs(root);
	for(int i=0;i<ans.size();i++)
	{
		cout << ans[i];
		if(i != ans.size() - 1) cout << ' ';
	}
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

总结
其实还是觉得挺幸运的，因为昨天刚做了夏季的真题，发现考二叉树的三种遍历方式，然后就复习了一下，今天刚好考到了。
还有夏季的最后一题，昨天没写出来，看题解发现完全二叉树的父节点和子节点在编号上直接有关系，然后今天刚好用这个来判断。

虽然有点遗憾，但尽力就好，不是所有事情都尽如人意的。

有个小经验就是，如果有个点没过的话不要死磕，可以先跳过去做后面的，可能回过头来就知道哪里的问题了。

后面要努力刷题备战区域赛了！！