PAT甲级 1140——1147

1140.Look-and-say Sequence (20)

时间限制
400 ms
内存限制
65536 kB
代码长度限制
16000 B
判题程序
Standard
作者
CHEN, Yue
Look-and-say sequence is a sequence of integers as the following:

D, D1, D111, D113, D11231, D112213111, …
where D is in [0, 9] except 1. The (n+1)st number is a kind of description of the nth number. For example, the 2nd number means that there is one D in the 1st number, and hence it is D1; the 2nd number consists of one D (corresponding to D1) and one 1 (corresponding to 11), therefore the 3rd number is D111; or since the 4th number is D113, it consists of one D, two 1’s, and one 3, so the next number must be D11231. This definition works for D = 1 as well. Now you are supposed to calculate the Nth number in a look-and-say sequence of a given digit D.

Input Specification:

Each input file contains one test case, which gives D (in [0, 9]) and a positive integer N (<=40), separated by a space.

Output Specification:

Print in a line the Nth number in a look-and-say sequence of D.

Sample Input:
1 8
Sample Output:
1123123111

考差英语能力与语文理解能力。
看题目看了10多分钟，才看明白是啥意思。
就是用后一个字符串表示前面字符串的组成。
例如12332312311
那么下一个字符串来表示就是一个1——11
一个2——21 两个3——32
一个2——21 一个3——31
一个1——11 一个2——21
一个3——31 两个1——12
连起来就是112132213111213112，这就是我写的字符串的下一个。
两个vector来回搞就可以了

#include <bits/stdc++.h>
using namespace std;
vector<int> arr, temp; 
int main(void)
{
	int d, n;
	scanf("%d%d", &d, &n);
	int i, j;
	if (n == 1)
	{
		printf("%d", d);return 0;
	}
	if (n == 2)
	{
		printf("%d1", d);return 0;
	}
	arr.push_back(d);
	arr.push_back(1);
	for (i = 3; i <= n; i++)
	{
		temp.clear();
		for (j = 0; j < arr.size(); j++)
		{
			int cnt = 1;
			while (j < arr.size() - 1 && arr[j] == arr[j+1])
			{
				cnt++; j++;
			}
			temp.push_back(arr[j]);
			temp.push_back(cnt);
		}
		arr = temp;
	}
	for (i = 0; i < arr.size(); i++) printf("%d", arr[i]);
}

1141.PAT Ranking of Institutions (25)

时间限制
500 ms
内存限制
65536 kB
代码长度限制
16000 B
判题程序
Standard
作者
CHEN, Yue
After each PAT, the PAT Center will announce the ranking of institutions based on their students’ performances. Now you are asked to generate the ranklist.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (<=105), which is the number of testees. Then N lines follow, each gives the information of a testee in the following format:

ID Score School

where “ID” is a string of 6 characters with the first one representing the test level: “B” stands for the basic level, “A” the advanced level and “T” the top level; “Score” is an integer in [0, 100]; and “School” is the institution code which is a string of no more than 6 English letters (case insensitive). Note: it is guaranteed that “ID” is unique for each testee.

Output Specification:

For each case, first print in a line the total number of institutions. Then output the ranklist of institutions in nondecreasing order of their ranks in the following format:

Rank School TWS Ns

where “Rank” is the rank (start from 1) of the institution; “School” is the institution code (all in lower case); “TWS” is the total weighted score which is defined to be the integer part of “ScoreB/1.5 + ScoreA + ScoreT*1.5”, where “ScoreX” is the total score of the testees belong to this institution on level X; and “Ns” is the total number of testees who belong to this institution.

The institutions are ranked according to their TWS. If there is a tie, the institutions are supposed to have the same rank, and they shall be printed in ascending order of Ns. If there is still a tie, they shall be printed in alphabetical order of their codes.

Sample Input:
10
A57908 85 Au
B57908 54 LanX
A37487 60 au
T28374 67 CMU
T32486 24 hypu
A66734 92 cmu
B76378 71 AU
A47780 45 lanx
A72809 100 pku
A03274 45 hypu
Sample Output:
5
1 cmu 192 2
1 au 192 3
3 pku 100 1
4 hypu 81 2
4 lanx 81 2

PAT特色，数据检索题，用stl搞搞就行了。
建议大家抛弃cin和cout吧，这题如果用cin和cout如果写的不是很好是会TLE的（亲测）
而且如果以后搞专业OI，用cin很有可能光输入就TLE了，ios::sync_with_stdio(false)这样都阻止不了cin的TLE
注意一个点就行了，总分不要用int
如果用int的话，有可能两个分2.5+2.7，本来结果要约成5的，你用int就会变成2+2=4
实际上没什么意思，姥姥非要这么搞，弄的我WA了8发，题目也没讲清楚能不能中间约。。。

#include <bits/stdc++.h>
using namespace std;
struct node{
	string name;
	double score;
	int num;
	int rank;
	bool operator< (const node& b) const{
		if (score != b.score) return score > b.score;
		else if (num != b.num) return num < b.num;
		else return name < b.name;
	}
	node()
	{
		score = num = rank = 0;
	}
}arr[100005];
map<string, int> id;
int top = 1;
int main(void)
{
	int n;
	scanf("%d", &n);
	int i, j;
	char q[30], w[30];
	string Id, school;
	double s;
	for (i = 0; i < n; i++)
	{
		scanf("%s%lf%s", q, &s, w);
		Id = q, school = w;
		for (j = 0; j < school.size(); j++)
		{
			if (school[j] >= 'A' && school[j] <= 'Z')
			{
				school[j] += 'a' - 'A';
			}
		}
		if (id[school] == 0)
		{
			id[school] = top++;
		}
		int index = id[school];
		if (Id[0] == 'B') s /= 1.5;
		else if (Id[0] == 'T') s *= 1.5;
		arr[index].num += 1;
		arr[index].score += s;
		arr[index].name = school;
	}
	top--;
	for (i = 1; i <= top; i++) arr[i].score = (int)arr[i].score;//在sort之前记得就要约了，要不然sort会出错
	sort(arr+1, arr+top+1);
	arr[1].rank = 1;
	for (i = 2; i <= top; i++)
	{
		if (arr[i].score == arr[i-1].score) arr[i].rank = arr[i-1].rank;
		else arr[i].rank = i;
	}
	printf("%d\n", top);
	for (i = 1; i <= top; i++)
	{
		printf("%d %s %.0lf %d\n", arr[i].rank, arr[i].name.c_str(), arr[i].score, arr[i].num);
	}
}

1142 Maximal Clique (25)

时间限制
400 ms
内存限制
65536 kB
代码长度限制
16000 B
判题程序
Standard
作者
CHEN, Yue
A clique is a subset of vertices of an undirected graph such that every two distinct vertices in the clique are adjacent. A maximal clique is a clique that cannot be extended by including one more adjacent vertex. (Quoted from https://en.wikipedia.org/wiki/Clique_(graph_theory))

Now it is your job to judge if a given subset of vertices can form a maximal clique.

Input Specification:

Each input file contains one test case. For each case, the first line gives two positive integers Nv (<= 200), the number of vertices in the graph, and Ne, the number of undirected edges. Then Ne lines follow, each gives a pair of vertices of an edge. The vertices are numbered from 1 to Nv.

After the graph, there is another positive integer M (<= 100). Then M lines of query follow, each first gives a positive number K (<= Nv), then followed by a sequence of K distinct vertices. All the numbers in a line are separated by a space.

Output Specification:

For each of the M queries, print in a line “Yes” if the given subset of vertices can form a maximal clique; or if it is a clique but not a maximal clique, print “Not Maximal”; or if it is not a clique at all, print “Not a Clique”.

Sample Input:
8 10
5 6
7 8
6 4
3 6
4 5
2 3
8 2
2 7
5 3
3 4
6
4 5 4 3 6
3 2 8 7
2 2 3
1 1
3 4 3 6
3 3 2 1
Sample Output:
Yes
Yes
Yes
Yes
Not Maximal
Not a Clique

水题，判断一个给你的序列是不是两两相连（Clique），并且是否是最大的Clique。
数据很小，暴力做就行了。
如果是正规竞赛的话，应该是自己先预处理，把所有的最大Clique先用并查集或者其他数据结构先弄出来。
然后判断每个给你的序列是不是一个集合，并且集合的size和并查集的size是否一样大。
这题的话你直接就暴力搜，看看是否两两相连，再看看能不能加其他点进来。
这种做法设查询的次数为q，点数为n，那么时间复杂度为O(q*n^2)

#include <bits/stdc++.h>
using namespace std;
bool something[205][205];
int main(void)
{
	int n, m;
	scanf("%d%d", &n, &m);
	int i, j;
	int a, b;
	for (i = 0; i < m; i++)
	{
		scanf("%d%d", &a, &b);
		something[a][b]= something[b][a] = true;
	}
	scanf("%d", &m);
	int t, tmp;
	set<int> test;
	set<int>::iterator it;
	while (m--)
	{
		int flag = 0;
		test.clear();
		scanf("%d", &t);
		for (i = 0; i < t; i++)
		{
			scanf("%d", &tmp);
			for (it = test.begin(); it != test.end(); ++it)
			{
				if (!something[tmp][*it])
				{
					flag = 1;
				}
			}
			test.insert(tmp);
		}
		if (flag == 1)
		{
			printf("Not a Clique\n");
			continue;
		}
		for (i = 1 ; i <= n; i++)
		{
			bool temp = true;
			if (test.count(i)) continue;//我之所以用set就是想省一下查找的时间复杂度
										//但是后来发现好像这样作用不是很大，时间复杂度数量级没有改变
			for (it = test.begin(); it != test.end(); ++it)
			{
				if (!something[i][*it]) temp = false;
			}
			if (temp)
			{
				flag = 2;
				break;
			} 
		}
		if (flag == 0)
		{
			printf("Yes\n");
		}
		else
		{
			printf("Not Maximal\n");
		}
	}
}

1143 Lowest Common Ancestor (30)

时间限制
200 ms
内存限制
65536 kB
代码长度限制
16000 B
判题程序
Standard
作者
CHEN, Yue
The lowest common ancestor (LCA) of two nodes U and V in a tree is the deepest node that has both U and V as descendants.

A binary search tree (BST) is recursively defined as a binary tree which has the following properties:

The left subtree of a node contains only nodes with keys less than the node’s key.
The right subtree of a node contains only nodes with keys greater than or equal to the node’s key.
Both the left and right subtrees must also be binary search trees.
Given any two nodes in a BST, you are supposed to find their LCA.

Input Specification:

Each input file contains one test case. For each case, the first line gives two positive integers: M (<= 1000), the number of pairs of nodes to be tested; and N (<= 10000), the number of keys in the BST, respectively. In the second line, N distinct integers are given as the preorder traversal sequence of the BST. Then M lines follow, each contains a pair of integer keys U and V. All the keys are in the range of int.

Output Specification:

For each given pair of U and V, print in a line “LCA of U and V is A.” if the LCA is found and A is the key. But if A is one of U and V, print “X is an ancestor of Y.” where X is A and Y is the other node. If U or V is not found in the BST, print in a line “ERROR: U is not found.” or “ERROR: V is not found.” or “ERROR: U and V are not found.”.

Sample Input:
6 8
6 3 1 2 5 4 8 7
2 5
8 7
1 9
12 -3
0 8
99 99
Sample Output:
LCA of 2 and 5 is 3.
8 is an ancestor of 7.
ERROR: 9 is not found.
ERROR: 12 and -3 are not found.
ERROR: 0 is not found.
ERROR: 99 and 99 are not found.

题目就是求一棵树上的LCA，还是二叉搜索树。
那就好做了，给的两个点的最近祖先，一定是从根找下来，第一个大于两个数中的小的，小于两个数中大的的节点

#include <bits/stdc++.h>
using namespace std;
int pre[10005], in[10005];
set<int> se;
struct node{
    int data;
    node* left;
    node* right;
    node(int _data)
    {
        data = _data;
        left = right = NULL;
    }
};
bool flag = false;
int dfs(int mi, int ma, node* root)
{
	if (root->data == mi || root->data == ma)
	{
		flag =true;
		return root->data;
	}
	if (ma < root->data) return dfs(mi, ma, root->left);
	else if (root->data < mi) return dfs(mi, ma, root->right);
	else return root->data;
}
node* build(node* root,int prel,int prer,int inl,int inr)//前中序建树
{
    int i, left, right;
    for (i = inl; i <= inr; i++)
    {
        if (in[i] == pre[prel]) break;
    }
    if (!root) root = new node(in[i]);
    if (i != inr)
    {
        root->right = build(root->right, prel+1+i-1-inl+1, prer, i+1, inr);
    }
    if (i != inl)
    {
        root->left = build(root->left, prel+1, prel+1+i-1-inl, inl, i-1);
    }
    return root;
}
int main(void)
{
    int n, q;
    int i;
    scanf("%d%d", &q, &n);
    for (i = 0; i < n; i++)
    {
        scanf("%d", &pre[i]);
        in[i] = pre[i];
        se.insert(in[i]); 
    }
    sort(in, in+n);
    node* root = NULL;
    root = build(root, 0, n-1, 0, n-1);
    while (q--)
    {
    	flag = false;
    	int a, b;
    	scanf("%d%d", &a, &b);
    	if (se.find(a) == se.end() && se.find(b) == se.end())
    	{
    		printf("ERROR: %d and %d are not found.\n", a, b);
		}
		else if (se.find(a) == se.end())
		{
			printf("ERROR: %d is not found.\n", a);
		}
		else if (se.find(b) == se.end())
		{
			printf("ERROR: %d is not found.\n", b);
		}
		else
		{
			int mi = min(a, b), ma = max(a, b);
			int res = dfs(mi, ma, root);
			if (!flag)
			{
				printf("LCA of %d and %d is %d.\n", a, b, res);
			}
			else
			{
				if (res == a)
				{
					printf("%d is an ancestor of %d.\n", a, b);
				}
				else
				{
					printf("%d is an ancestor of %d.\n", b, a);
				}
			}
		}
	}
}

1144 The Missing Number (20)

时间限制
150 ms
内存限制
65536 kB
代码长度限制
16000 B
判题程序
Standard
作者
CHEN, Yue
Given N integers, you are supposed to find the smallest positive integer that is NOT in the given list.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (<= 105). Then N integers are given in the next line, separated by spaces. All the numbers are in the range of int.

Output Specification:

Print in a line the smallest positive integer that is missing from the input list.

Sample Input:
10
5 -25 9 6 1 3 4 2 5 17
Sample Output:
7

水题，瞎几把搞就行了。

#include <bits/stdc++.h>
using namespace std;
#define N (int)1e5+10
int arr[N];
int main(void)
{
	int n;
	scanf("%d", &n);
	int i, top = 0, j;
	for (i = 0; i< n; i++)
	{
		int temp;
		scanf("%d", &temp);
		if (temp > 0) arr[top++] = temp;
	}
	sort(arr, arr+top);
	if (arr[0] != 1)
	{
		printf("%d", 1);
		return 0;
	}
	for (i = 0; i < top - 1; i++)
	{
		if (arr[i] + 1 != arr[i+1] && arr[i] != arr[i+1])
		{
			printf("%d", arr[i]+1);
			return 0;
		}
	}
	printf("%d", arr[n-1]+1);
} 

1145 Hashing - Average Search Time (25)

时间限制
200 ms
内存限制
65536 kB
代码长度限制
16000 B
判题程序
Standard
作者
CHEN, Yue
The task of this problem is simple: insert a sequence of distinct positive integers into a hash table first. Then try to find another sequence of integer keys from the table and output the average search time (the number of comparisons made to find whether or not the key is in the table). The hash function is defined to be “H(key) = key % TSize” where TSize is the maximum size of the hash table. Quadratic probing (with positive increments only) is used to solve the collisions.

Note that the table size is better to be prime. If the maximum size given by the user is not prime, you must re-define the table size to be the smallest prime number which is larger than the size given by the user.

Input Specification:

Each input file contains one test case. For each case, the first line contains two positive numbers: MSize, N, and M, which are the user-defined table size, the number of input numbers, and the number of keys to be found, respectively. All the three numbers are no more than 104. Then N distinct positive integers are given in the next line. All the numbers in a line are separated by a space and are no more than 105.

Output Specification:

For each test case, in case it is impossible to insert some number, print in a line “X cannot be inserted.” where X is the input number. Finally print in a line the average search time for all the M keys, accurate up to 1 decimal place.

Sample Input:
4 5 4
10 6 4 15 11
11 4 15 2
Sample Output:
15 cannot be inserted.
2.8

哈希表裸题，不太熟悉哈希表策略de 姥姥的mooc了解一下~
注意一下判定一个数不在哈希表的判定条件是：index+j^2(0<=j<=size)，注意两个都是小于等于
也许有人要问我为什么右边这个也是小于等于size
明明index + size^2 = index (mod size)，所以这个等于有什么意义呢？
那么我只能告诉你，姥姥是这么规定的 or2
当初学ds的时候，我就对姥姥把树根的深度定义为0而不是1很不满。。。

#include <bits/stdc++.h>
using namespace std;
#define N (int)1e6+10
int arr[N];
bool isprime(int num)
{
	if (num == 1) return false;
	int i;
	for (i = 2; i * i <= num; i++)
	{
		if (num % i == 0) return false;
	}
	return true;
}
int main(void)
{
	int p, n, m, t;
	scanf("%d%d%d", &p, &n, &m);
	while (1)
	{
		if (!isprime(p)) p++;
		else break;
	}
	int i, j;
	double res = 0;
	for (i = 0; i < n; i++)
	{
		j = 1;
		scanf("%d", &t);
		int index = t % p;
		int k = index;
		while (arr[k])
		{
			k = (index + j * j) % p;
			if (++j == p)
			{
				printf("%d cannot be inserted.\n", t);
				break;
			}
		}
		if (j != p)
		{
			arr[k] = t;
		}
	}
	for (i = 0; i < m; i++)
	{
		j = 1;
		scanf("%d", &t);
		int index = t % p;
		int k = index;
		while (arr[k] != t && arr[k])
		{
			res++;
			k = (index + j * j) % p;
			if (++j == p+1)
			{
				break;
			}
		}
		res++;
	}
	printf("%.1lf", res / m);
}

1146 Topological Order (25)

时间限制
200 ms
内存限制
65536 kB
代码长度限制
16000 B
判题程序
Standard
作者
CHEN, Yue
This is a problem given in the Graduate Entrance Exam in 2018: Which of the following is NOT a topological order obtained from the given directed graph? Now you are supposed to write a program to test each of the options.

Input Specification:

Each input file contains one test case. For each case, the first line gives two positive integers N (<= 1,000), the number of vertices in the graph, and M (<= 10,000), the number of directed edges. Then M lines follow, each gives the start and the end vertices of an edge. The vertices are numbered from 1 to N. After the graph, there is another positive integer K (<= 100). Then K lines of query follow, each gives a permutation of all the vertices. All the numbers in a line are separated by a space.

Output Specification:

Print in a line all the indices of queries which correspond to “NOT a topological order”. The indices start from zero. All the numbers are separated by a space, and there must no extra space at the beginning or the end of the line. It is graranteed that there is at least one answer.

Sample Input:
6 8
1 2
1 3
5 2
5 4
2 3
2 6
3 4
6 4
5
1 5 2 3 6 4
5 1 2 6 3 4
5 1 2 3 6 4
5 2 1 6 3 4
1 2 3 4 5 6
Sample Output:
3 4

拓扑序裸题，模拟一下就行了。

#include <bits/stdc++.h>
using namespace std;
#define N (int)1e3+10
vector<int> something[N];
int rudu[N], temprudu[N];
int main(void)
{
	int n, m;
	scanf("%d%d", &n, &m);
	int i, j;
	int a, b;
	for (i = 0; i < m; i++)
	{
		scanf("%d%d", &a, &b);
		something[a].push_back(b);
		rudu[b]++;
	}
	int q, k;
	scanf("%d", &q);
	vector<int> res;
	for (j = 0; j < q; j++)
	{
		for (i = 1; i <= n; i++) temprudu[i] = rudu[i];
		vector<int> p;
		for (i = 0; i < n; i++)
		{
			scanf("%d", &a);
			p.push_back(a);
		}
		for (i = 0; i < n; i++)
		{
			if (temprudu[p[i]] != 0)
			{
				res.push_back(j);
				break;
			}
			else
			{
				for (k = 0; k < something[p[i]].size(); k++)
				{
					temprudu[something[p[i]][k]]--;
				}
			}
		}
	}
	for (i = 0; i < res.size() - 1; i++)
	{
		printf("%d ", res[i]);
	}
	printf("%d", res[i]);
	
}

1147 Heaps (30)

时间限制
200 ms
内存限制
65536 kB
代码长度限制
16000 B
判题程序
Standard
作者
CHEN, Yue
In computer science, a heap is a specialized tree-based data structure that satisfies the heap property: if P is a parent node of C, then the key (the value) of P is either greater than or equal to (in a max heap) or less than or equal to (in a min heap) the key of C. A common implementation of a heap is the binary heap, in which the tree is a complete binary tree. (Quoted from Wikipedia at https://en.wikipedia.org/wiki/Heap_(data_structure))

Your job is to tell if a given complete binary tree is a heap.

Input Specification:

Each input file contains one test case. For each case, the first line gives two positive integers: M (<= 100), the number of trees to be tested; and N (1 < N <= 1000), the number of keys in each tree, respectively. Then M lines follow, each contains N distinct integer keys (all in the range of int), which gives the level order traversal sequence of a complete binary tree.

Output Specification:

For each given tree, print in a line “Max Heap” if it is a max heap, or “Min Heap” for a min heap, or “Not Heap” if it is not a heap at all. Then in the next line print the tree’s postorder traversal sequence. All the numbers are separated by a space, and there must no extra space at the beginning or the end of the line.

Sample Input:
3 8
98 72 86 60 65 12 23 50
8 38 25 58 52 82 70 60
10 28 15 12 34 9 8 56
Sample Output:
Max Heap
50 60 65 72 12 23 86 98
Min Heap
60 58 52 38 82 70 25 8
Not Heap
56 12 34 28 9 8 15 10

bfs建树，嘿嘿嘿过年刚学的。
会建树应该就没问题了。其实可以不在建树过程中判断最大还是最小堆。
你可以把树建好再判断。但是这样会多花一次遍历的时间。。。。

#include <bits/stdc++.h>
using namespace std;
#define N (int)1e3+10
struct node{
    int data;
    node* left;
    node* right;
    node(int _data)
    {
        data = _data;
        left = right = NULL;
    }
};
int arr[N];
vector<int> res;
void print(node* root)
{
	if (root)
	{
		print(root->left);
		print(root->right);
		res.push_back(root->data);
	}
}
int main(void)
{
	int q, n, p, i, flag;
	scanf("%d%d", &q, &n);
	while (q--)
	{
		res.clear();
		flag = 0;
		for (i = 1; i <= n; i++)
		{
			scanf("%d", &arr[i]);
		}
		queue<node*> sup;
		node* root = new node(arr[1]);
		sup.push(root);
		i = 2;
		while (i != n + 1)
		{
			node* front = sup.front();
			sup.pop();
			front->left = new node(arr[i++]);
			sup.push(front->left);
			if (front->data > front->left->data)//写成函数好一点，我比较懒，就直接复制粘贴了。
			{
				if (flag == 2)
				{
					flag = -1; 
				}
				if (!flag) flag = 1;
			}
			else if (front->data < front->left->data)
			{
				if (flag == 1)
				{
					flag = -1; 
				}
				if (!flag) flag = 2;
			}
			if (i == n + 1) break;
			front->right = new node(arr[i++]);
			sup.push(front->right);
			if (front->data > front->right->data)
			{
				if (flag == 2)
				{
					flag = -1; 
				}
				if (!flag) flag = 1;
			}
			else if (front->data < front->right->data)
			{
				if (flag == 1)
				{
					flag = -1;  
				}
				if (!flag) flag = 2;
			}
		}
		if (flag == -1)
		{
			printf("Not Heap\n");
		}
		else if (flag == 1)
		{
			printf("Max Heap\n");
		 } 
		else printf("Min Heap\n");
		print(root);
		for (i = 0; i < res.size() - 1; i++)
		{
			printf("%d ", res[i]);
		}
		printf("%d\n", res[i]);
	}
	
}